Message ID | 1398328208-4489-2-git-send-email-p.aubert@staubli.com |
---|---|
State | Accepted |
Delegated to: | Pantelis Antoniou |
Headers | show |
Hi Pierre, On Apr 24, 2014, at 11:30 AM, Pierre Aubert wrote: > This patch adds functions for read, write and authentication > key programming for the Replay Protected Memory Block partition > in the eMMC. > > Signed-off-by: Pierre Aubert <p.aubert@staubli.com> > CC: Pantelis Antoniou <panto@antoniou-consulting.com> > --- > Changes in V5: > - move changelog to the right place > - change lib/Makefile for adding sha256 when CONFIG_SUPPORT_EMMC_RPMB is > defined > > V3, V4: no changes > > Changes in V2: > - use ALLOC_CACHE_ALIGN_BUFFER in rpmb.c instead of a static buffer for the > RPMB frames. > > drivers/mmc/Makefile | 1 + > drivers/mmc/rpmb.c | 323 ++++++++++++++++++++++++++++++++++++++++++++++++++ > include/mmc.h | 10 ++- > lib/Makefile | 1 + > 4 files changed, 334 insertions(+), 1 deletions(-) > create mode 100644 drivers/mmc/rpmb.c > > diff --git a/drivers/mmc/Makefile b/drivers/mmc/Makefile > index 931922b..4c6ab9e 100644 > --- a/drivers/mmc/Makefile > +++ b/drivers/mmc/Makefile > @@ -30,6 +30,7 @@ obj-$(CONFIG_DWMMC) += dw_mmc.o > obj-$(CONFIG_EXYNOS_DWMMC) += exynos_dw_mmc.o > obj-$(CONFIG_ZYNQ_SDHCI) += zynq_sdhci.o > obj-$(CONFIG_SOCFPGA_DWMMC) += socfpga_dw_mmc.o > +obj-$(CONFIG_SUPPORT_EMMC_RPMB) += rpmb.o > ifdef CONFIG_SPL_BUILD > obj-$(CONFIG_SPL_MMC_BOOT) += fsl_esdhc_spl.o > else > diff --git a/drivers/mmc/rpmb.c b/drivers/mmc/rpmb.c > new file mode 100644 > index 0000000..05936f5 > --- /dev/null > +++ b/drivers/mmc/rpmb.c > @@ -0,0 +1,323 @@ > +/* > + * Copyright 2014, Staubli Faverges > + * Pierre Aubert > + * > + * eMMC- Replay Protected Memory Block > + * According to JEDEC Standard No. 84-A441 > + * > + * SPDX-License-Identifier: GPL-2.0+ > + */ > + > +#include <config.h> > +#include <common.h> > +#include <mmc.h> > +#include <sha256.h> > +#include "mmc_private.h" > + > +/* Request codes */ > +#define RPMB_REQ_KEY 1 > +#define RPMB_REQ_WCOUNTER 2 > +#define RPMB_REQ_WRITE_DATA 3 > +#define RPMB_REQ_READ_DATA 4 > +#define RPMB_REQ_STATUS 5 > + > +/* Response code */ > +#define RPMB_RESP_KEY 0x0100 > +#define RPMB_RESP_WCOUNTER 0x0200 > +#define RPMB_RESP_WRITE_DATA 0x0300 > +#define RPMB_RESP_READ_DATA 0x0400 > + > +/* Error codes */ > +#define RPMB_OK 0 > +#define RPMB_ERR_GENERAL 1 > +#define RPMB_ERR_AUTH 2 > +#define RPMB_ERR_COUNTER 3 > +#define RPMB_ERR_ADDRESS 4 > +#define RPMB_ERR_WRITE 5 > +#define RPMB_ERR_READ 6 > +#define RPMB_ERR_KEY 7 > +#define RPMB_ERR_CNT_EXPIRED 0x80 > +#define RPMB_ERR_MSK 0x7 > + > +/* Sizes of RPMB data frame */ > +#define RPMB_SZ_STUFF 196 > +#define RPMB_SZ_MAC 32 > +#define RPMB_SZ_DATA 256 > +#define RPMB_SZ_NONCE 16 > + > +#define SHA256_BLOCK_SIZE 64 > + > +/* Error messages */ > +static const char * const rpmb_err_msg[] = { > + "", > + "General failure", > + "Authentication failure", > + "Counter failure", > + "Address failure", > + "Write failure", > + "Read failure", > + "Authentication key not yet programmed", > +}; > + > + > +/* Structure of RPMB data frame. */ > +struct s_rpmb { > + unsigned char stuff[RPMB_SZ_STUFF]; > + unsigned char mac[RPMB_SZ_MAC]; > + unsigned char data[RPMB_SZ_DATA]; > + unsigned char nonce[RPMB_SZ_NONCE]; > + unsigned long write_counter; > + unsigned short address; > + unsigned short block_count; > + unsigned short result; > + unsigned short request; > +}; > + > +static int mmc_set_blockcount(struct mmc *mmc, unsigned int blockcount, > + bool is_rel_write) > +{ > + struct mmc_cmd cmd = {0}; > + > + cmd.cmdidx = MMC_CMD_SET_BLOCK_COUNT; > + cmd.cmdarg = blockcount & 0x0000FFFF; > + if (is_rel_write) > + cmd.cmdarg |= 1 << 31; > + cmd.resp_type = MMC_RSP_R1; > + > + return mmc_send_cmd(mmc, &cmd, NULL); > +} > +static int mmc_rpmb_request(struct mmc *mmc, const struct s_rpmb *s, > + unsigned int count, bool is_rel_write) > +{ > + struct mmc_cmd cmd = {0}; > + struct mmc_data data; > + int ret; > + > + ret = mmc_set_blockcount(mmc, count, is_rel_write); > + if (ret) { > +#ifdef CONFIG_MMC_RPMB_TRACE > + printf("%s:mmc_set_blockcount-> %d\n", __func__, ret); > +#endif > + return 1; > + } > + > + cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK; > + cmd.cmdarg = 0; > + cmd.resp_type = MMC_RSP_R1b; > + > + data.src = (const char *)s; > + data.blocks = 1; > + data.blocksize = MMC_MAX_BLOCK_LEN; > + data.flags = MMC_DATA_WRITE; > + > + ret = mmc_send_cmd(mmc, &cmd, &data); > + if (ret) { > +#ifdef CONFIG_MMC_RPMB_TRACE > + printf("%s:mmc_send_cmd-> %d\n", __func__, ret); > +#endif > + return 1; > + } > + return 0; > +} > +static int mmc_rpmb_response(struct mmc *mmc, struct s_rpmb *s, > + unsigned short expected) > +{ > + struct mmc_cmd cmd = {0}; > + struct mmc_data data; > + int ret; > + > + ret = mmc_set_blockcount(mmc, 1, false); > + if (ret) { > +#ifdef CONFIG_MMC_RPMB_TRACE > + printf("%s:mmc_set_blockcount-> %d\n", __func__, ret); > +#endif > + return -1; > + } > + cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK; > + cmd.cmdarg = 0; > + cmd.resp_type = MMC_RSP_R1; > + > + data.dest = (char *)s; > + data.blocks = 1; > + data.blocksize = MMC_MAX_BLOCK_LEN; > + data.flags = MMC_DATA_READ; > + > + ret = mmc_send_cmd(mmc, &cmd, &data); > + if (ret) { > +#ifdef CONFIG_MMC_RPMB_TRACE > + printf("%s:mmc_send_cmd-> %d\n", __func__, ret); > +#endif > + return -1; > + } > + /* Check the response and the status */ > + if (be16_to_cpu(s->request) != expected) { > +#ifdef CONFIG_MMC_RPMB_TRACE > + printf("%s:response= %x\n", __func__, > + be16_to_cpu(s->request)); > +#endif > + return -1; > + } > + ret = be16_to_cpu(s->result); > + if (ret) { > + printf("%s %s\n", rpmb_err_msg[ret & RPMB_ERR_MSK], > + (ret & RPMB_ERR_CNT_EXPIRED) ? > + "Write counter has expired" : ""); > + } > + > + /* Return the status of the command */ > + return ret; > +} > +static int mmc_rpmb_status(struct mmc *mmc, unsigned short expected) > +{ > + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1); > + > + memset(rpmb_frame, 0, sizeof(struct s_rpmb)); > + rpmb_frame->request = cpu_to_be16(RPMB_REQ_STATUS); > + if (mmc_rpmb_request(mmc, rpmb_frame, 1, false)) > + return -1; > + > + /* Read the result */ > + return mmc_rpmb_response(mmc, rpmb_frame, expected); > +} > +static void rpmb_hmac(unsigned char *key, unsigned char *buff, int len, > + unsigned char *output) > +{ > + sha256_context ctx; > + int i; > + unsigned char k_ipad[SHA256_BLOCK_SIZE]; > + unsigned char k_opad[SHA256_BLOCK_SIZE]; > + > + sha256_starts(&ctx); > + > + /* According to RFC 4634, the HMAC transform looks like: > + SHA(K XOR opad, SHA(K XOR ipad, text)) > + > + where K is an n byte key. > + ipad is the byte 0x36 repeated blocksize times > + opad is the byte 0x5c repeated blocksize times > + and text is the data being protected. > + */ > + > + for (i = 0; i < RPMB_SZ_MAC; i++) { > + k_ipad[i] = key[i] ^ 0x36; > + k_opad[i] = key[i] ^ 0x5c; > + } > + /* remaining pad bytes are '\0' XOR'd with ipad and opad values */ > + for ( ; i < SHA256_BLOCK_SIZE; i++) { > + k_ipad[i] = 0x36; > + k_opad[i] = 0x5c; > + } > + sha256_update(&ctx, k_ipad, SHA256_BLOCK_SIZE); > + sha256_update(&ctx, buff, len); > + sha256_finish(&ctx, output); > + > + /* Init context for second pass */ > + sha256_starts(&ctx); > + > + /* start with outer pad */ > + sha256_update(&ctx, k_opad, SHA256_BLOCK_SIZE); > + > + /* then results of 1st hash */ > + sha256_update(&ctx, output, RPMB_SZ_MAC); > + > + /* finish up 2nd pass */ > + sha256_finish(&ctx, output); > +} > +int mmc_rpmb_get_counter(struct mmc *mmc, unsigned long *pcounter) > +{ > + int ret; > + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1); > + > + /* Fill the request */ > + memset(rpmb_frame, 0, sizeof(struct s_rpmb)); > + rpmb_frame->request = cpu_to_be16(RPMB_REQ_WCOUNTER); > + if (mmc_rpmb_request(mmc, rpmb_frame, 1, false)) > + return -1; > + > + /* Read the result */ > + ret = mmc_rpmb_response(mmc, rpmb_frame, RPMB_RESP_WCOUNTER); > + if (ret) > + return ret; > + > + *pcounter = be32_to_cpu(rpmb_frame->write_counter); > + return 0; > +} > +int mmc_rpmb_set_key(struct mmc *mmc, void *key) > +{ > + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1); > + /* Fill the request */ > + memset(rpmb_frame, 0, sizeof(struct s_rpmb)); > + rpmb_frame->request = cpu_to_be16(RPMB_REQ_KEY); > + memcpy(rpmb_frame->mac, key, RPMB_SZ_MAC); > + > + if (mmc_rpmb_request(mmc, rpmb_frame, 1, true)) > + return -1; > + > + /* read the operation status */ > + return mmc_rpmb_status(mmc, RPMB_RESP_KEY); > +} > +int mmc_rpmb_read(struct mmc *mmc, void *addr, unsigned short blk, > + unsigned short cnt, unsigned char *key) > +{ > + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1); > + int i; > + > + for (i = 0; i < cnt; i++) { > + /* Fill the request */ > + memset(rpmb_frame, 0, sizeof(struct s_rpmb)); > + rpmb_frame->address = cpu_to_be16(blk + i); > + rpmb_frame->request = cpu_to_be16(RPMB_REQ_READ_DATA); > + if (mmc_rpmb_request(mmc, rpmb_frame, 1, false)) > + break; > + > + /* Read the result */ > + if (mmc_rpmb_response(mmc, rpmb_frame, RPMB_RESP_READ_DATA)) > + break; > + > + /* Check the HMAC if key is provided */ > + if (key) { > + unsigned char ret_hmac[RPMB_SZ_MAC]; > + > + rpmb_hmac(key, rpmb_frame->data, 284, ret_hmac); > + if (memcmp(ret_hmac, rpmb_frame->mac, RPMB_SZ_MAC)) { > + printf("MAC error on block #%d\n", i); > + break; > + } > + } > + /* Copy data */ > + memcpy(addr + i * RPMB_SZ_DATA, rpmb_frame->data, RPMB_SZ_DATA); > + } > + return i; > +} > +int mmc_rpmb_write(struct mmc *mmc, void *addr, unsigned short blk, > + unsigned short cnt, unsigned char *key) > +{ > + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1); > + unsigned long wcount; > + int i; > + > + for (i = 0; i < cnt; i++) { > + if (mmc_rpmb_get_counter(mmc, &wcount)) { > + printf("Cannot read RPMB write counter\n"); > + break; > + } > + > + /* Fill the request */ > + memset(rpmb_frame, 0, sizeof(struct s_rpmb)); > + memcpy(rpmb_frame->data, addr + i * RPMB_SZ_DATA, RPMB_SZ_DATA); > + rpmb_frame->address = cpu_to_be16(blk + i); > + rpmb_frame->block_count = cpu_to_be16(1); > + rpmb_frame->write_counter = cpu_to_be32(wcount); > + rpmb_frame->request = cpu_to_be16(RPMB_REQ_WRITE_DATA); > + /* Computes HMAC */ > + rpmb_hmac(key, rpmb_frame->data, 284, rpmb_frame->mac); > + > + if (mmc_rpmb_request(mmc, rpmb_frame, 1, true)) > + break; > + > + /* Get status */ > + if (mmc_rpmb_status(mmc, RPMB_RESP_WRITE_DATA)) > + break; > + } > + return i; > +} > diff --git a/include/mmc.h b/include/mmc.h > index 42d0125..14d296c 100644 > --- a/include/mmc.h > +++ b/include/mmc.h > @@ -69,6 +69,7 @@ > #define MMC_CMD_SET_BLOCKLEN 16 > #define MMC_CMD_READ_SINGLE_BLOCK 17 > #define MMC_CMD_READ_MULTIPLE_BLOCK 18 > +#define MMC_CMD_SET_BLOCK_COUNT 23 > #define MMC_CMD_WRITE_SINGLE_BLOCK 24 > #define MMC_CMD_WRITE_MULTIPLE_BLOCK 25 > #define MMC_CMD_ERASE_GROUP_START 35 > @@ -224,6 +225,7 @@ > * boot partitions (2), general purpose partitions (4) in MMC v4.4. > */ > #define MMC_NUM_BOOT_PARTITION 2 > +#define MMC_PART_RPMB 3 /* RPMB partition number */ > > struct mmc_cid { > unsigned long psn; > @@ -335,7 +337,13 @@ int mmc_set_part_conf(struct mmc *mmc, u8 ack, u8 part_num, u8 access); > int mmc_set_boot_bus_width(struct mmc *mmc, u8 width, u8 reset, u8 mode); > /* Function to modify the RST_n_FUNCTION field of EXT_CSD */ > int mmc_set_rst_n_function(struct mmc *mmc, u8 enable); > - > +/* Functions to read / write the RPMB partition */ > +int mmc_rpmb_set_key(struct mmc *mmc, void *key); > +int mmc_rpmb_get_counter(struct mmc *mmc, unsigned long *counter); > +int mmc_rpmb_read(struct mmc *mmc, void *addr, unsigned short blk, > + unsigned short cnt, unsigned char *key); > +int mmc_rpmb_write(struct mmc *mmc, void *addr, unsigned short blk, > + unsigned short cnt, unsigned char *key); > /** > * Start device initialization and return immediately; it does not block on > * polling OCR (operation condition register) status. Then you should call > diff --git a/lib/Makefile b/lib/Makefile > index 27e4f78..377ab13 100644 > --- a/lib/Makefile > +++ b/lib/Makefile > @@ -35,6 +35,7 @@ obj-y += net_utils.o > obj-$(CONFIG_PHYSMEM) += physmem.o > obj-y += qsort.o > obj-$(CONFIG_SHA1) += sha1.o > +obj-$(CONFIG_SUPPORT_EMMC_RPMB) += sha256.o > obj-$(CONFIG_SHA256) += sha256.o > obj-y += strmhz.o > obj-$(CONFIG_TPM) += tpm.o > -- > 1.7.6.5 > Looks good. Applied Thanks -- Pantelis Acked-by: Pantelis Antoniou <panto@antoniou-consulting.com> > _______________________________________________ > U-Boot mailing list > U-Boot@lists.denx.de > http://lists.denx.de/mailman/listinfo/u-boot
diff --git a/drivers/mmc/Makefile b/drivers/mmc/Makefile index 931922b..4c6ab9e 100644 --- a/drivers/mmc/Makefile +++ b/drivers/mmc/Makefile @@ -30,6 +30,7 @@ obj-$(CONFIG_DWMMC) += dw_mmc.o obj-$(CONFIG_EXYNOS_DWMMC) += exynos_dw_mmc.o obj-$(CONFIG_ZYNQ_SDHCI) += zynq_sdhci.o obj-$(CONFIG_SOCFPGA_DWMMC) += socfpga_dw_mmc.o +obj-$(CONFIG_SUPPORT_EMMC_RPMB) += rpmb.o ifdef CONFIG_SPL_BUILD obj-$(CONFIG_SPL_MMC_BOOT) += fsl_esdhc_spl.o else diff --git a/drivers/mmc/rpmb.c b/drivers/mmc/rpmb.c new file mode 100644 index 0000000..05936f5 --- /dev/null +++ b/drivers/mmc/rpmb.c @@ -0,0 +1,323 @@ +/* + * Copyright 2014, Staubli Faverges + * Pierre Aubert + * + * eMMC- Replay Protected Memory Block + * According to JEDEC Standard No. 84-A441 + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#include <config.h> +#include <common.h> +#include <mmc.h> +#include <sha256.h> +#include "mmc_private.h" + +/* Request codes */ +#define RPMB_REQ_KEY 1 +#define RPMB_REQ_WCOUNTER 2 +#define RPMB_REQ_WRITE_DATA 3 +#define RPMB_REQ_READ_DATA 4 +#define RPMB_REQ_STATUS 5 + +/* Response code */ +#define RPMB_RESP_KEY 0x0100 +#define RPMB_RESP_WCOUNTER 0x0200 +#define RPMB_RESP_WRITE_DATA 0x0300 +#define RPMB_RESP_READ_DATA 0x0400 + +/* Error codes */ +#define RPMB_OK 0 +#define RPMB_ERR_GENERAL 1 +#define RPMB_ERR_AUTH 2 +#define RPMB_ERR_COUNTER 3 +#define RPMB_ERR_ADDRESS 4 +#define RPMB_ERR_WRITE 5 +#define RPMB_ERR_READ 6 +#define RPMB_ERR_KEY 7 +#define RPMB_ERR_CNT_EXPIRED 0x80 +#define RPMB_ERR_MSK 0x7 + +/* Sizes of RPMB data frame */ +#define RPMB_SZ_STUFF 196 +#define RPMB_SZ_MAC 32 +#define RPMB_SZ_DATA 256 +#define RPMB_SZ_NONCE 16 + +#define SHA256_BLOCK_SIZE 64 + +/* Error messages */ +static const char * const rpmb_err_msg[] = { + "", + "General failure", + "Authentication failure", + "Counter failure", + "Address failure", + "Write failure", + "Read failure", + "Authentication key not yet programmed", +}; + + +/* Structure of RPMB data frame. */ +struct s_rpmb { + unsigned char stuff[RPMB_SZ_STUFF]; + unsigned char mac[RPMB_SZ_MAC]; + unsigned char data[RPMB_SZ_DATA]; + unsigned char nonce[RPMB_SZ_NONCE]; + unsigned long write_counter; + unsigned short address; + unsigned short block_count; + unsigned short result; + unsigned short request; +}; + +static int mmc_set_blockcount(struct mmc *mmc, unsigned int blockcount, + bool is_rel_write) +{ + struct mmc_cmd cmd = {0}; + + cmd.cmdidx = MMC_CMD_SET_BLOCK_COUNT; + cmd.cmdarg = blockcount & 0x0000FFFF; + if (is_rel_write) + cmd.cmdarg |= 1 << 31; + cmd.resp_type = MMC_RSP_R1; + + return mmc_send_cmd(mmc, &cmd, NULL); +} +static int mmc_rpmb_request(struct mmc *mmc, const struct s_rpmb *s, + unsigned int count, bool is_rel_write) +{ + struct mmc_cmd cmd = {0}; + struct mmc_data data; + int ret; + + ret = mmc_set_blockcount(mmc, count, is_rel_write); + if (ret) { +#ifdef CONFIG_MMC_RPMB_TRACE + printf("%s:mmc_set_blockcount-> %d\n", __func__, ret); +#endif + return 1; + } + + cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK; + cmd.cmdarg = 0; + cmd.resp_type = MMC_RSP_R1b; + + data.src = (const char *)s; + data.blocks = 1; + data.blocksize = MMC_MAX_BLOCK_LEN; + data.flags = MMC_DATA_WRITE; + + ret = mmc_send_cmd(mmc, &cmd, &data); + if (ret) { +#ifdef CONFIG_MMC_RPMB_TRACE + printf("%s:mmc_send_cmd-> %d\n", __func__, ret); +#endif + return 1; + } + return 0; +} +static int mmc_rpmb_response(struct mmc *mmc, struct s_rpmb *s, + unsigned short expected) +{ + struct mmc_cmd cmd = {0}; + struct mmc_data data; + int ret; + + ret = mmc_set_blockcount(mmc, 1, false); + if (ret) { +#ifdef CONFIG_MMC_RPMB_TRACE + printf("%s:mmc_set_blockcount-> %d\n", __func__, ret); +#endif + return -1; + } + cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK; + cmd.cmdarg = 0; + cmd.resp_type = MMC_RSP_R1; + + data.dest = (char *)s; + data.blocks = 1; + data.blocksize = MMC_MAX_BLOCK_LEN; + data.flags = MMC_DATA_READ; + + ret = mmc_send_cmd(mmc, &cmd, &data); + if (ret) { +#ifdef CONFIG_MMC_RPMB_TRACE + printf("%s:mmc_send_cmd-> %d\n", __func__, ret); +#endif + return -1; + } + /* Check the response and the status */ + if (be16_to_cpu(s->request) != expected) { +#ifdef CONFIG_MMC_RPMB_TRACE + printf("%s:response= %x\n", __func__, + be16_to_cpu(s->request)); +#endif + return -1; + } + ret = be16_to_cpu(s->result); + if (ret) { + printf("%s %s\n", rpmb_err_msg[ret & RPMB_ERR_MSK], + (ret & RPMB_ERR_CNT_EXPIRED) ? + "Write counter has expired" : ""); + } + + /* Return the status of the command */ + return ret; +} +static int mmc_rpmb_status(struct mmc *mmc, unsigned short expected) +{ + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1); + + memset(rpmb_frame, 0, sizeof(struct s_rpmb)); + rpmb_frame->request = cpu_to_be16(RPMB_REQ_STATUS); + if (mmc_rpmb_request(mmc, rpmb_frame, 1, false)) + return -1; + + /* Read the result */ + return mmc_rpmb_response(mmc, rpmb_frame, expected); +} +static void rpmb_hmac(unsigned char *key, unsigned char *buff, int len, + unsigned char *output) +{ + sha256_context ctx; + int i; + unsigned char k_ipad[SHA256_BLOCK_SIZE]; + unsigned char k_opad[SHA256_BLOCK_SIZE]; + + sha256_starts(&ctx); + + /* According to RFC 4634, the HMAC transform looks like: + SHA(K XOR opad, SHA(K XOR ipad, text)) + + where K is an n byte key. + ipad is the byte 0x36 repeated blocksize times + opad is the byte 0x5c repeated blocksize times + and text is the data being protected. + */ + + for (i = 0; i < RPMB_SZ_MAC; i++) { + k_ipad[i] = key[i] ^ 0x36; + k_opad[i] = key[i] ^ 0x5c; + } + /* remaining pad bytes are '\0' XOR'd with ipad and opad values */ + for ( ; i < SHA256_BLOCK_SIZE; i++) { + k_ipad[i] = 0x36; + k_opad[i] = 0x5c; + } + sha256_update(&ctx, k_ipad, SHA256_BLOCK_SIZE); + sha256_update(&ctx, buff, len); + sha256_finish(&ctx, output); + + /* Init context for second pass */ + sha256_starts(&ctx); + + /* start with outer pad */ + sha256_update(&ctx, k_opad, SHA256_BLOCK_SIZE); + + /* then results of 1st hash */ + sha256_update(&ctx, output, RPMB_SZ_MAC); + + /* finish up 2nd pass */ + sha256_finish(&ctx, output); +} +int mmc_rpmb_get_counter(struct mmc *mmc, unsigned long *pcounter) +{ + int ret; + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1); + + /* Fill the request */ + memset(rpmb_frame, 0, sizeof(struct s_rpmb)); + rpmb_frame->request = cpu_to_be16(RPMB_REQ_WCOUNTER); + if (mmc_rpmb_request(mmc, rpmb_frame, 1, false)) + return -1; + + /* Read the result */ + ret = mmc_rpmb_response(mmc, rpmb_frame, RPMB_RESP_WCOUNTER); + if (ret) + return ret; + + *pcounter = be32_to_cpu(rpmb_frame->write_counter); + return 0; +} +int mmc_rpmb_set_key(struct mmc *mmc, void *key) +{ + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1); + /* Fill the request */ + memset(rpmb_frame, 0, sizeof(struct s_rpmb)); + rpmb_frame->request = cpu_to_be16(RPMB_REQ_KEY); + memcpy(rpmb_frame->mac, key, RPMB_SZ_MAC); + + if (mmc_rpmb_request(mmc, rpmb_frame, 1, true)) + return -1; + + /* read the operation status */ + return mmc_rpmb_status(mmc, RPMB_RESP_KEY); +} +int mmc_rpmb_read(struct mmc *mmc, void *addr, unsigned short blk, + unsigned short cnt, unsigned char *key) +{ + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1); + int i; + + for (i = 0; i < cnt; i++) { + /* Fill the request */ + memset(rpmb_frame, 0, sizeof(struct s_rpmb)); + rpmb_frame->address = cpu_to_be16(blk + i); + rpmb_frame->request = cpu_to_be16(RPMB_REQ_READ_DATA); + if (mmc_rpmb_request(mmc, rpmb_frame, 1, false)) + break; + + /* Read the result */ + if (mmc_rpmb_response(mmc, rpmb_frame, RPMB_RESP_READ_DATA)) + break; + + /* Check the HMAC if key is provided */ + if (key) { + unsigned char ret_hmac[RPMB_SZ_MAC]; + + rpmb_hmac(key, rpmb_frame->data, 284, ret_hmac); + if (memcmp(ret_hmac, rpmb_frame->mac, RPMB_SZ_MAC)) { + printf("MAC error on block #%d\n", i); + break; + } + } + /* Copy data */ + memcpy(addr + i * RPMB_SZ_DATA, rpmb_frame->data, RPMB_SZ_DATA); + } + return i; +} +int mmc_rpmb_write(struct mmc *mmc, void *addr, unsigned short blk, + unsigned short cnt, unsigned char *key) +{ + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1); + unsigned long wcount; + int i; + + for (i = 0; i < cnt; i++) { + if (mmc_rpmb_get_counter(mmc, &wcount)) { + printf("Cannot read RPMB write counter\n"); + break; + } + + /* Fill the request */ + memset(rpmb_frame, 0, sizeof(struct s_rpmb)); + memcpy(rpmb_frame->data, addr + i * RPMB_SZ_DATA, RPMB_SZ_DATA); + rpmb_frame->address = cpu_to_be16(blk + i); + rpmb_frame->block_count = cpu_to_be16(1); + rpmb_frame->write_counter = cpu_to_be32(wcount); + rpmb_frame->request = cpu_to_be16(RPMB_REQ_WRITE_DATA); + /* Computes HMAC */ + rpmb_hmac(key, rpmb_frame->data, 284, rpmb_frame->mac); + + if (mmc_rpmb_request(mmc, rpmb_frame, 1, true)) + break; + + /* Get status */ + if (mmc_rpmb_status(mmc, RPMB_RESP_WRITE_DATA)) + break; + } + return i; +} diff --git a/include/mmc.h b/include/mmc.h index 42d0125..14d296c 100644 --- a/include/mmc.h +++ b/include/mmc.h @@ -69,6 +69,7 @@ #define MMC_CMD_SET_BLOCKLEN 16 #define MMC_CMD_READ_SINGLE_BLOCK 17 #define MMC_CMD_READ_MULTIPLE_BLOCK 18 +#define MMC_CMD_SET_BLOCK_COUNT 23 #define MMC_CMD_WRITE_SINGLE_BLOCK 24 #define MMC_CMD_WRITE_MULTIPLE_BLOCK 25 #define MMC_CMD_ERASE_GROUP_START 35 @@ -224,6 +225,7 @@ * boot partitions (2), general purpose partitions (4) in MMC v4.4. */ #define MMC_NUM_BOOT_PARTITION 2 +#define MMC_PART_RPMB 3 /* RPMB partition number */ struct mmc_cid { unsigned long psn; @@ -335,7 +337,13 @@ int mmc_set_part_conf(struct mmc *mmc, u8 ack, u8 part_num, u8 access); int mmc_set_boot_bus_width(struct mmc *mmc, u8 width, u8 reset, u8 mode); /* Function to modify the RST_n_FUNCTION field of EXT_CSD */ int mmc_set_rst_n_function(struct mmc *mmc, u8 enable); - +/* Functions to read / write the RPMB partition */ +int mmc_rpmb_set_key(struct mmc *mmc, void *key); +int mmc_rpmb_get_counter(struct mmc *mmc, unsigned long *counter); +int mmc_rpmb_read(struct mmc *mmc, void *addr, unsigned short blk, + unsigned short cnt, unsigned char *key); +int mmc_rpmb_write(struct mmc *mmc, void *addr, unsigned short blk, + unsigned short cnt, unsigned char *key); /** * Start device initialization and return immediately; it does not block on * polling OCR (operation condition register) status. Then you should call diff --git a/lib/Makefile b/lib/Makefile index 27e4f78..377ab13 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -35,6 +35,7 @@ obj-y += net_utils.o obj-$(CONFIG_PHYSMEM) += physmem.o obj-y += qsort.o obj-$(CONFIG_SHA1) += sha1.o +obj-$(CONFIG_SUPPORT_EMMC_RPMB) += sha256.o obj-$(CONFIG_SHA256) += sha256.o obj-y += strmhz.o obj-$(CONFIG_TPM) += tpm.o
This patch adds functions for read, write and authentication key programming for the Replay Protected Memory Block partition in the eMMC. Signed-off-by: Pierre Aubert <p.aubert@staubli.com> CC: Pantelis Antoniou <panto@antoniou-consulting.com> --- Changes in V5: - move changelog to the right place - change lib/Makefile for adding sha256 when CONFIG_SUPPORT_EMMC_RPMB is defined V3, V4: no changes Changes in V2: - use ALLOC_CACHE_ALIGN_BUFFER in rpmb.c instead of a static buffer for the RPMB frames. drivers/mmc/Makefile | 1 + drivers/mmc/rpmb.c | 323 ++++++++++++++++++++++++++++++++++++++++++++++++++ include/mmc.h | 10 ++- lib/Makefile | 1 + 4 files changed, 334 insertions(+), 1 deletions(-) create mode 100644 drivers/mmc/rpmb.c