1 /* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0-or-later */
2
3 #include <commonlib/bsd/cbfs_private.h>
4 #include <commonlib/bsd/helpers.h>
5 #include <assert.h>
6
read_next_header(cbfs_dev_t dev,size_t * offset,struct cbfs_file * buffer,const size_t devsize)7 static enum cb_err read_next_header(cbfs_dev_t dev, size_t *offset, struct cbfs_file *buffer,
8 const size_t devsize)
9 {
10 DEBUG("Looking for next file @%#zx...\n", *offset);
11 *offset = ALIGN_UP(*offset, CBFS_ALIGNMENT);
12 while (*offset + sizeof(*buffer) < devsize) {
13 if (cbfs_dev_read(dev, buffer, *offset, sizeof(*buffer)) != sizeof(*buffer))
14 return CB_CBFS_IO;
15
16 if (memcmp(buffer->magic, CBFS_FILE_MAGIC, sizeof(buffer->magic)) == 0)
17 return CB_SUCCESS;
18
19 *offset += CBFS_ALIGNMENT;
20 }
21
22 DEBUG("End of CBFS reached\n");
23 return CB_CBFS_NOT_FOUND;
24 }
25
cbfs_walk(cbfs_dev_t dev,enum cb_err (* walker)(cbfs_dev_t dev,size_t offset,const union cbfs_mdata * mdata,size_t already_read,void * arg),void * arg,struct vb2_hash * metadata_hash,enum cbfs_walk_flags flags)26 enum cb_err cbfs_walk(cbfs_dev_t dev, enum cb_err (*walker)(cbfs_dev_t dev, size_t offset,
27 const union cbfs_mdata *mdata,
28 size_t already_read, void *arg),
29 void *arg, struct vb2_hash *metadata_hash, enum cbfs_walk_flags flags)
30 {
31 const bool do_hash = CBFS_ENABLE_HASHING && metadata_hash;
32 const size_t devsize = cbfs_dev_size(dev);
33 struct vb2_digest_context dc;
34
35 assert(CBFS_ENABLE_HASHING || (!metadata_hash && !(flags & CBFS_WALK_WRITEBACK_HASH)));
36 if (do_hash && vb2_digest_init(&dc, CBFS_HASH_HWCRYPTO, metadata_hash->algo, 0))
37 return CB_ERR_ARG;
38
39 size_t offset = 0;
40 enum cb_err ret_header;
41 enum cb_err ret_walker = CB_CBFS_NOT_FOUND;
42 union cbfs_mdata mdata;
43 while ((ret_header = read_next_header(dev, &offset, &mdata.h, devsize)) == CB_SUCCESS) {
44 const uint32_t attr_offset = be32toh(mdata.h.attributes_offset);
45 const uint32_t data_offset = be32toh(mdata.h.offset);
46 const uint32_t data_length = be32toh(mdata.h.len);
47 const uint32_t type = be32toh(mdata.h.type);
48 const bool empty = (type == CBFS_TYPE_DELETED || type == CBFS_TYPE_NULL);
49
50 DEBUG("Found CBFS header @%#zx (type %d, attr +%#x, data +%#x, length %#x)\n",
51 offset, type, attr_offset, data_offset, data_length);
52 if (data_offset > sizeof(mdata) || data_length > devsize ||
53 offset + data_offset + data_length > devsize) {
54 ERROR("File @%#zx too large\n", offset);
55 offset += CBFS_ALIGNMENT;
56 continue;
57 }
58
59 if (empty && !(flags & CBFS_WALK_INCLUDE_EMPTY))
60 goto next_file;
61
62 /* When hashing we need to read everything. Otherwise skip the attributes.
63 attr_offset may be 0, which means there are no attributes. */
64 ssize_t todo;
65 if (do_hash || attr_offset == 0)
66 todo = data_offset - sizeof(mdata.h);
67 else
68 todo = attr_offset - sizeof(mdata.h);
69 if (todo <= 0 || data_offset < attr_offset) {
70 ERROR("Corrupt file header @%#zx\n", offset);
71 goto next_file;
72 }
73
74 /* Read the rest of the metadata (filename, and possibly attributes). */
75 assert(todo > 0 && todo <= sizeof(mdata) - sizeof(mdata.h));
76 if (cbfs_dev_read(dev, mdata.raw + sizeof(mdata.h),
77 offset + sizeof(mdata.h), todo) != todo)
78 return CB_CBFS_IO;
79 /* Force filename null-termination, just in case. */
80 mdata.raw[attr_offset ? attr_offset - 1 : data_offset - 1] = '\0';
81 DEBUG("File name: '%s'\n", mdata.h.filename);
82
83 if (do_hash && !empty && vb2_digest_extend(&dc, mdata.raw, data_offset))
84 return CB_ERR;
85
86 if (walker && ret_walker == CB_CBFS_NOT_FOUND)
87 ret_walker = walker(dev, offset, &mdata, sizeof(mdata.h) + todo, arg);
88
89 /* Return IO errors immediately. For others, finish the hash first if needed. */
90 if (ret_walker == CB_CBFS_IO || (ret_walker != CB_CBFS_NOT_FOUND && !do_hash))
91 return ret_walker;
92
93 next_file:
94 offset += data_offset + data_length;
95 }
96
97 if (ret_header != CB_CBFS_NOT_FOUND)
98 return ret_header;
99
100 if (do_hash) {
101 uint8_t real_hash[VB2_MAX_DIGEST_SIZE];
102 size_t hash_size = vb2_digest_size(metadata_hash->algo);
103 if (vb2_digest_finalize(&dc, real_hash, hash_size))
104 return CB_ERR;
105 if (flags & CBFS_WALK_WRITEBACK_HASH)
106 memcpy(metadata_hash->raw, real_hash, hash_size);
107 else if (memcmp(metadata_hash->raw, real_hash, hash_size) != 0)
108 return CB_CBFS_HASH_MISMATCH;
109 }
110
111 return ret_walker;
112 }
113
cbfs_copy_fill_metadata(union cbfs_mdata * dst,const union cbfs_mdata * src,size_t already_read,cbfs_dev_t dev,size_t offset)114 enum cb_err cbfs_copy_fill_metadata(union cbfs_mdata *dst, const union cbfs_mdata *src,
115 size_t already_read, cbfs_dev_t dev, size_t offset)
116 {
117 /* First, copy the stuff that cbfs_walk() already read for us. */
118 memcpy(dst, src, already_read);
119
120 /* Then read in whatever metadata may be left (will only happen in non-hashing case). */
121 const size_t todo = be32toh(src->h.offset) - already_read;
122 assert(todo <= sizeof(*dst) - already_read);
123 if (todo && cbfs_dev_read(dev, dst->raw + already_read, offset + already_read,
124 todo) != todo)
125 return CB_CBFS_IO;
126 return CB_SUCCESS;
127 }
128
129 struct cbfs_lookup_args {
130 union cbfs_mdata *mdata_out;
131 const char *name;
132 size_t namesize;
133 size_t *data_offset_out;
134 };
135
lookup_walker(cbfs_dev_t dev,size_t offset,const union cbfs_mdata * mdata,size_t already_read,void * arg)136 static enum cb_err lookup_walker(cbfs_dev_t dev, size_t offset, const union cbfs_mdata *mdata,
137 size_t already_read, void *arg)
138 {
139 struct cbfs_lookup_args *args = arg;
140 /* Check if the name we're looking for could fit, then we can safely memcmp() it. */
141 if (args->namesize > already_read - offsetof(union cbfs_mdata, h.filename) ||
142 memcmp(args->name, mdata->h.filename, args->namesize) != 0)
143 return CB_CBFS_NOT_FOUND;
144
145 LOG("Found '%s' @%#zx size %#x\n", args->name, offset, be32toh(mdata->h.len));
146 if (cbfs_copy_fill_metadata(args->mdata_out, mdata, already_read, dev, offset))
147 return CB_CBFS_IO;
148
149 *args->data_offset_out = offset + be32toh(mdata->h.offset);
150 return CB_SUCCESS;
151 }
152
cbfs_lookup(cbfs_dev_t dev,const char * name,union cbfs_mdata * mdata_out,size_t * data_offset_out,struct vb2_hash * metadata_hash)153 enum cb_err cbfs_lookup(cbfs_dev_t dev, const char *name, union cbfs_mdata *mdata_out,
154 size_t *data_offset_out, struct vb2_hash *metadata_hash)
155 {
156 struct cbfs_lookup_args args = {
157 .mdata_out = mdata_out,
158 .name = name,
159 .namesize = strlen(name) + 1, /* Count trailing \0 so we can memcmp() it. */
160 .data_offset_out = data_offset_out,
161 };
162 return cbfs_walk(dev, lookup_walker, &args, metadata_hash, 0);
163 }
164
cbfs_find_attr(const union cbfs_mdata * mdata,uint32_t attr_tag,size_t size_check)165 const void *cbfs_find_attr(const union cbfs_mdata *mdata, uint32_t attr_tag, size_t size_check)
166 {
167 uint32_t offset = be32toh(mdata->h.attributes_offset);
168 uint32_t end = be32toh(mdata->h.offset);
169
170 if (!offset)
171 return NULL;
172
173 while (offset + sizeof(struct cbfs_file_attribute) <= end) {
174 const struct cbfs_file_attribute *attr = (const void *)mdata->raw + offset;
175 const uint32_t tag = be32toh(attr->tag);
176 const uint32_t len = be32toh(attr->len);
177
178 if (len < sizeof(struct cbfs_file_attribute) || len > end - offset) {
179 ERROR("Attribute %s[%x] invalid length: %u\n",
180 mdata->h.filename, tag, len);
181 return NULL;
182 }
183 if (tag == attr_tag) {
184 if (size_check && len != size_check) {
185 ERROR("Attribute %s[%x] size mismatch: %u != %zu\n",
186 mdata->h.filename, tag, len, size_check);
187 return NULL;
188 }
189 return attr;
190 }
191 offset += len;
192 }
193
194 return NULL;
195 }
196
cbfs_file_hash(const union cbfs_mdata * mdata)197 const struct vb2_hash *cbfs_file_hash(const union cbfs_mdata *mdata)
198 {
199 /* Hashes are variable-length attributes, so need to manually check the length. */
200 const struct cbfs_file_attr_hash *attr =
201 cbfs_find_attr(mdata, CBFS_FILE_ATTR_TAG_HASH, 0);
202 if (!attr)
203 return NULL; /* no hash */
204 const size_t asize = be32toh(attr->len);
205
206 const struct vb2_hash *hash = &attr->hash;
207 const size_t hsize = vb2_digest_size(hash->algo);
208 if (!hsize) {
209 ERROR("Hash algo %u for '%s' unsupported.\n", hash->algo, mdata->h.filename);
210 return NULL;
211 }
212 if (hsize != asize - offsetof(struct cbfs_file_attr_hash, hash.raw)) {
213 ERROR("Hash attribute size for '%s' (%zu) incorrect for algo %u.\n",
214 mdata->h.filename, asize, hash->algo);
215 return NULL;
216 }
217 return hash;
218 }
219