From b6bdd7744aba06d82f30b0c84012f0b06ccb01de Mon Sep 17 00:00:00 2001 From: Marc Hartmayer Date: Wed, 24 Feb 2021 15:04:11 +0000 Subject: [PATCH] genprotimg: use `pv_` namespace for our Buffer implementation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Use `pv_` namespace for our Buffer implementation so a symbol clash with other libraries is less likely. Fixes: https://github.com/ibm-s390-linux/s390-tools/issues/109 Reviewed-by: Jan Hoeppner Signed-off-by: Marc Hartmayer Signed-off-by: Jan Höppner --- genprotimg/src/pv/pv_comp.c | 26 +++++------ genprotimg/src/pv/pv_comp.h | 4 +- genprotimg/src/pv/pv_comps.c | 10 ++--- genprotimg/src/pv/pv_comps.h | 4 +- genprotimg/src/pv/pv_hdr.c | 24 +++++------ genprotimg/src/pv/pv_hdr.h | 4 +- genprotimg/src/pv/pv_image.c | 70 +++++++++++++++--------------- genprotimg/src/pv/pv_image.h | 14 +++--- genprotimg/src/pv/pv_ipib.c | 4 +- genprotimg/src/pv/pv_ipib.h | 2 +- genprotimg/src/pv/pv_stage3.c | 26 +++++------ genprotimg/src/pv/pv_stage3.h | 10 ++--- genprotimg/src/utils/buffer.c | 18 ++++---- genprotimg/src/utils/buffer.h | 16 +++---- genprotimg/src/utils/crypto.c | 72 +++++++++++++++---------------- genprotimg/src/utils/crypto.h | 28 ++++++------ genprotimg/src/utils/file_utils.c | 4 +- genprotimg/src/utils/file_utils.h | 2 +- 18 files changed, 169 insertions(+), 169 deletions(-) diff --git a/genprotimg/src/pv/pv_comp.c b/genprotimg/src/pv/pv_comp.c index 1f64eea8..21879ae7 100644 --- a/genprotimg/src/pv/pv_comp.c +++ b/genprotimg/src/pv/pv_comp.c @@ -73,12 +73,12 @@ PvComponent *pv_component_new_file(PvComponentType type, const gchar *path, return pv_component_new(type, size, DATA_FILE, (void **)&file, err); } -PvComponent *pv_component_new_buf(PvComponentType type, const Buffer *buf, +PvComponent *pv_component_new_buf(PvComponentType type, const PvBuffer *buf, GError **err) { g_assert(buf); - g_autoptr(Buffer) dup_buf = buffer_dup(buf, FALSE); + g_autoptr(PvBuffer) dup_buf = pv_buffer_dup(buf, FALSE); return pv_component_new(type, buf->size, DATA_BUFFER, (void **)&dup_buf, err); } @@ -90,7 +90,7 @@ void pv_component_free(PvComponent *component) switch ((PvComponentDataType)component->d_type) { case DATA_BUFFER: - buffer_clear(&component->buf); + pv_buffer_clear(&component->buf); break; case DATA_FILE: comp_file_free(component->file); @@ -162,21 +162,21 @@ gint pv_component_align_and_encrypt(PvComponent *component, const gchar *tmp_pat switch ((PvComponentDataType)component->d_type) { case DATA_BUFFER: { - g_autoptr(Buffer) enc_buf = NULL; + g_autoptr(PvBuffer) enc_buf = NULL; if (!(IS_PAGE_ALIGNED(pv_component_size(component)))) { - g_autoptr(Buffer) new = NULL; + g_autoptr(PvBuffer) new = NULL; /* create a page aligned copy */ - new = buffer_dup(component->buf, TRUE); - buffer_clear(&component->buf); + new = pv_buffer_dup(component->buf, TRUE); + pv_buffer_clear(&component->buf); component->buf = g_steal_pointer(&new); } enc_buf = encrypt_buf(parms, component->buf, err); if (!enc_buf) return -1; - buffer_clear(&component->buf); + pv_buffer_clear(&component->buf); component->buf = g_steal_pointer(&enc_buf); return 0; } @@ -220,10 +220,10 @@ gint pv_component_align(PvComponent *component, const gchar *tmp_path, switch (component->d_type) { case DATA_BUFFER: { - g_autoptr(Buffer) buf = NULL; + g_autoptr(PvBuffer) buf = NULL; - buf = buffer_dup(component->buf, TRUE); - buffer_clear(&component->buf); + buf = pv_buffer_dup(component->buf, TRUE); + pv_buffer_clear(&component->buf); component->buf = g_steal_pointer(&buf); return 0; } break; @@ -301,7 +301,7 @@ int64_t pv_component_update_pld(const PvComponent *comp, EVP_MD_CTX *ctx, switch (comp->d_type) { case DATA_BUFFER: { - const Buffer *buf = comp->buf; + const PvBuffer *buf = comp->buf; g_assert(buf->size <= INT64_MAX); g_assert(buf->size == size); @@ -425,7 +425,7 @@ gint pv_component_write(const PvComponent *component, FILE *f, GError **err) switch (component->d_type) { case DATA_BUFFER: { - const Buffer *buf = component->buf; + const PvBuffer *buf = component->buf; if (seek_and_write_buffer(f, buf, offset, err) < 0) return -1; diff --git a/genprotimg/src/pv/pv_comp.h b/genprotimg/src/pv/pv_comp.h index aa1b5ae7..a4ffae81 100644 --- a/genprotimg/src/pv/pv_comp.h +++ b/genprotimg/src/pv/pv_comp.h @@ -41,7 +41,7 @@ typedef struct { gint d_type; /* PvComponentDataType */ union { struct comp_file *file; - Buffer *buf; + PvBuffer *buf; void *data; }; uint64_t src_addr; @@ -51,7 +51,7 @@ typedef struct { PvComponent *pv_component_new_file(PvComponentType type, const gchar *path, GError **err); -PvComponent *pv_component_new_buf(PvComponentType type, const Buffer *buf, +PvComponent *pv_component_new_buf(PvComponentType type, const PvBuffer *buf, GError **err); void pv_component_free(PvComponent *component); gint pv_component_type(const PvComponent *component); diff --git a/genprotimg/src/pv/pv_comps.c b/genprotimg/src/pv/pv_comps.c index 15d32f09..2d364fd0 100644 --- a/genprotimg/src/pv/pv_comps.c +++ b/genprotimg/src/pv/pv_comps.c @@ -210,13 +210,13 @@ GSList *pv_img_comps_get_comps(const PvImgComps *comps) return comps->comps; } -gint pv_img_comps_finalize(PvImgComps *comps, Buffer **pld_digest, - Buffer **ald_digest, Buffer **tld_digest, +gint pv_img_comps_finalize(PvImgComps *comps, PvBuffer **pld_digest, + PvBuffer **ald_digest, PvBuffer **tld_digest, uint64_t *nep, GError **err) { - g_autoptr(Buffer) tmp_pld_digest = NULL; - g_autoptr(Buffer) tmp_ald_digest = NULL; - g_autoptr(Buffer) tmp_tld_digest = NULL; + g_autoptr(PvBuffer) tmp_pld_digest = NULL; + g_autoptr(PvBuffer) tmp_ald_digest = NULL; + g_autoptr(PvBuffer) tmp_tld_digest = NULL; comps->finalized = TRUE; for (GSList *iterator = comps->comps; iterator; iterator = iterator->next) { diff --git a/genprotimg/src/pv/pv_comps.h b/genprotimg/src/pv/pv_comps.h index d555e36f..891ecdff 100644 --- a/genprotimg/src/pv/pv_comps.h +++ b/genprotimg/src/pv/pv_comps.h @@ -32,8 +32,8 @@ gint pv_img_comps_add_component(PvImgComps *comps, PvComponent **comp, GError **err); PvComponent *pv_img_comps_get_nth_comp(PvImgComps *comps, guint n); gint pv_img_comps_set_offset(PvImgComps *comps, gsize offset, GError **err); -gint pv_img_comps_finalize(PvImgComps *comps, Buffer **pld_digest, - Buffer **ald_digest, Buffer **tld_digest, +gint pv_img_comps_finalize(PvImgComps *comps, PvBuffer **pld_digest, + PvBuffer **ald_digest, PvBuffer **tld_digest, uint64_t *nep, GError **err); void pv_img_comps_free(PvImgComps *comps); diff --git a/genprotimg/src/pv/pv_hdr.c b/genprotimg/src/pv/pv_hdr.c index 45e721dd..e46e1761 100644 --- a/genprotimg/src/pv/pv_hdr.c +++ b/genprotimg/src/pv/pv_hdr.c @@ -76,17 +76,17 @@ uint64_t pv_hdr_get_nks(const PvHdr *hdr) } /* In-place modification of ``buf`` */ -static gint pv_hdr_encrypt(const PvHdr *hdr, const PvImage *img, Buffer *buf, +static gint pv_hdr_encrypt(const PvHdr *hdr, const PvImage *img, PvBuffer *buf, GError **err) { uint32_t hdr_len = pv_hdr_size(hdr); uint32_t aad_len = pv_hdr_aad_size(hdr); guint tag_len = pv_hdr_tag_size(hdr); uint32_t enc_len = pv_hdr_enc_size_casted(hdr); - const Buffer aad_part = { .data = buf->data, .size = aad_len }; - Buffer enc_part = { .data = (uint8_t *)buf->data + aad_len, + const PvBuffer aad_part = { .data = buf->data, .size = aad_len }; + PvBuffer enc_part = { .data = (uint8_t *)buf->data + aad_len, .size = enc_len }; - Buffer tag_part = { .data = (uint8_t *)buf->data + hdr_len - tag_len, + PvBuffer tag_part = { .data = (uint8_t *)buf->data + hdr_len - tag_len, .size = tag_len }; struct cipher_parms parms; int64_t c_len; @@ -119,9 +119,9 @@ static gint pv_hdr_aad_init(PvHdr *hdr, const PvImage *img, GError **err) g_autofree union ecdh_pub_key *cust_pub_key = NULL; struct pv_hdr_key_slot *hdr_slot = hdr->slots; struct pv_hdr_head *head = &hdr->head; - g_autoptr(Buffer) pld = NULL; - g_autoptr(Buffer) ald = NULL; - g_autoptr(Buffer) tld = NULL; + g_autoptr(PvBuffer) pld = NULL; + g_autoptr(PvBuffer) ald = NULL; + g_autoptr(PvBuffer) tld = NULL; uint64_t nep = 0; g_assert(sizeof(head->iv) == img->gcm_iv->size); @@ -250,7 +250,7 @@ PvHdr *pv_hdr_new(const PvImage *img, GError **err) return g_steal_pointer(&ret); } -static void pv_hdr_memcpy(const PvHdr *hdr, const Buffer *dst) +static void pv_hdr_memcpy(const PvHdr *hdr, const PvBuffer *dst) { uint64_t nks = pv_hdr_get_nks(hdr); uint8_t *data; @@ -270,13 +270,13 @@ static void pv_hdr_memcpy(const PvHdr *hdr, const Buffer *dst) } } -Buffer *pv_hdr_serialize(const PvHdr *hdr, const PvImage *img, - enum PvCryptoMode mode, GError **err) +PvBuffer *pv_hdr_serialize(const PvHdr *hdr, const PvImage *img, + enum PvCryptoMode mode, GError **err) { uint32_t hdr_size = pv_hdr_size(hdr); - g_autoptr(Buffer) ret = NULL; + g_autoptr(PvBuffer) ret = NULL; - ret = buffer_alloc(hdr_size); + ret = pv_buffer_alloc(hdr_size); pv_hdr_memcpy(hdr, ret); if (mode == PV_ENCRYPT) { diff --git a/genprotimg/src/pv/pv_hdr.h b/genprotimg/src/pv/pv_hdr.h index 8df7a6f1..fbcc9e9e 100644 --- a/genprotimg/src/pv/pv_hdr.h +++ b/genprotimg/src/pv/pv_hdr.h @@ -23,8 +23,8 @@ PvHdr *pv_hdr_new(const PvImage *img, GError **err); void pv_hdr_free(PvHdr *hdr); G_GNUC_UNUSED gboolean pv_hdr_uses_encryption(const PvHdr *hdr); -Buffer *pv_hdr_serialize(const PvHdr *hdr, const PvImage *img, - enum PvCryptoMode mode, GError **err); +PvBuffer *pv_hdr_serialize(const PvHdr *hdr, const PvImage *img, + enum PvCryptoMode mode, GError **err); uint32_t pv_hdr_size(const PvHdr *hdr); uint32_t pv_hdr_aad_size(const PvHdr *hdr); uint64_t pv_hdr_enc_size(const PvHdr *hdr); diff --git a/genprotimg/src/pv/pv_image.c b/genprotimg/src/pv/pv_image.c index 59eca5e3..375e40f6 100644 --- a/genprotimg/src/pv/pv_image.c +++ b/genprotimg/src/pv/pv_image.c @@ -56,7 +56,7 @@ static gint pv_img_prepare_component(const PvImage *img, PvComponent *comp, GError **err) { struct cipher_parms parms = { 0 }; - g_autoptr(Buffer) tweak = NULL; + g_autoptr(PvBuffer) tweak = NULL; prepare_func func = NULL; void *opaque = NULL; gint rc; @@ -76,7 +76,7 @@ static gint pv_img_prepare_component(const PvImage *img, PvComponent *comp, EVP_CIPHER_iv_length(cipher)); g_assert(img->xts_key->size <= UINT_MAX); - tweak = buffer_alloc(sizeof(comp->tweak.data)); + tweak = pv_buffer_alloc(sizeof(comp->tweak.data)); memcpy(tweak->data, comp->tweak.data, tweak->size); func = pv_component_align_and_encrypt; parms.cipher = cipher; @@ -93,11 +93,11 @@ static gint pv_img_prepare_component(const PvImage *img, PvComponent *comp, return 0; } -static Buffer *pv_img_read_key(const gchar *path, guint key_size, - GError **err) +static PvBuffer *pv_img_read_key(const gchar *path, guint key_size, + GError **err) { - g_autoptr(Buffer) tmp_ret = NULL; - Buffer *ret = NULL; + g_autoptr(PvBuffer) tmp_ret = NULL; + PvBuffer *ret = NULL; gsize bytes_read; FILE *f = NULL; gsize size; @@ -116,7 +116,7 @@ static Buffer *pv_img_read_key(const gchar *path, guint key_size, if (!f) return NULL; - tmp_ret = buffer_alloc(size); + tmp_ret = pv_buffer_alloc(size); if (file_read(f, tmp_ret->data, 1, tmp_ret->size, &bytes_read, err) < 0) goto err; @@ -160,8 +160,8 @@ static HostKeyList *pv_img_get_host_keys(GSList *host_keys_with_path, gint nid, return g_steal_pointer(&ret); } -static Buffer *pv_img_get_key(const EVP_CIPHER *cipher, const gchar *path, - GError **err) +static PvBuffer *pv_img_get_key(const EVP_CIPHER *cipher, const gchar *path, + GError **err) { gint key_len = EVP_CIPHER_key_length(cipher); @@ -173,8 +173,8 @@ static Buffer *pv_img_get_key(const EVP_CIPHER *cipher, const gchar *path, return generate_aes_key((guint)key_len, err); } -static Buffer *pv_img_get_iv(const EVP_CIPHER *cipher, const gchar *path, - GError **err) +static PvBuffer *pv_img_get_iv(const EVP_CIPHER *cipher, const gchar *path, + GError **err) { gint iv_len = EVP_CIPHER_iv_length(cipher); @@ -485,23 +485,23 @@ static void pv_hdr_key_slot_free(PvHdrKeySlot *slot) WRAPPED_G_DEFINE_AUTOPTR_CLEANUP_FUNC(PvHdrKeySlot, pv_hdr_key_slot_free) static PvHdrKeySlot *pv_hdr_key_slot_new(const EVP_CIPHER *gcm_cipher, - const Buffer *cust_root_key, + const PvBuffer *cust_root_key, EVP_PKEY *cust_key, EVP_PKEY *host_key, GError **err) { g_autoptr(PvHdrKeySlot) ret = g_new0(PvHdrKeySlot, 1); g_autofree union ecdh_pub_key *pub = NULL; - g_autoptr(Buffer) exchange_key = NULL; - g_autoptr(Buffer) digest_key = NULL; - g_autoptr(Buffer) iv = NULL; - Buffer pub_buf; + g_autoptr(PvBuffer) exchange_key = NULL; + g_autoptr(PvBuffer) digest_key = NULL; + g_autoptr(PvBuffer) iv = NULL; + PvBuffer pub_buf; /* No AAD data is used */ - Buffer aad = { .data = NULL, .size = 0 }; + PvBuffer aad = { .data = NULL, .size = 0 }; /* Set the output buffers for the encrypted data and the * generated GCM tag */ - Buffer enc = { .data = ret->wrapped_key, .size = sizeof(ret->wrapped_key) }; - Buffer tag = { .data = ret->tag, .size = sizeof(ret->tag) }; + PvBuffer enc = { .data = ret->wrapped_key, .size = sizeof(ret->wrapped_key) }; + PvBuffer tag = { .data = ret->tag, .size = sizeof(ret->tag) }; struct cipher_parms parms; int64_t c_len = 0; @@ -530,7 +530,7 @@ static PvHdrKeySlot *pv_hdr_key_slot_new(const EVP_CIPHER *gcm_cipher, g_assert(exchange_key->size == (guint)EVP_CIPHER_key_length(gcm_cipher)); /* create zero IV */ - iv = buffer_alloc((guint)EVP_CIPHER_iv_length(gcm_cipher)); + iv = pv_buffer_alloc((guint)EVP_CIPHER_iv_length(gcm_cipher)); parms.iv_or_tweak = iv; parms.key = exchange_key; parms.cipher = gcm_cipher; @@ -637,13 +637,13 @@ void pv_img_free(PvImage *img) g_slist_free_full(img->key_slots, (GDestroyNotify)pv_hdr_key_slot_free); g_slist_free_full(img->host_pub_keys, (GDestroyNotify)EVP_PKEY_free); EVP_PKEY_free(img->cust_pub_priv_key); - buffer_clear(&img->stage3a); + pv_buffer_clear(&img->stage3a); pv_img_comps_free(img->comps); g_free(img->tmp_dir); - buffer_free(img->xts_key); - buffer_free(img->cust_root_key); - buffer_free(img->gcm_iv); - buffer_free(img->cust_comm_key); + pv_buffer_free(img->xts_key); + pv_buffer_free(img->cust_root_key); + pv_buffer_free(img->gcm_iv); + pv_buffer_free(img->cust_comm_key); g_free(img); } @@ -684,13 +684,13 @@ gint pv_img_add_component(PvImage *img, const PvArg *arg, GError **err) return 0; } -gint pv_img_calc_pld_ald_tld_nep(const PvImage *img, Buffer **pld, Buffer **ald, - Buffer **tld, uint64_t *nep, GError **err) +gint pv_img_calc_pld_ald_tld_nep(const PvImage *img, PvBuffer **pld, PvBuffer **ald, + PvBuffer **tld, uint64_t *nep, GError **err) { return pv_img_comps_finalize(img->comps, pld, ald, tld, nep, err); } -static gint pv_img_build_stage3b(PvImage *img, Buffer *stage3b, GError **err) +static gint pv_img_build_stage3b(PvImage *img, PvBuffer *stage3b, GError **err) { g_autofree struct stage3b_args *args = NULL; @@ -708,7 +708,7 @@ static gint pv_img_build_stage3b(PvImage *img, Buffer *stage3b, GError **err) gint pv_img_add_stage3b_comp(PvImage *img, const gchar *path, GError **err) { g_autoptr(PvComponent) comp = NULL; - g_autoptr(Buffer) stage3b = NULL; + g_autoptr(PvBuffer) stage3b = NULL; stage3b = stage3b_getblob(path, err); if (!stage3b) @@ -825,7 +825,7 @@ static gint get_stage3a_data_size(const PvImage *img, gsize *data_size, gint pv_img_load_and_set_stage3a(PvImage *img, const gchar *path, GError **err) { - g_autoptr(Buffer) stage3a = NULL; + g_autoptr(PvBuffer) stage3a = NULL; gsize bin_size, data_size = 0; if (get_stage3a_data_size(img, &data_size, err) < 0) @@ -845,8 +845,8 @@ gint pv_img_load_and_set_stage3a(PvImage *img, const gchar *path, GError **err) } /* Creates the PV IPIB and sets the stage3a arguments */ -static gint pv_img_build_stage3a(Buffer *stage3a, gsize stage3a_bin_size, - GSList *comps, const Buffer *hdr, GError **err) +static gint pv_img_build_stage3a(PvBuffer *stage3a, gsize stage3a_bin_size, + GSList *comps, const PvBuffer *hdr, GError **err) { g_autofree struct ipl_parameter_block *ipib = NULL; @@ -866,9 +866,9 @@ static gint pv_img_build_stage3a(Buffer *stage3a, gsize stage3a_bin_size, } /* Creates the actual PV header (serialized and AES-GCM encrypted) */ -static Buffer *pv_img_create_pv_hdr(PvImage *img, GError **err) +static PvBuffer *pv_img_create_pv_hdr(PvImage *img, GError **err) { - g_autoptr(Buffer) hdr_buf = NULL; + g_autoptr(PvBuffer) hdr_buf = NULL; g_autoptr(PvHdr) hdr = NULL; hdr = pv_hdr_new(img, err); @@ -887,7 +887,7 @@ static Buffer *pv_img_create_pv_hdr(PvImage *img, GError **err) */ gint pv_img_finalize(PvImage *pv, const gchar *stage3b_path, GError **err) { - g_autoptr(Buffer) hdr = NULL; + g_autoptr(PvBuffer) hdr = NULL; /* load stage3b template into memory and add it to the list of * components. This must be done before calling diff --git a/genprotimg/src/pv/pv_image.h b/genprotimg/src/pv/pv_image.h index 7c624e24..116fb1a9 100644 --- a/genprotimg/src/pv/pv_image.h +++ b/genprotimg/src/pv/pv_image.h @@ -25,7 +25,7 @@ typedef struct { gchar *tmp_dir; /* directory used for temporary files */ - Buffer *stage3a; /* stage3a containing IPIB and PV header */ + PvBuffer *stage3a; /* stage3a containing IPIB and PV header */ gsize stage3a_bin_size; /* size of stage3a.bin */ struct psw_t stage3a_psw; /* (short) PSW that is written to * location 0 of the created image @@ -35,15 +35,15 @@ typedef struct { GSList *host_pub_keys; /* public host keys */ gint nid; /* Elliptic Curve used for the key derivation */ /* keys and cipher used for the AES-GCM encryption */ - Buffer *cust_root_key; - Buffer *gcm_iv; + PvBuffer *cust_root_key; + PvBuffer *gcm_iv; const EVP_CIPHER *gcm_cipher; /* Information for the IPIB and PV header */ uint64_t pcf; uint64_t scf; - Buffer *cust_comm_key; + PvBuffer *cust_comm_key; const EVP_CIPHER *cust_comm_cipher; - Buffer *xts_key; + PvBuffer *xts_key; const EVP_CIPHER *xts_cipher; GSList *key_slots; GSList *optional_items; @@ -54,8 +54,8 @@ PvImage *pv_img_new(PvArgs *args, const gchar *stage3a_path, GError **err); void pv_img_free(PvImage *img); gint pv_img_add_component(PvImage *img, const PvArg *arg, GError **err); gint pv_img_finalize(PvImage *img, const gchar *stage3b_path, GError **err); -gint pv_img_calc_pld_ald_tld_nep(const PvImage *img, Buffer **pld, Buffer **ald, - Buffer **tld, uint64_t *nep, GError **err); +gint pv_img_calc_pld_ald_tld_nep(const PvImage *img, PvBuffer **pld, PvBuffer **ald, + PvBuffer **tld, uint64_t *nep, GError **err); gint pv_img_load_and_set_stage3a(PvImage *img, const gchar *path, GError **err); const PvComponent *pv_img_get_stage3b_comp(const PvImage *img, GError **err); gint pv_img_add_stage3b_comp(PvImage *img, const gchar *path, GError **err); diff --git a/genprotimg/src/pv/pv_ipib.c b/genprotimg/src/pv/pv_ipib.c index 2517e548..59fe0086 100644 --- a/genprotimg/src/pv/pv_ipib.c +++ b/genprotimg/src/pv/pv_ipib.c @@ -35,7 +35,7 @@ uint64_t pv_ipib_get_size(uint32_t num_comp) } static gint pv_ipib_init(IplParameterBlock *ipib, GSList *comps, - const Buffer *hdr) + const PvBuffer *hdr) { g_assert(sizeof(struct ipl_pl_hdr) <= UINT32_MAX); g_assert(sizeof(struct ipl_pb0_pv_comp) <= UINT32_MAX); @@ -100,7 +100,7 @@ static gint pv_ipib_init(IplParameterBlock *ipib, GSList *comps, return 0; } -IplParameterBlock *pv_ipib_new(GSList *comps, const Buffer *hdr, GError **err) +IplParameterBlock *pv_ipib_new(GSList *comps, const PvBuffer *hdr, GError **err) { uint64_t ipib_size = pv_ipib_get_size(g_slist_length(comps)); g_autoptr(IplParameterBlock) ret = NULL; diff --git a/genprotimg/src/pv/pv_ipib.h b/genprotimg/src/pv/pv_ipib.h index 93317901..4b66643d 100644 --- a/genprotimg/src/pv/pv_ipib.h +++ b/genprotimg/src/pv/pv_ipib.h @@ -19,7 +19,7 @@ typedef struct ipl_parameter_block IplParameterBlock; uint64_t pv_ipib_get_size(uint32_t num_comp); -IplParameterBlock *pv_ipib_new(GSList *comps, const Buffer *hdr, GError **err); +IplParameterBlock *pv_ipib_new(GSList *comps, const PvBuffer *hdr, GError **err); void pv_ipib_free(IplParameterBlock *ipib); WRAPPED_G_DEFINE_AUTOPTR_CLEANUP_FUNC(IplParameterBlock, pv_ipib_free) diff --git a/genprotimg/src/pv/pv_stage3.c b/genprotimg/src/pv/pv_stage3.c index a1e5b164..bff9db7d 100644 --- a/genprotimg/src/pv/pv_stage3.c +++ b/genprotimg/src/pv/pv_stage3.c @@ -24,12 +24,12 @@ ((struct stage3a_args *)((uint64_t)data_ptr + loader_size - \ sizeof(struct stage3a_args))) -static Buffer *loader_getblob(const gchar *filename, gsize *loader_size, - gsize args_size, gsize data_size, - gboolean data_aligned, GError **err) +static PvBuffer *loader_getblob(const gchar *filename, gsize *loader_size, + gsize args_size, gsize data_size, + gboolean data_aligned, GError **err) { g_autoptr(GMappedFile) mapped_file = NULL; - g_autoptr(Buffer) ret = NULL; + g_autoptr(PvBuffer) ret = NULL; gsize size, tmp_loader_size; gchar *loader_data; @@ -60,7 +60,7 @@ static Buffer *loader_getblob(const gchar *filename, gsize *loader_size, size = (data_aligned ? PAGE_ALIGN(tmp_loader_size) : tmp_loader_size) + data_size; - ret = buffer_alloc(size); + ret = pv_buffer_alloc(size); /* copy the loader "template" */ memcpy(ret->data, loader_data, tmp_loader_size); @@ -71,8 +71,8 @@ static Buffer *loader_getblob(const gchar *filename, gsize *loader_size, return g_steal_pointer(&ret); } -Buffer *stage3a_getblob(const gchar *filename, gsize *loader_size, - gsize data_size, GError **err) +PvBuffer *stage3a_getblob(const gchar *filename, gsize *loader_size, + gsize data_size, GError **err) { return loader_getblob(filename, loader_size, sizeof(struct stage3a_args), data_size, TRUE, @@ -83,8 +83,8 @@ Buffer *stage3a_getblob(const gchar *filename, gsize *loader_size, /* Set the right offsets and sizes in the stage3a template + add * the IPIB block with the PV header */ -static gint stage3a_set_data(Buffer *loader, gsize loader_size, - const Buffer *hdr, struct ipl_parameter_block *ipib, +static gint stage3a_set_data(PvBuffer *loader, gsize loader_size, + const PvBuffer *hdr, struct ipl_parameter_block *ipib, GError **err) { uint32_t ipib_size = GUINT32_FROM_BE(ipib->hdr.len); @@ -126,15 +126,15 @@ static gint stage3a_set_data(Buffer *loader, gsize loader_size, return 0; } -gint build_stage3a(Buffer *loader, gsize loader_size, const Buffer *hdr, +gint build_stage3a(PvBuffer *loader, gsize loader_size, const PvBuffer *hdr, struct ipl_parameter_block *ipib, GError **err) { return stage3a_set_data(loader, loader_size, hdr, ipib, err); } -Buffer *stage3b_getblob(const gchar *filename, GError **err) +PvBuffer *stage3b_getblob(const gchar *filename, GError **err) { - g_autoptr(Buffer) ret = NULL; + g_autoptr(PvBuffer) ret = NULL; gsize rb_size; ret = loader_getblob(filename, &rb_size, sizeof(struct stage3b_args), 0, @@ -146,7 +146,7 @@ Buffer *stage3b_getblob(const gchar *filename, GError **err) return g_steal_pointer(&ret); } -void build_stage3b(Buffer *stage3b, const struct stage3b_args *args) +void build_stage3b(PvBuffer *stage3b, const struct stage3b_args *args) { g_assert(stage3b->size > sizeof(*args)); diff --git a/genprotimg/src/pv/pv_stage3.h b/genprotimg/src/pv/pv_stage3.h index baaf921b..364408ee 100644 --- a/genprotimg/src/pv/pv_stage3.h +++ b/genprotimg/src/pv/pv_stage3.h @@ -19,12 +19,12 @@ #include "boot/stage3b.h" #include "utils/buffer.h" -Buffer *stage3a_getblob(const gchar *filename, gsize *loader_size, - gsize data_size, GError **err); -gint build_stage3a(Buffer *dc, gsize dc_size, const Buffer *hdr, +PvBuffer *stage3a_getblob(const gchar *filename, gsize *loader_size, + gsize data_size, GError **err); +gint build_stage3a(PvBuffer *dc, gsize dc_size, const PvBuffer *hdr, struct ipl_parameter_block *ipib, GError **err); -Buffer *stage3b_getblob(const gchar *filename, GError **err); -void build_stage3b(Buffer *stage3b, const struct stage3b_args *args); +PvBuffer *stage3b_getblob(const gchar *filename, GError **err); +void build_stage3b(PvBuffer *stage3b, const struct stage3b_args *args); void memblob_init(struct memblob *arg, uint64_t src, uint64_t size); #endif diff --git a/genprotimg/src/utils/buffer.c b/genprotimg/src/utils/buffer.c index 35aed742..509dc0de 100644 --- a/genprotimg/src/utils/buffer.c +++ b/genprotimg/src/utils/buffer.c @@ -17,18 +17,18 @@ #include "common.h" #include "file_utils.h" -Buffer *buffer_alloc(gsize size) +PvBuffer *pv_buffer_alloc(gsize size) { - Buffer *ret = g_new0(Buffer, 1); + PvBuffer *ret = g_new0(PvBuffer, 1); ret->data = g_malloc0(size); ret->size = size; return ret; } -Buffer *buffer_dup(const Buffer *buf, gboolean page_aligned) +PvBuffer *pv_buffer_dup(const PvBuffer *buf, gboolean page_aligned) { - Buffer *ret; + PvBuffer *ret; gsize size; if (!buf) @@ -38,19 +38,19 @@ Buffer *buffer_dup(const Buffer *buf, gboolean page_aligned) if (page_aligned) size = PAGE_ALIGN(size); - ret = buffer_alloc(size); + ret = pv_buffer_alloc(size); /* content will be 0-right-padded */ memcpy(ret->data, buf->data, buf->size); return ret; } -gint buffer_write(const Buffer *buf, FILE *file, GError **err) +gint pv_buffer_write(const PvBuffer *buf, FILE *file, GError **err) { return file_write(file, buf->data, buf->size, 1, NULL, err); } -void buffer_free(Buffer *buf) +void pv_buffer_free(PvBuffer *buf) { if (!buf) return; @@ -59,11 +59,11 @@ void buffer_free(Buffer *buf) g_free(buf); } -void buffer_clear(Buffer **buf) +void pv_buffer_clear(PvBuffer **buf) { if (!buf || !*buf) return; - buffer_free(*buf); + pv_buffer_free(*buf); *buf = NULL; } diff --git a/genprotimg/src/utils/buffer.h b/genprotimg/src/utils/buffer.h index 7239d5c9..824b72cb 100644 --- a/genprotimg/src/utils/buffer.h +++ b/genprotimg/src/utils/buffer.h @@ -15,17 +15,17 @@ #include "common.h" -typedef struct Buffer { +typedef struct PvBuffer { void *data; gsize size; /* in bytes */ -} Buffer; +} PvBuffer; -Buffer *buffer_alloc(gsize size); -void buffer_free(Buffer *buf); -void buffer_clear(Buffer **buf); -gint buffer_write(const Buffer *buf, FILE *file, GError **err); -Buffer *buffer_dup(const Buffer *buf, gboolean page_aligned); +PvBuffer *pv_buffer_alloc(gsize size); +void pv_buffer_free(PvBuffer *buf); +void pv_buffer_clear(PvBuffer **buf); +gint pv_buffer_write(const PvBuffer *buf, FILE *file, GError **err); +PvBuffer *pv_buffer_dup(const PvBuffer *buf, gboolean page_aligned); -WRAPPED_G_DEFINE_AUTOPTR_CLEANUP_FUNC(Buffer, buffer_free) +WRAPPED_G_DEFINE_AUTOPTR_CLEANUP_FUNC(PvBuffer, pv_buffer_free) #endif diff --git a/genprotimg/src/utils/crypto.c b/genprotimg/src/utils/crypto.c index 44facc28..05c3e832 100644 --- a/genprotimg/src/utils/crypto.c +++ b/genprotimg/src/utils/crypto.c @@ -89,15 +89,15 @@ EVP_MD_CTX *digest_ctx_new(const EVP_MD *md, GError **err) return g_steal_pointer(&ctx); } -Buffer *digest_ctx_finalize(EVP_MD_CTX *ctx, GError **err) +PvBuffer *digest_ctx_finalize(EVP_MD_CTX *ctx, GError **err) { gint md_size = EVP_MD_size(EVP_MD_CTX_md(ctx)); - g_autoptr(Buffer) ret = NULL; + g_autoptr(PvBuffer) ret = NULL; guint digest_size; g_assert(md_size > 0); - ret = buffer_alloc((guint)md_size); + ret = pv_buffer_alloc((guint)md_size); if (EVP_DigestFinal_ex(ctx, ret->data, &digest_size) != 1) { g_set_error(err, PV_CRYPTO_ERROR, PV_CRYPTO_ERROR_INTERNAL, _("EVP_DigestFinal_ex failed")); @@ -110,10 +110,10 @@ Buffer *digest_ctx_finalize(EVP_MD_CTX *ctx, GError **err) } /* Returns the digest of @buf using the hash algorithm @md */ -static Buffer *digest_buffer(const EVP_MD *md, const Buffer *buf, GError **err) +static PvBuffer *digest_buffer(const EVP_MD *md, const PvBuffer *buf, GError **err) { g_autoptr(EVP_MD_CTX) md_ctx = NULL; - g_autoptr(Buffer) ret = NULL; + g_autoptr(PvBuffer) ret = NULL; g_assert(buf); md_ctx = digest_ctx_new(md, err); @@ -134,9 +134,9 @@ static Buffer *digest_buffer(const EVP_MD *md, const Buffer *buf, GError **err) } /* Returns the SHA256 digest of @buf */ -Buffer *sha256_buffer(const Buffer *buf, GError **err) +PvBuffer *sha256_buffer(const PvBuffer *buf, GError **err) { - g_autoptr(Buffer) ret = NULL; + g_autoptr(PvBuffer) ret = NULL; ret = digest_buffer(EVP_sha256(), buf, err); if (!ret) @@ -207,10 +207,10 @@ union ecdh_pub_key *evp_pkey_to_ecdh_pub_key(EVP_PKEY *key, GError **err) return g_steal_pointer(&ret); } -static Buffer *derive_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err) +static PvBuffer *derive_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err) { g_autoptr(EVP_PKEY_CTX) ctx = NULL; - g_autoptr(Buffer) ret = NULL; + g_autoptr(PvBuffer) ret = NULL; gsize key_size; ctx = EVP_PKEY_CTX_new(cust, NULL); @@ -236,7 +236,7 @@ static Buffer *derive_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err) return NULL; } - ret = buffer_alloc(key_size); + ret = pv_buffer_alloc(key_size); if (EVP_PKEY_derive(ctx, ret->data, &key_size) != 1) { g_set_error(err, PV_CRYPTO_ERROR, PV_CRYPTO_ERROR_DERIVE, _("Key derivation failed")); @@ -247,11 +247,11 @@ static Buffer *derive_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err) return g_steal_pointer(&ret); } -Buffer *compute_exchange_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err) +PvBuffer *compute_exchange_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err) { - g_autoptr(Buffer) raw = buffer_alloc(70); - g_autoptr(Buffer) ret = NULL; - g_autoptr(Buffer) key = NULL; + g_autoptr(PvBuffer) raw = pv_buffer_alloc(70); + g_autoptr(PvBuffer) ret = NULL; + g_autoptr(PvBuffer) key = NULL; guchar *data; key = derive_key(cust, host, err); @@ -290,10 +290,10 @@ gint generate_tweak(union tweak *tweak, uint16_t i, GError **err) return 0; } -static Buffer *generate_rand_data(guint size, const gchar *err_msg, - GError **err) +static PvBuffer *generate_rand_data(guint size, const gchar *err_msg, + GError **err) { - g_autoptr(Buffer) buf = buffer_alloc(size); + g_autoptr(PvBuffer) buf = pv_buffer_alloc(size); g_assert(size <= INT_MAX); @@ -307,14 +307,14 @@ static Buffer *generate_rand_data(guint size, const gchar *err_msg, return g_steal_pointer(&buf); } -Buffer *generate_aes_iv(guint size, GError **err) +PvBuffer *generate_aes_iv(guint size, GError **err) { return generate_rand_data(size, _("Generating a IV failed because the required amount of random data is not available"), err); } -Buffer *generate_aes_key(guint size, GError **err) +PvBuffer *generate_aes_key(guint size, GError **err) { return generate_rand_data(size, _("Generating a key failed because the required amount of random data is not available"), @@ -1756,8 +1756,8 @@ static gint __encrypt_decrypt_bio(const struct cipher_parms *parms, BIO *b_in, gint cipher_block_size = EVP_CIPHER_block_size(cipher); guchar in_buf[PAGE_SIZE], out_buf[PAGE_SIZE + (guint)cipher_block_size]; - const Buffer *key = parms->key; - const Buffer *tweak = parms->iv_or_tweak; + const PvBuffer *key = parms->key; + const PvBuffer *tweak = parms->iv_or_tweak; g_autofree guchar *tmp_tweak = NULL; gint out_len, tweak_size; gsize tmp_size_in = 0, tmp_size_out = 0; @@ -1895,11 +1895,11 @@ static gint __encrypt_decrypt_bio(const struct cipher_parms *parms, BIO *b_in, return 0; } -static Buffer *__encrypt_decrypt_buffer(const struct cipher_parms *parms, - const Buffer *in, gboolean encrypt, - GError **err) +static PvBuffer *__encrypt_decrypt_buffer(const struct cipher_parms *parms, + const PvBuffer *in, gboolean encrypt, + GError **err) { - g_autoptr(Buffer) ret = NULL; + g_autoptr(PvBuffer) ret = NULL; g_autoptr(BIO) b_out = NULL; g_autoptr(BIO) b_in = NULL; gsize in_size, out_size; @@ -1927,19 +1927,19 @@ static Buffer *__encrypt_decrypt_buffer(const struct cipher_parms *parms, return NULL; } - ret = buffer_alloc((unsigned long)data_size); + ret = pv_buffer_alloc((unsigned long)data_size); memcpy(ret->data, data, ret->size); return g_steal_pointer(&ret); } -Buffer *encrypt_buf(const struct cipher_parms *parms, const Buffer *in, - GError **err) +PvBuffer *encrypt_buf(const struct cipher_parms *parms, const PvBuffer *in, + GError **err) { return __encrypt_decrypt_buffer(parms, in, TRUE, err); } -Buffer *decrypt_buf(const struct cipher_parms *parms, const Buffer *in, - GError **err) +PvBuffer *decrypt_buf(const struct cipher_parms *parms, const PvBuffer *in, + GError **err) { return __encrypt_decrypt_buffer(parms, in, FALSE, err); } @@ -1993,16 +1993,16 @@ G_GNUC_UNUSED static gint decrypt_file(const struct cipher_parms *parms, } /* GCM mode uses (zero-)padding */ -static int64_t gcm_encrypt_decrypt(const Buffer *in, const Buffer *aad, +static int64_t gcm_encrypt_decrypt(const PvBuffer *in, const PvBuffer *aad, const struct cipher_parms *parms, - Buffer *out, Buffer *tag, + PvBuffer *out, PvBuffer *tag, enum PvCryptoMode mode, GError **err) { g_autoptr(EVP_CIPHER_CTX) ctx = NULL; const EVP_CIPHER *cipher = parms->cipher; - const Buffer *iv = parms->iv_or_tweak; + const PvBuffer *iv = parms->iv_or_tweak; gboolean encrypt = mode == PV_ENCRYPT; - const Buffer *key = parms->key; + const PvBuffer *key = parms->key; int64_t ret = -1; gint len = -1; @@ -2097,8 +2097,8 @@ static int64_t gcm_encrypt_decrypt(const Buffer *in, const Buffer *aad, return ret; } -int64_t gcm_encrypt(const Buffer *in, const Buffer *aad, - const struct cipher_parms *parms, Buffer *out, Buffer *tag, +int64_t gcm_encrypt(const PvBuffer *in, const PvBuffer *aad, + const struct cipher_parms *parms, PvBuffer *out, PvBuffer *tag, GError **err) { return gcm_encrypt_decrypt(in, aad, parms, out, tag, PV_ENCRYPT, err); diff --git a/genprotimg/src/utils/crypto.h b/genprotimg/src/utils/crypto.h index 286cf457..3cda4507 100644 --- a/genprotimg/src/utils/crypto.h +++ b/genprotimg/src/utils/crypto.h @@ -117,8 +117,8 @@ union tweak { struct cipher_parms { const EVP_CIPHER *cipher; - const Buffer *key; - const Buffer *iv_or_tweak; + const PvBuffer *key; + const PvBuffer *iv_or_tweak; }; int check_crl_valid_for_cert(X509_CRL *crl, X509 *cert, @@ -152,24 +152,24 @@ X509_CRL *get_first_valid_crl(X509_STORE_CTX *ctx, X509 *cert, GError **err); void store_setup_crl_download(X509_STORE *st); EVP_PKEY *read_ec_pubkey_cert(X509 *cert, gint nid, GError **err); -Buffer *compute_exchange_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err); -Buffer *generate_aes_key(guint size, GError **err); -Buffer *generate_aes_iv(guint size, GError **err); +PvBuffer *compute_exchange_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err); +PvBuffer *generate_aes_key(guint size, GError **err); +PvBuffer *generate_aes_iv(guint size, GError **err); EVP_PKEY *generate_ec_key(gint nid, GError **err); gint generate_tweak(union tweak *tweak, uint16_t i, GError **err); union ecdh_pub_key *evp_pkey_to_ecdh_pub_key(EVP_PKEY *key, GError **err); EVP_MD_CTX *digest_ctx_new(const EVP_MD *md, GError **err); -Buffer *digest_ctx_finalize(EVP_MD_CTX *ctx, GError **err); -Buffer *sha256_buffer(const Buffer *buf, GError **err); -int64_t gcm_encrypt(const Buffer *in, const Buffer *aad, - const struct cipher_parms *parms, Buffer *out, - Buffer *tag, GError **err); +PvBuffer *digest_ctx_finalize(EVP_MD_CTX *ctx, GError **err); +PvBuffer *sha256_buffer(const PvBuffer *buf, GError **err); +int64_t gcm_encrypt(const PvBuffer *in, const PvBuffer *aad, + const struct cipher_parms *parms, PvBuffer *out, + PvBuffer *tag, GError **err); gint encrypt_file(const struct cipher_parms *parms, const gchar *in_path, const gchar *path_out, gsize *in_size, gsize *out_size, GError **err); -Buffer *encrypt_buf(const struct cipher_parms *parms, const Buffer *in, - GError **err); -G_GNUC_UNUSED Buffer *decrypt_buf(const struct cipher_parms *parms, - const Buffer *in, GError **err); +PvBuffer *encrypt_buf(const struct cipher_parms *parms, const PvBuffer *in, + GError **err); +G_GNUC_UNUSED PvBuffer *decrypt_buf(const struct cipher_parms *parms, + const PvBuffer *in, GError **err); #endif diff --git a/genprotimg/src/utils/file_utils.c b/genprotimg/src/utils/file_utils.c index 1d6fc370..ba33400f 100644 --- a/genprotimg/src/utils/file_utils.c +++ b/genprotimg/src/utils/file_utils.c @@ -171,13 +171,13 @@ gint seek_and_write_file(FILE *o, const CompFile *ifile, uint64_t offset, return ret; } -gint seek_and_write_buffer(FILE *o, const Buffer *buf, uint64_t offset, +gint seek_and_write_buffer(FILE *o, const PvBuffer *buf, uint64_t offset, GError **err) { if (file_seek(o, offset, err) < 0) return -1; - if (buffer_write(buf, o, err) < 0) + if (pv_buffer_write(buf, o, err) < 0) return -1; return 0; diff --git a/genprotimg/src/utils/file_utils.h b/genprotimg/src/utils/file_utils.h index 47df1148..456e7aca 100644 --- a/genprotimg/src/utils/file_utils.h +++ b/genprotimg/src/utils/file_utils.h @@ -26,7 +26,7 @@ gint file_write(FILE *out, const void *ptr, gsize size, gsize count, gsize *count_written, GError **err); gint pad_file_right(const gchar *path_out, const gchar *path_in, gsize *size_out, guint padding, GError **err); -gint seek_and_write_buffer(FILE *out, const Buffer *buf, uint64_t offset, +gint seek_and_write_buffer(FILE *out, const PvBuffer *buf, uint64_t offset, GError **err); gint seek_and_write_file(FILE *o, const CompFile *ifile, uint64_t offset, GError **err);