Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
       2                 :            : /* Copyright 2013-2016 IBM Corp. */
       3                 :            : 
       4                 :            : #include <skiboot.h>
       5                 :            : #include "container.h"
       6                 :            : 
       7                 :         17 : bool stb_is_container(const void *buf, size_t size)
       8                 :            : {
       9                 :            :         ROM_container_raw *c;
      10                 :            : 
      11                 :         17 :         c = (ROM_container_raw*) buf;
      12                 :         17 :         if (!buf || size < SECURE_BOOT_HEADERS_SIZE)
      13                 :          6 :                 return false;
      14                 :         11 :         if (be32_to_cpu(c->magic_number) != ROM_MAGIC_NUMBER )
      15                 :         10 :                 return false;
      16                 :          1 :         return true;
      17                 :            : }
      18                 :            : 
      19                 :          0 : uint32_t stb_payload_magic(const void *buf, size_t size)
      20                 :            : {
      21                 :            :         uint8_t *p;
      22                 :          0 :         if (!stb_is_container(buf, size))
      23                 :          0 :                 return 0;
      24                 :          0 :         p = (uint8_t*) buf;
      25                 :          0 :         return be32_to_cpu(*(be32*)(p+SECURE_BOOT_HEADERS_SIZE));
      26                 :            : }
      27                 :            : 
      28                 :          0 : uint64_t stb_sw_payload_size(const void *buf, size_t size)
      29                 :            : {
      30                 :            :         struct parsed_stb_container c;
      31                 :          0 :         if (!stb_is_container(buf, size))
      32                 :          0 :                 return 0;
      33                 :          0 :         if (parse_stb_container(buf, size, &c) != 0)
      34                 :          0 :                 return 0;
      35                 :          0 :         return be64_to_cpu(c.sh->payload_size);
      36                 :            : }
      37                 :            : 
      38                 :          0 : int parse_stb_container(const void* data, size_t len, struct parsed_stb_container *c)
      39                 :            : {
      40                 :          0 :         const size_t prefix_data_min_size = 3 * (EC_COORDBYTES * 2);
      41                 :          0 :         c->buf = data;
      42                 :          0 :         c->bufsz = len;
      43                 :          0 :         c->c = data;
      44                 :          0 :         c->ph = data += sizeof(ROM_container_raw);
      45                 :          0 :         c->pd = data += sizeof(ROM_prefix_header_raw) + (c->ph->ecid_count * ECID_SIZE);
      46                 :          0 :         c->sh = data += prefix_data_min_size + c->ph->sw_key_count * (EC_COORDBYTES * 2);
      47                 :          0 :         c->ssig = data += sizeof(ROM_sw_header_raw) +
      48                 :          0 :                 c->sh->ecid_count * ECID_SIZE;
      49                 :            : 
      50                 :          0 :         return 0;
      51                 :            : }
      52                 :            : 
      53                 :          0 : const uint8_t* stb_sw_payload_hash(const void *buf, size_t size)
      54                 :            : {
      55                 :            :         struct parsed_stb_container c;
      56                 :            : 
      57                 :          0 :         if (!stb_is_container(buf, size))
      58                 :          0 :                 return NULL;
      59                 :          0 :         if (parse_stb_container(buf, size, &c) != 0)
      60                 :          0 :                 return NULL;
      61                 :            : 
      62                 :          0 :         return c.sh->payload_hash;
      63                 :            : }
      64                 :            : 
      65                 :            : 
      66                 :          0 : void stb_print_data(const void* data, size_t len)
      67                 :            : {
      68                 :            :         char hash[1+SHA512_DIGEST_LENGTH*2];
      69                 :          0 :         char *h = hash;
      70                 :          0 :         char *d = (char*)data;
      71                 :            : 
      72                 :          0 :         assert(len <= SHA512_DIGEST_LENGTH);
      73                 :            : 
      74                 :          0 :         while(len) {
      75                 :          0 :                 snprintf(h, 3, "%02x", *d);
      76                 :          0 :                 h+=2;
      77                 :          0 :                 d++;
      78                 :          0 :                 len--;
      79                 :            :         }
      80                 :          0 :         *h='\0';
      81                 :          0 :         prlog(PR_NOTICE, "%s\n", hash);
      82                 :          0 : }