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 : }