From patchwork Wed Nov 24 07:56:23 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ruchika Gupta X-Patchwork-Id: 519344 Delivered-To: patch@linaro.org Received: by 2002:ac0:c605:0:0:0:0:0 with SMTP id p5csp9968118imj; Tue, 23 Nov 2021 23:56:51 -0800 (PST) X-Google-Smtp-Source: ABdhPJzOkrkBimqSbqIQOGe95U9clnFE7cTveH3rLFKt9tamRIdOaH07cy3lEy3FX1WGd/4hfXNb X-Received: by 2002:a50:da48:: with SMTP id a8mr21139426edk.146.1637740610822; Tue, 23 Nov 2021 23:56:50 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1637740610; cv=none; d=google.com; s=arc-20160816; b=FcDrv2PijQCVsaaCcD3ur2LQdXIB/b2aGWsCVgXDbKPqG7xFQ/Lg1YzhQo2qsCQ/Hy rynIGxZKXVLekf5nz10JFgLEjkQPcGWc2GPuRDsSX0PBRn7Y64I2u6iWXCSusSEhjDg5 SDy2ZXEy5+emQykTF34FRIuAqlIenoluIcMO+cZX7Ks+poU/Rg/6VxHWwXqjV39mkTrv aia75Iq4BOLBJhnkfwP6H/eDDUe50AMa1wLs69sObx639ce1gDy1xPSkvAYva1ydKjrT ZmOwhKZJiUs4tLDbthGmhsHNz39IVbr36R0gtLtJ8/3Hrt4Ql7ckjVISaJTPIFOfbd7K 2fZw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:message-id:date:subject:cc:to:from:dkim-signature; bh=S9Wy0MJ91UQocMD0CenpPbMyVV/KBErnTUosBm0fFIA=; b=pXW9FlLDB2v2TNtqYh2gNLeguJK6ccwJ30/GKEj32UADRXDRhnm5FOcXzmZ4Tzgp50 60N3QW3Gz4lZCLLCx+MxIcYiqbzuylVaRZER+wm4BHBLTEzk8aHAqvPidw9Ulo1zdUHT b4FbFAU6KkNOra3cy/Nz+7P2NjCSN7sKmuLoFF5w2BRxU4mjT8yyUJQLPY2kkCvGXJaz NFYAU+gYPPJHA9eRxUT3tIdMOaegGJ3cRHDOS0FuC/tcq+Jihcqwi/hCaN3pwnwS1hHm a3NHXE94ItvBoYy5CleD2I9m8RrvDVbq8maW2sffiHDq7DE4L8dzsYDDqqkdycpfdQCU +HYg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=IlLWjjcR; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from phobos.denx.de (phobos.denx.de. [2a01:238:438b:c500:173d:9f52:ddab:ee01]) by mx.google.com with ESMTPS id h10si31634136edf.379.2021.11.23.23.56.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 23 Nov 2021 23:56:50 -0800 (PST) Received-SPF: pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) client-ip=2a01:238:438b:c500:173d:9f52:ddab:ee01; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=IlLWjjcR; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: from h2850616.stratoserver.net (localhost [IPv6:::1]) by phobos.denx.de (Postfix) with ESMTP id 54D1783691; Wed, 24 Nov 2021 08:56:47 +0100 (CET) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=u-boot-bounces@lists.denx.de Authentication-Results: phobos.denx.de; dkim=pass (2048-bit key; unprotected) header.d=linaro.org header.i=@linaro.org header.b="IlLWjjcR"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id D828883718; Wed, 24 Nov 2021 08:56:44 +0100 (CET) X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on phobos.denx.de X-Spam-Level: X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.2 Received: from mail-pj1-x102b.google.com (mail-pj1-x102b.google.com [IPv6:2607:f8b0:4864:20::102b]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits)) (No client certificate requested) by phobos.denx.de (Postfix) with ESMTPS id 53690806A7 for ; Wed, 24 Nov 2021 08:56:40 +0100 (CET) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=ruchika.gupta@linaro.org Received: by mail-pj1-x102b.google.com with SMTP id nh10-20020a17090b364a00b001a69adad5ebso1886446pjb.2 for ; Tue, 23 Nov 2021 23:56:40 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=S9Wy0MJ91UQocMD0CenpPbMyVV/KBErnTUosBm0fFIA=; b=IlLWjjcRHuNmBgu4GfCK8ssVIgeT3pAJzWaO2EsOkXHM8CIgg0appMg9qmK7YUJWG7 u5uLLeXa9+y0uzERYFAWSTB0WxLXedlV44HylUdmSjmVEJq15MstyCid6qRPdhSWteUF l0Fr2mPGSpmRFP7P+Hepe/jfMmgRof56L6fu1evdiOMMD5/E9JIkzYti1rdFqJ82y23L OfDlsKVzdZbudtWCgEiRoguZGnc/w5tD5oWBSRPOXNOcRZxLwAYK6vRg95pf/XHtGiJh DalXa4wpkx/s8UxVq1qGT3LzFNEzBb64n3Io3LhRzdK+2/MAb0PXG1CmJ8X45YHsr+a6 CVsA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=S9Wy0MJ91UQocMD0CenpPbMyVV/KBErnTUosBm0fFIA=; b=TSatuLwMWsCo5GltQS2jkGIM6jm21eSewh/DKebNComB+ROd8jjdj9Vk1zHwVELYRj 55hTCePL9eY2Upbp/z+K7H06dI3PcGouv2nWq1hoT9/06BgCOSokfmib2p/royTzvESa tgSu984OvKhRW19IU7kYsyqYqKSqOv+2xZYM41MP3eBQij8G9KkzVFOzqGVTkLtKXj/i jqwk61mvHIKr1nCg5lOKB1VXmN9rPPvNRBM1aHcU9s5UrCx8lFg27J0wfqCOBiQGTlL4 tsDHUyzU2wYj/iRoLyId4HOujqIYfFTNOrSgUaGQYSSk8PXikERPU9LwhlSueNVuYekz tPjQ== X-Gm-Message-State: AOAM531qaYTqEOFs2d5ekcdT5qO367etoWF8nzlHgxeKnoA0TA22trtX NgUT0KQ8xFxJ+xuS5L9KvM7gihvrdeLVDA== X-Received: by 2002:a17:90a:6045:: with SMTP id h5mr12712909pjm.147.1637740598176; Tue, 23 Nov 2021 23:56:38 -0800 (PST) Received: from localhost.localdomain ([106.215.91.18]) by smtp.gmail.com with ESMTPSA id q9sm10775420pfj.114.2021.11.23.23.56.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 23 Nov 2021 23:56:37 -0800 (PST) From: Ruchika Gupta To: u-boot@lists.denx.de, ilias.apalodimas@linaro.org, xypron.glpk@gmx.de, agraf@csgraf.de Cc: Ruchika Gupta Subject: [v3][PATCH 1/3] efi_loader: Add check for event log passed from firmware Date: Wed, 24 Nov 2021 13:26:23 +0530 Message-Id: <20211124075625.197449-1-ruchika.gupta@linaro.org> X-Mailer: git-send-email 2.25.1 MIME-Version: 1.0 X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.37 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" X-Virus-Scanned: clamav-milter 0.103.2 at phobos.denx.de X-Virus-Status: Clean Platforms may have support to measure their initial firmware components and pass the event log to u-boot. The event log address can be passed in property tpm_event_log_addr and tpm_event_log_size of the tpm node. Platforms may choose their own specific mechanism to do so. A weak function is added to check if even log has been passed to u-boot from earlier firmware components. If available, the eventlog is parsed to check for its correctness and further event logs are appended to the passed log. Signed-off-by: Ruchika Gupta --- v3: Return as soon as you detect error v2: Moved firmware eventlog code parsing to tcg2_get_fw_eventlog() lib/efi_loader/efi_tcg2.c | 322 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 311 insertions(+), 11 deletions(-) diff --git a/lib/efi_loader/efi_tcg2.c b/lib/efi_loader/efi_tcg2.c index 8c1f22e337..ebd7847957 100644 --- a/lib/efi_loader/efi_tcg2.c +++ b/lib/efi_loader/efi_tcg2.c @@ -324,6 +324,45 @@ __weak efi_status_t platform_get_tpm2_device(struct udevice **dev) return EFI_NOT_FOUND; } +/** + * platform_get_eventlog() - retrieve the eventlog address and size + * + * This function retrieves the eventlog address and size if the underlying + * firmware has done some measurements and passed them. + * + * This function may be overridden based on platform specific method of + * passing the eventlog address and size. + * + * @dev: udevice + * @addr: eventlog address + * @sz: eventlog size + * Return: status code + */ +__weak efi_status_t platform_get_eventlog(struct udevice *dev, u64 *addr, + u32 *sz) +{ + const u64 *basep; + const u32 *sizep; + + basep = dev_read_prop(dev, "tpm_event_log_addr", NULL); + if (!basep) + return EFI_NOT_FOUND; + + *addr = be64_to_cpup((__force __be64 *)basep); + + sizep = dev_read_prop(dev, "tpm_event_log_size", NULL); + if (!sizep) + return EFI_NOT_FOUND; + + *sz = be32_to_cpup((__force __be32 *)sizep); + if (*sz == 0) { + log_debug("event log empty\n"); + return EFI_NOT_FOUND; + } + + return EFI_SUCCESS; +} + /** * tpm2_get_max_command_size() - get the supported max command size * @@ -1181,6 +1220,250 @@ static const struct efi_tcg2_protocol efi_tcg2_protocol = { .get_result_of_set_active_pcr_banks = efi_tcg2_get_result_of_set_active_pcr_banks, }; +/** + * parse_event_log_header() - Parse and verify the event log header fields + * + * @buffer: Pointer to the event header + * @size: Size of the eventlog + * @pos: Position in buffer after event log header + * + * Return: status code + */ +efi_status_t parse_event_log_header(void *buffer, u32 size, u32 *pos) +{ + struct tcg_pcr_event *event_header = (struct tcg_pcr_event *)buffer; + int i = 0; + + if (size < sizeof(*event_header)) + return EFI_COMPROMISED_DATA; + + if (get_unaligned_le32(&event_header->pcr_index) != 0 || + get_unaligned_le32(&event_header->event_type) != EV_NO_ACTION) + return EFI_COMPROMISED_DATA; + + for (i = 0; i < sizeof(event_header->digest); i++) { + if (event_header->digest[i] != 0) + return EFI_COMPROMISED_DATA; + } + + *pos += sizeof(*event_header); + + return EFI_SUCCESS; +} + +/** + * parse_specid_event() - Parse and verify the specID Event in the eventlog + * + * @dev: udevice + * @buffer: Pointer to the start of the eventlog + * @log_size: Size of the eventlog + * @pos: Offset in the evenlog where specID event starts + * + * Return: status code + * @pos Offset in the eventlog where the specID event ends + * @digest_list: list of digests in the event + */ +efi_status_t parse_specid_event(struct udevice *dev, void *buffer, u32 log_size, + u32 *pos, + struct tpml_digest_values *digest_list) +{ + struct tcg_efi_spec_id_event *spec_event; + struct tcg_pcr_event *event_header = (struct tcg_pcr_event *)buffer; + size_t spec_event_size; + u32 active = 0, supported = 0, pcr_count = 0, alg_count = 0; + u32 spec_active = 0; + u16 hash_alg, hash_sz; + u8 vendor_sz; + int err, i; + + /* Check specID event data */ + spec_event = (struct tcg_efi_spec_id_event *)((uintptr_t)buffer + *pos); + /* Check for signature */ + if (memcmp(spec_event->signature, TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03, + sizeof(TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03))) { + log_err("specID Event: Signature mismatch\n"); + return EFI_COMPROMISED_DATA; + } + + if (spec_event->spec_version_minor != + TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MINOR_TPM2 || + spec_event->spec_version_major != + TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MAJOR_TPM2) + return EFI_COMPROMISED_DATA; + + if (spec_event->number_of_algorithms > MAX_HASH_COUNT || + spec_event->number_of_algorithms < 1) { + log_err("specID Event: Number of algorithms incorrect\n"); + return EFI_COMPROMISED_DATA; + } + + alg_count = spec_event->number_of_algorithms; + + err = tpm2_get_pcr_info(dev, &supported, &active, &pcr_count); + if (err) + return EFI_DEVICE_ERROR; + + digest_list->count = 0; + /* + * We may need to worry about the order of algs in this structure as + * subsequent entries in event should be in same order + */ + for (i = 0; i < alg_count; i++) { + hash_alg = + get_unaligned_le16(&spec_event->digest_sizes[i].algorithm_id); + hash_sz = + get_unaligned_le16(&spec_event->digest_sizes[i].digest_size); + + if (!(supported & alg_to_mask(hash_alg))) { + log_err("specID Event: Unsupported algorithm\n"); + return EFI_COMPROMISED_DATA; + } + digest_list->digests[digest_list->count++].hash_alg = hash_alg; + + spec_active |= alg_to_mask(hash_alg); + } + + /* TCG spec expects the event log to have hashes for all active PCR's */ + if (spec_active != active) { + /* + * Previous stage bootloader should know all the active PCR's + * and use them in the Eventlog. + */ + log_err("specID Event: All active hash alg not present\n"); + return EFI_COMPROMISED_DATA; + } + + /* + * the size of the spec event and placement of vendor_info_size + * depends on supported algoriths + */ + spec_event_size = + offsetof(struct tcg_efi_spec_id_event, digest_sizes) + + alg_count * sizeof(spec_event->digest_sizes[0]); + + vendor_sz = *(uint8_t *)((uintptr_t)buffer + *pos + spec_event_size); + + spec_event_size += sizeof(vendor_sz) + vendor_sz; + *pos += spec_event_size; + + if (get_unaligned_le32(&event_header->event_size) != spec_event_size) { + log_err("specID event: header event size mismatch\n"); + /* Right way to handle this can be to call SetActive PCR's */ + return EFI_COMPROMISED_DATA; + } + + return EFI_SUCCESS; +} + +efi_status_t tcg2_parse_event(struct udevice *dev, void *buffer, u32 log_size, + u32 *offset, struct tpml_digest_values *digest_list, + u32 *pcr) +{ + struct tcg_pcr_event2 *event = NULL; + u32 event_type, count, size, event_size; + size_t pos; + + if (*offset > log_size) + return EFI_COMPROMISED_DATA; + + event = (struct tcg_pcr_event2 *)((uintptr_t)buffer + *offset); + + *pcr = get_unaligned_le32(&event->pcr_index); + + event_size = tcg_event_final_size(digest_list); + + if (*offset + event_size > log_size) { + log_err("Event exceeds log size\n"); + return EFI_COMPROMISED_DATA; + } + + event_type = get_unaligned_le32(&event->event_type); + + /* get the count */ + count = get_unaligned_le32(&event->digests.count); + if (count != digest_list->count) + return EFI_COMPROMISED_DATA; + + pos = offsetof(struct tcg_pcr_event2, digests); + pos += offsetof(struct tpml_digest_values, digests); + + for (int i = 0; i < digest_list->count; i++) { + u16 alg; + u16 hash_alg = digest_list->digests[i].hash_alg; + u8 *digest = (u8 *)&digest_list->digests[i].digest; + + alg = get_unaligned_le16((void *)((uintptr_t)event + pos)); + + if (alg != hash_alg) + return EFI_COMPROMISED_DATA; + + pos += offsetof(struct tpmt_ha, digest); + memcpy(digest, (void *)((uintptr_t)event + pos), alg_to_len(hash_alg)); + pos += alg_to_len(hash_alg); + } + + size = get_unaligned_le32((void *)((uintptr_t)event + pos)); + event_size += size; + pos += sizeof(u32); /* tcg_pcr_event2 event_size*/ + pos += size; + + /* make sure the calculated buffer is what we checked against */ + if (pos != event_size) + return EFI_COMPROMISED_DATA; + + if (pos > log_size) + return EFI_COMPROMISED_DATA; + + *offset += pos; + + return EFI_SUCCESS; +} + +efi_status_t tcg2_get_fw_eventlog(struct udevice *dev, void *log_buffer, + size_t *log_sz) +{ + struct tpml_digest_values digest_list; + void *buffer; + efi_status_t ret; + u32 pcr, pos; + u64 base; + u32 sz; + + ret = platform_get_eventlog(dev, &base, &sz); + if (ret != EFI_SUCCESS) + return ret; + + if (sz > TPM2_EVENT_LOG_SIZE) + return EFI_VOLUME_FULL; + + buffer = (void *)base; + pos = 0; + /* Parse the eventlog to check for its validity */ + ret = parse_event_log_header(buffer, sz, &pos); + if (ret || pos > sz) + return EFI_COMPROMISED_DATA; + + ret = parse_specid_event(dev, buffer, sz, &pos, &digest_list); + if (ret || pos > sz) { + log_err("Error parsing SPEC ID Event\n"); + return EFI_COMPROMISED_DATA; + } + + while (pos < sz) { + ret = tcg2_parse_event(dev, buffer, sz, &pos, &digest_list, + &pcr); + if (ret) { + log_err("Error parsing event\n"); + return ret; + } + } + + memcpy(log_buffer, buffer, sz); + *log_sz = sz; + + return ret; +} + /** * create_specid_event() - Create the first event in the eventlog * @@ -1340,6 +1623,12 @@ static efi_status_t efi_init_event_log(void) * last log entry */ memset(event_log.buffer, 0xff, TPM2_EVENT_LOG_SIZE); + + /* + * The log header is defined to be in SHA1 event log entry format. + * Setup event header + */ + event_header = (struct tcg_pcr_event *)event_log.buffer; event_log.pos = 0; event_log.last_event_size = 0; event_log.get_event_called = false; @@ -1347,20 +1636,31 @@ static efi_status_t efi_init_event_log(void) event_log.truncated = false; /* - * The log header is defined to be in SHA1 event log entry format. - * Setup event header + * Check if earlier firmware have passed any eventlog. Different + * platforms can use different ways to do so */ - event_header = (struct tcg_pcr_event *)event_log.buffer; - put_unaligned_le32(0, &event_header->pcr_index); - put_unaligned_le32(EV_NO_ACTION, &event_header->event_type); - memset(&event_header->digest, 0, sizeof(event_header->digest)); - ret = create_specid_event(dev, (void *)((uintptr_t)event_log.buffer + sizeof(*event_header)), - &spec_event_size); + ret = tcg2_get_fw_eventlog(dev, event_log.buffer, &event_log.pos); + /* + * If earlier firmware hasn't passed any eventlog, go ahead and + * create the eventlog header + */ + if (ret == EFI_NOT_FOUND) { + put_unaligned_le32(0, &event_header->pcr_index); + put_unaligned_le32(EV_NO_ACTION, &event_header->event_type); + memset(&event_header->digest, 0, sizeof(event_header->digest)); + ret = create_specid_event(dev, + (void *)((uintptr_t)event_log.buffer + + sizeof(*event_header)), + &spec_event_size); + if (ret != EFI_SUCCESS) + goto free_pool; + put_unaligned_le32(spec_event_size, &event_header->event_size); + event_log.pos = spec_event_size + sizeof(*event_header); + event_log.last_event_size = event_log.pos; + } + if (ret != EFI_SUCCESS) goto free_pool; - put_unaligned_le32(spec_event_size, &event_header->event_size); - event_log.pos = spec_event_size + sizeof(*event_header); - event_log.last_event_size = event_log.pos; ret = create_final_event(); if (ret != EFI_SUCCESS) From patchwork Wed Nov 24 07:56:24 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ruchika Gupta X-Patchwork-Id: 519345 Delivered-To: patch@linaro.org Received: by 2002:ac0:c605:0:0:0:0:0 with SMTP id p5csp9968289imj; Tue, 23 Nov 2021 23:57:01 -0800 (PST) X-Google-Smtp-Source: ABdhPJzsrbI0vkare280dQCJNWRC9f6j/Pyq25GDc9Pjhp++ezf4DGDlkSYfcvIkrCv7xkfKFUM9 X-Received: by 2002:a17:906:31c2:: with SMTP id f2mr17320229ejf.341.1637740621369; Tue, 23 Nov 2021 23:57:01 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1637740621; cv=none; d=google.com; s=arc-20160816; b=iaMFhePIRxYMmcA9+PT12Vy0KY7O+TRY1HnbmA6uUaEAz/NXWLxCDIj1yXBjWsziAd 280dAtA2IdpxnB4QxpNvEwO4Lwtvlvz0MgLFd0e8KuHOKPeb1HABq+pwFySIwKePG5Qv BLUqE9Ybns8odiJkRbEPgP1iUzFSTFETPvD4Bxn+K+OhIXOz1pmcYIi7NSCbEua7zZRC WAJzQC/wTUluGB/Qiyas1PhfWbeXPv8jlge5M6MfJMCMSDC52KtnuKmsfaq49UaU/GXN cvzCnzDYwD2xZ/jhOWFTQW6ZG6Bl5hIzRp6u8kRkOw61txQxD08Gg9sZPBj2fbCdvKs1 J3zg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:dkim-signature; bh=CENfc8gSIOvN1khuUO8kQjgl1eL7mjb4JvMs2DCmxkc=; b=oNgOmw+Gh82iL/4c0/as2fSoMGukzLf5WW1JDNj6jREKKjIeAvFzNfZrEw6D9gE+4f W5nZLwKwbLX69TW8O3H3gVMsRNl/Sf1sA3R6ZrY00U0RZkJvFyPspGG6b1Y3lF2TJy6Q DUgeOABxbIDHm2VtDDjC7kFbE4ZTKRd1xmBSqf3tEgrg6epXn0kFeL1E3k2vBAF63xxP cM+r7qtS7+YurvnpD859RPglpB8zCHKTvXPmMAMVAMHBmPZHzfQ96TJkCXM2L0o6WH43 SfsD2GjPKkXJ1R0ick+RQkihEC734ClSkNfNlTikRHWgJxcoMVRkpURcoNrWAR6voRY6 saiA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=jbOi9yZX; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from phobos.denx.de (phobos.denx.de. [85.214.62.61]) by mx.google.com with ESMTPS id qf24si45508954ejc.251.2021.11.23.23.57.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 23 Nov 2021 23:57:01 -0800 (PST) Received-SPF: pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 as permitted sender) client-ip=85.214.62.61; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=jbOi9yZX; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: from h2850616.stratoserver.net (localhost [IPv6:::1]) by phobos.denx.de (Postfix) with ESMTP id 1769283731; Wed, 24 Nov 2021 08:57:00 +0100 (CET) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=u-boot-bounces@lists.denx.de Authentication-Results: phobos.denx.de; dkim=pass (2048-bit key; unprotected) header.d=linaro.org header.i=@linaro.org header.b="jbOi9yZX"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id 6EE5583731; Wed, 24 Nov 2021 08:56:57 +0100 (CET) X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on phobos.denx.de X-Spam-Level: X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.2 Received: from mail-pl1-x62d.google.com (mail-pl1-x62d.google.com [IPv6:2607:f8b0:4864:20::62d]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits)) (No client certificate requested) by phobos.denx.de (Postfix) with ESMTPS id 9EDB783737 for ; Wed, 24 Nov 2021 08:56:51 +0100 (CET) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=ruchika.gupta@linaro.org Received: by mail-pl1-x62d.google.com with SMTP id v19so1171732plo.7 for ; Tue, 23 Nov 2021 23:56:51 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=CENfc8gSIOvN1khuUO8kQjgl1eL7mjb4JvMs2DCmxkc=; b=jbOi9yZXAOYCHM4mslJ6lBwBZU1CALRis4xjshwa8f2HUb9m1nGEnDjsZjHMORmMry te4Nj7H69iruf3C40lPqhLe9M0ZEuHy4rrAFeqf/RIzP0B6xc2mk7Yc4Gmx02yD2YhNb 36UKVACmgG8VdadJbW6C3Bo2o9b5O+uHx/E1QPNgRXq309qyHhKb6GLSyUwTUmL0CMQ/ Q6KIPKNLymdb8JeYOwN+RrTwHcdya/3ihXKlMQmDcUMSm5JTfzGGn6fEihmO001lhk/9 LuN8VjaNfPjGbMKRjX1t6lJ2Nj2UvfD2yTWcRiEdrayFkeW0VQWG5JL0YSTy8QfKW3Nt wKeg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=CENfc8gSIOvN1khuUO8kQjgl1eL7mjb4JvMs2DCmxkc=; b=MbkdZ2ZavaZZ+50shtOu5YmZ3LBEFflxJ5/YDxK6ucs16TheiAHTRSBUepMtbpTTB6 E0X23eZowys6Pk0iZm0frqbcs5L5kfL7wK6gmpxvb0SmgqtcujCRzuv7upu4RF4jrc43 G72ZS2bjisU7K9WjdcDk59F/PZIPJN33nZSCPhly7WhCSCSTYP2qalEqsRjKJg7R+twF XbxqtU6Yo/zjz9rahJJTuIrYx8cEUt895lz6+wvrP4Gsc5JMvDvaaRn5OuAHrsvgoT/V tS8r2xufcnMK60q90uLunYF9aj3ylfAfga+WAo5tljRD5Oy+74n6t4q9Ggjg2qRDcIN+ DfUQ== X-Gm-Message-State: AOAM531SuGV2/q45AbZ8piAibLo1FDqUP8hM4ka99bsc1q1+66jhC3RD EEcA8K8NAp/2n/8+rWnUcvdYRvsMybeR7Q== X-Received: by 2002:a17:902:8302:b0:142:66e7:ed6d with SMTP id bd2-20020a170902830200b0014266e7ed6dmr15953133plb.83.1637740609578; Tue, 23 Nov 2021 23:56:49 -0800 (PST) Received: from localhost.localdomain ([106.215.91.18]) by smtp.gmail.com with ESMTPSA id q9sm10775420pfj.114.2021.11.23.23.56.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 23 Nov 2021 23:56:49 -0800 (PST) From: Ruchika Gupta To: u-boot@lists.denx.de, ilias.apalodimas@linaro.org, xypron.glpk@gmx.de, agraf@csgraf.de Cc: Ruchika Gupta Subject: [v3][PATCH 2/3] tpm: use more algorithms than sha256 on pcr_read Date: Wed, 24 Nov 2021 13:26:24 +0530 Message-Id: <20211124075625.197449-2-ruchika.gupta@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20211124075625.197449-1-ruchika.gupta@linaro.org> References: <20211124075625.197449-1-ruchika.gupta@linaro.org> MIME-Version: 1.0 X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.37 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" X-Virus-Scanned: clamav-milter 0.103.2 at phobos.denx.de X-Virus-Status: Clean The current tpm2_pcr_read is hardcoded using SHA256. Make the actual command to TPM configurable to use wider range of algorithms. The current command line is kept as is i.e limited to SHA-256 only. Signed-off-by: Ruchika Gupta Reviewed-by: Ilias Apalodimas --- v3: No change v2: Change algorithm from u32 to u16 Add parameter description in function declaration cmd/tpm-v2.c | 3 ++- include/tpm-v2.h | 5 ++++- lib/tpm-v2.c | 12 ++++++++---- 3 files changed, 14 insertions(+), 6 deletions(-) diff --git a/cmd/tpm-v2.c b/cmd/tpm-v2.c index daae91100a..4ea5f9f094 100644 --- a/cmd/tpm-v2.c +++ b/cmd/tpm-v2.c @@ -151,7 +151,8 @@ static int do_tpm_pcr_read(struct cmd_tbl *cmdtp, int flag, int argc, data = map_sysmem(simple_strtoul(argv[2], NULL, 0), 0); - rc = tpm2_pcr_read(dev, index, priv->pcr_select_min, data, &updates); + rc = tpm2_pcr_read(dev, index, priv->pcr_select_min, TPM2_ALG_SHA256, + data, TPM2_DIGEST_LEN, &updates); if (!rc) { printf("PCR #%u content (%u known updates):\n", index, updates); print_byte_string(data, TPM2_DIGEST_LEN); diff --git a/include/tpm-v2.h b/include/tpm-v2.h index ceff7d245e..4e9dd52cb6 100644 --- a/include/tpm-v2.h +++ b/include/tpm-v2.h @@ -512,13 +512,16 @@ u32 tpm2_nv_write_value(struct udevice *dev, u32 index, const void *data, * @dev TPM device * @idx Index of the PCR * @idx_min_sz Minimum size in bytes of the pcrSelect array + * @algorithm Algorithm used, defined in 'enum tpm2_algorithms' * @data Output buffer for contents of the named PCR + * @digest_len len of the data * @updates Optional out parameter: number of updates for this PCR * * @return code of the operation */ u32 tpm2_pcr_read(struct udevice *dev, u32 idx, unsigned int idx_min_sz, - void *data, unsigned int *updates); + u16 algorithm, void *data, u32 digest_len, + unsigned int *updates); /** * Issue a TPM2_GetCapability command. This implementation is limited diff --git a/lib/tpm-v2.c b/lib/tpm-v2.c index 2e7b27bd6b..1bf627853a 100644 --- a/lib/tpm-v2.c +++ b/lib/tpm-v2.c @@ -254,7 +254,8 @@ u32 tpm2_nv_write_value(struct udevice *dev, u32 index, const void *data, } u32 tpm2_pcr_read(struct udevice *dev, u32 idx, unsigned int idx_min_sz, - void *data, unsigned int *updates) + u16 algorithm, void *data, u32 digest_len, + unsigned int *updates) { u8 idx_array_sz = max(idx_min_sz, DIV_ROUND_UP(idx, 8)); u8 command_v2[COMMAND_BUFFER_SIZE] = { @@ -264,7 +265,7 @@ u32 tpm2_pcr_read(struct udevice *dev, u32 idx, unsigned int idx_min_sz, /* TPML_PCR_SELECTION */ tpm_u32(1), /* Number of selections */ - tpm_u16(TPM2_ALG_SHA256), /* Algorithm of the hash */ + tpm_u16(algorithm), /* Algorithm of the hash */ idx_array_sz, /* Array size for selection */ /* bitmap(idx) Selected PCR bitmap */ }; @@ -283,10 +284,13 @@ u32 tpm2_pcr_read(struct udevice *dev, u32 idx, unsigned int idx_min_sz, if (ret) return ret; + if (digest_len > response_len) + return TPM_LIB_ERROR; + if (unpack_byte_string(response, response_len, "ds", 10, &counter, - response_len - TPM2_DIGEST_LEN, data, - TPM2_DIGEST_LEN)) + response_len - digest_len, data, + digest_len)) return TPM_LIB_ERROR; if (updates) From patchwork Wed Nov 24 07:56:25 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ruchika Gupta X-Patchwork-Id: 519346 Delivered-To: patch@linaro.org Received: by 2002:ac0:c605:0:0:0:0:0 with SMTP id p5csp9968471imj; Tue, 23 Nov 2021 23:57:14 -0800 (PST) X-Google-Smtp-Source: ABdhPJzFrWLNRINZtbnec9TwxXSAj7hR/J6AJMtMpgSu07b14SK9pw9mDd6BHJ27xSGDsLgv9F61 X-Received: by 2002:a05:6402:510e:: with SMTP id m14mr21613161edd.312.1637740633923; Tue, 23 Nov 2021 23:57:13 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1637740633; cv=none; d=google.com; s=arc-20160816; b=ZL0Gt7PjXrPfRUXsl0xck47luI+ZYp/Oqxl8shqevh+35stpQltvZSShL7RtkSIUHD Zqh24YWDq9ZAUvf3N6of5DeCuxZxlYDE/d36T5qALp06b4T8Wkl1Us4pQkSW6w1FzO2H myq/0xSwKYocEhe0SzLokoHT6cc5lxr4PltlKtX4uGRg1T6O1aVh0U1RaA1w61ly5dfn gnUqSqhUDLFh6Yi6i41t35vPlZI3GcJuti6pdI/8lURe2/UvzWlmGlRzyytcCBVb5Wzv cA82VikK8L+zdLM2Oe/hl66BR8oTN0EGdrSgEYlmR4dfnFx9deQ5F+9ZYDcoMXlJ8Pfh bITA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:dkim-signature; bh=RJtxl1wfiVTaN2nsueXpnMjbK6zFOJZ8kS7S91H0g4Y=; b=qKSdafUwndUZLcXggKQrUuuO4bR7zvlMsIE9KLNRhhr5U3Ne4egkO/vPfKT2XefQOd xFvoRV9RjFu27IqziU+UT1TSvbjF/4F8tMFvkJam7kH16IgK5o3fR2JGY56cyWcViy05 AUoYrTAHj+fUjURe4cESRhGaJyb1gqx6NH0BU8TQpdjLSi7OXY8J4/GXSqfC0FqEPRZQ 8Ge9YfOwjJuM3NnGNtXimlRPZH9lU0KMY3Y8aryoTsgIRmChE5O9o7YF0Xi1hz2pCCVn qHGyS4daJRKR3cLkqCEUidl/ZF+7ZmHiWjxdUJNSdQb/ogOwfx7w5H5LVctscnzHEc95 7ElA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=EEjh33B8; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from phobos.denx.de (phobos.denx.de. [85.214.62.61]) by mx.google.com with ESMTPS id dt3si56004326ejc.300.2021.11.23.23.57.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 23 Nov 2021 23:57:13 -0800 (PST) Received-SPF: pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 as permitted sender) client-ip=85.214.62.61; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=EEjh33B8; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: from h2850616.stratoserver.net (localhost [IPv6:::1]) by phobos.denx.de (Postfix) with ESMTP id EAAFA83738; Wed, 24 Nov 2021 08:57:12 +0100 (CET) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=u-boot-bounces@lists.denx.de Authentication-Results: phobos.denx.de; dkim=pass (2048-bit key; unprotected) header.d=linaro.org header.i=@linaro.org header.b="EEjh33B8"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id F148783735; Wed, 24 Nov 2021 08:57:09 +0100 (CET) X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on phobos.denx.de X-Spam-Level: X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.2 Received: from mail-pl1-x62a.google.com (mail-pl1-x62a.google.com [IPv6:2607:f8b0:4864:20::62a]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits)) (No client certificate requested) by phobos.denx.de (Postfix) with ESMTPS id 8307D8373B for ; Wed, 24 Nov 2021 08:57:04 +0100 (CET) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=ruchika.gupta@linaro.org Received: by mail-pl1-x62a.google.com with SMTP id n8so1180001plf.4 for ; Tue, 23 Nov 2021 23:57:04 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=RJtxl1wfiVTaN2nsueXpnMjbK6zFOJZ8kS7S91H0g4Y=; b=EEjh33B8k4AM8YveJuLIzJZb1XnPYZVLbjCroG5+8+b2r62D5osq34l15OgFqTO+yk m/oiRll5PDbPCdGkifTPd2Usx4SzyvodiskK9todyoidIMuytlSOrasGoiQuYS1fo8xh OkDh8r0G/F5nQ9Yi0Av0XlKbStWk2XTrV3NAURsAVypm1VtTmAlCXRqmNnkBkYk5ry+J SqQxKZKJISynJ9GGbj++90OzSVFcIlk6Wte+uP06MwoVsxMhfxKKt9dLkdoqWo3u7RTd Q3tIiylNaXxw+AJ4Cd4H5Qng4uLh3ZFGvaa/yK6TjWe9RPlrIvL63dGQ6HLn95t+JZLV hWPQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=RJtxl1wfiVTaN2nsueXpnMjbK6zFOJZ8kS7S91H0g4Y=; b=RdXZaIKRS/Cogb14V7HYBBj8Zq3vcPPkbpJTXorsUEyAV2dkXS8rYDCr1WkFiblJsH xXKseD6ucR2k3ORn8a/Pd0DL4gra39fAsIssZGZ5voaviERPaLEh0dQBG0oyvyJ+2GwI QTv3gbQOXMR1Mom7j+Hrq1fh4XXfE3D3MthQUXZBCwOPWulkbgCNLwBkNjOgdZ8ci0vU +CJ2UAhp6uUmufAd1eHBNfKxihlMogsRIjC1vVYAwuXuHYO6LsB5nA3bDjjiqomKTFe9 UCcOU3Zc5Y1kZQTdO6th8I0zpLomh1fvMQY/MXHr/Vi4//akN1hkh8eMBj9q5NofCDRm Svdw== X-Gm-Message-State: AOAM5330bZnIv9Y9Prt/nyRCln1nDJQXavPytA4s5GGl1f2ubyLM0HJN fXnO3vmQAJW/CtpDyoJ+K7TomXTI5Rv/XQ== X-Received: by 2002:a17:90a:c58f:: with SMTP id l15mr6001470pjt.168.1637740622519; Tue, 23 Nov 2021 23:57:02 -0800 (PST) Received: from localhost.localdomain ([106.215.91.18]) by smtp.gmail.com with ESMTPSA id q9sm10775420pfj.114.2021.11.23.23.56.59 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 23 Nov 2021 23:57:02 -0800 (PST) From: Ruchika Gupta To: u-boot@lists.denx.de, ilias.apalodimas@linaro.org, xypron.glpk@gmx.de, agraf@csgraf.de Cc: Ruchika Gupta Subject: [v3] [PATCH 3/3] efi_loader: Extend PCR's for firmware measurements Date: Wed, 24 Nov 2021 13:26:25 +0530 Message-Id: <20211124075625.197449-3-ruchika.gupta@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20211124075625.197449-1-ruchika.gupta@linaro.org> References: <20211124075625.197449-1-ruchika.gupta@linaro.org> MIME-Version: 1.0 X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.37 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" X-Virus-Scanned: clamav-milter 0.103.2 at phobos.denx.de X-Virus-Status: Clean Firmwares before U-Boot may be capable of doing tpm measurements and passing them to U-Boot in the form of eventlog. However there may be scenarios where the firmwares don't have TPM driver and are not capable of extending the measurements in the PCRs. Based on TCG spec, if previous firnware has extended PCR's, PCR0 would not be 0. So, read the PCR0 to determine if the PCR's need to be extended as eventlog is parsed or not. Signed-off-by: Ruchika Gupta Reviewed-by: Ilias Apalodimas --- v3 : Rebase changes on top of changes made in first patch of series v2 : Removed check for PCR0 in eventlog lib/efi_loader/efi_tcg2.c | 75 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) diff --git a/lib/efi_loader/efi_tcg2.c b/lib/efi_loader/efi_tcg2.c index ebd7847957..b5343bf039 100644 --- a/lib/efi_loader/efi_tcg2.c +++ b/lib/efi_loader/efi_tcg2.c @@ -199,6 +199,43 @@ static efi_status_t tcg2_pcr_extend(struct udevice *dev, u32 pcr_index, return EFI_SUCCESS; } +/* tcg2_pcr_read - Read PCRs for a TPM2 device for a given tpml_digest_values + * + * @dev: device + * @digest_list: list of digest algorithms to extend + * + * @Return: status code + */ +static efi_status_t tcg2_pcr_read(struct udevice *dev, u32 pcr_index, + struct tpml_digest_values *digest_list) +{ + struct tpm_chip_priv *priv; + unsigned int updates, pcr_select_min; + u32 rc; + size_t i; + + priv = dev_get_uclass_priv(dev); + if (!priv) + return EFI_DEVICE_ERROR; + + pcr_select_min = priv->pcr_select_min; + + for (i = 0; i < digest_list->count; i++) { + u16 hash_alg = digest_list->digests[i].hash_alg; + u8 *digest = (u8 *)&digest_list->digests[i].digest; + + rc = tpm2_pcr_read(dev, pcr_index, pcr_select_min, + hash_alg, digest, alg_to_len(hash_alg), + &updates); + if (rc) { + EFI_PRINT("Failed to read PCR\n"); + return EFI_DEVICE_ERROR; + } + } + + return EFI_SUCCESS; +} + /* put_event - Append an agile event to an eventlog * * @pcr_index: PCR index @@ -1428,6 +1465,8 @@ efi_status_t tcg2_get_fw_eventlog(struct udevice *dev, void *log_buffer, u32 pcr, pos; u64 base; u32 sz; + bool extend_pcr = false; + int i; ret = platform_get_eventlog(dev, &base, &sz); if (ret != EFI_SUCCESS) @@ -1449,6 +1488,26 @@ efi_status_t tcg2_get_fw_eventlog(struct udevice *dev, void *log_buffer, return EFI_COMPROMISED_DATA; } + ret = tcg2_pcr_read(dev, 0, &digest_list); + if (ret) { + log_err("Error reading PCR 0\n"); + return ret; + } + + /* + * If PCR0 is 0, previous firmware didn't have the capability + * to extend the PCR. In this scenario, extend the PCR as + * the eventlog is parsed. + */ + for (i = 0; i < digest_list.count; i++) { + u8 buffer[TPM2_DIGEST_LEN] = { 0 }; + u16 hash_alg = digest_list.digests[i].hash_alg; + + if (!memcmp((u8 *)&digest_list.digests[i].digest, buffer, + alg_to_len(hash_alg))) + extend_pcr = true; + } + while (pos < sz) { ret = tcg2_parse_event(dev, buffer, sz, &pos, &digest_list, &pcr); @@ -1456,6 +1515,22 @@ efi_status_t tcg2_get_fw_eventlog(struct udevice *dev, void *log_buffer, log_err("Error parsing event\n"); return ret; } + if (extend_pcr) { + ret = tcg2_pcr_extend(dev, pcr, &digest_list); + if (ret != EFI_SUCCESS) { + log_err("Error in extending PCR\n"); + return ret; + } + + /* Clear the digest for next event */ + for (i = 0; i < digest_list.count; i++) { + u16 hash_alg = digest_list.digests[i].hash_alg; + u8 *digest = + (u8 *)&digest_list.digests[i].digest; + + memset(digest, 0, alg_to_len(hash_alg)); + } + } } memcpy(log_buffer, buffer, sz);