1 // SPDX-License-Identifier: MIT
2 /*
3  * Copyright (C) 2016 The Android Open Source Project
4  */
5 
6 #include "avb_util.h"
7 
8 #include <stdarg.h>
9 
avb_be32toh(uint32_t in)10 uint32_t avb_be32toh(uint32_t in) {
11   uint8_t* d = (uint8_t*)&in;
12   uint32_t ret;
13   ret = ((uint32_t)d[0]) << 24;
14   ret |= ((uint32_t)d[1]) << 16;
15   ret |= ((uint32_t)d[2]) << 8;
16   ret |= ((uint32_t)d[3]);
17   return ret;
18 }
19 
avb_be64toh(uint64_t in)20 uint64_t avb_be64toh(uint64_t in) {
21   uint8_t* d = (uint8_t*)&in;
22   uint64_t ret;
23   ret = ((uint64_t)d[0]) << 56;
24   ret |= ((uint64_t)d[1]) << 48;
25   ret |= ((uint64_t)d[2]) << 40;
26   ret |= ((uint64_t)d[3]) << 32;
27   ret |= ((uint64_t)d[4]) << 24;
28   ret |= ((uint64_t)d[5]) << 16;
29   ret |= ((uint64_t)d[6]) << 8;
30   ret |= ((uint64_t)d[7]);
31   return ret;
32 }
33 
34 /* Converts a 32-bit unsigned integer from host to big-endian byte order. */
avb_htobe32(uint32_t in)35 uint32_t avb_htobe32(uint32_t in) {
36   union {
37     uint32_t word;
38     uint8_t bytes[4];
39   } ret;
40   ret.bytes[0] = (in >> 24) & 0xff;
41   ret.bytes[1] = (in >> 16) & 0xff;
42   ret.bytes[2] = (in >> 8) & 0xff;
43   ret.bytes[3] = in & 0xff;
44   return ret.word;
45 }
46 
47 /* Converts a 64-bit unsigned integer from host to big-endian byte order. */
avb_htobe64(uint64_t in)48 uint64_t avb_htobe64(uint64_t in) {
49   union {
50     uint64_t word;
51     uint8_t bytes[8];
52   } ret;
53   ret.bytes[0] = (in >> 56) & 0xff;
54   ret.bytes[1] = (in >> 48) & 0xff;
55   ret.bytes[2] = (in >> 40) & 0xff;
56   ret.bytes[3] = (in >> 32) & 0xff;
57   ret.bytes[4] = (in >> 24) & 0xff;
58   ret.bytes[5] = (in >> 16) & 0xff;
59   ret.bytes[6] = (in >> 8) & 0xff;
60   ret.bytes[7] = in & 0xff;
61   return ret.word;
62 }
63 
avb_safe_memcmp(const void * s1,const void * s2,size_t n)64 int avb_safe_memcmp(const void* s1, const void* s2, size_t n) {
65   const unsigned char* us1 = s1;
66   const unsigned char* us2 = s2;
67   int result = 0;
68 
69   if (0 == n) {
70     return 0;
71   }
72 
73   /*
74    * Code snippet without data-dependent branch due to Nate Lawson
75    * (nate@root.org) of Root Labs.
76    */
77   while (n--) {
78     result |= *us1++ ^ *us2++;
79   }
80 
81   return result != 0;
82 }
83 
avb_safe_add_to(uint64_t * value,uint64_t value_to_add)84 bool avb_safe_add_to(uint64_t* value, uint64_t value_to_add) {
85   uint64_t original_value;
86 
87   avb_assert(value != NULL);
88 
89   original_value = *value;
90 
91   *value += value_to_add;
92   if (*value < original_value) {
93     avb_error("Overflow when adding values.\n");
94     return false;
95   }
96 
97   return true;
98 }
99 
avb_safe_add(uint64_t * out_result,uint64_t a,uint64_t b)100 bool avb_safe_add(uint64_t* out_result, uint64_t a, uint64_t b) {
101   uint64_t dummy;
102   if (out_result == NULL) {
103     out_result = &dummy;
104   }
105   *out_result = a;
106   return avb_safe_add_to(out_result, b);
107 }
108 
avb_validate_utf8(const uint8_t * data,size_t num_bytes)109 bool avb_validate_utf8(const uint8_t* data, size_t num_bytes) {
110   size_t n;
111   unsigned int num_cc;
112 
113   for (n = 0, num_cc = 0; n < num_bytes; n++) {
114     uint8_t c = data[n];
115 
116     if (num_cc > 0) {
117       if ((c & (0x80 | 0x40)) == 0x80) {
118         /* 10xx xxxx */
119       } else {
120         goto fail;
121       }
122       num_cc--;
123     } else {
124       if (c < 0x80) {
125         num_cc = 0;
126       } else if ((c & (0x80 | 0x40 | 0x20)) == (0x80 | 0x40)) {
127         /* 110x xxxx */
128         num_cc = 1;
129       } else if ((c & (0x80 | 0x40 | 0x20 | 0x10)) == (0x80 | 0x40 | 0x20)) {
130         /* 1110 xxxx */
131         num_cc = 2;
132       } else if ((c & (0x80 | 0x40 | 0x20 | 0x10 | 0x08)) ==
133                  (0x80 | 0x40 | 0x20 | 0x10)) {
134         /* 1111 0xxx */
135         num_cc = 3;
136       } else {
137         goto fail;
138       }
139     }
140   }
141 
142   if (num_cc != 0) {
143     goto fail;
144   }
145 
146   return true;
147 
148 fail:
149   return false;
150 }
151 
avb_str_concat(char * buf,size_t buf_size,const char * str1,size_t str1_len,const char * str2,size_t str2_len)152 bool avb_str_concat(char* buf,
153                     size_t buf_size,
154                     const char* str1,
155                     size_t str1_len,
156                     const char* str2,
157                     size_t str2_len) {
158   uint64_t combined_len;
159 
160   if (!avb_safe_add(&combined_len, str1_len, str2_len)) {
161     avb_error("Overflow when adding string sizes.\n");
162     return false;
163   }
164 
165   if (combined_len > buf_size - 1) {
166     avb_error("Insufficient buffer space.\n");
167     return false;
168   }
169 
170   avb_memcpy(buf, str1, str1_len);
171   avb_memcpy(buf + str1_len, str2, str2_len);
172   buf[combined_len] = '\0';
173 
174   return true;
175 }
176 
avb_malloc(size_t size)177 void* avb_malloc(size_t size) {
178   void* ret = avb_malloc_(size);
179   if (ret == NULL) {
180     avb_error("Failed to allocate memory.\n");
181     return NULL;
182   }
183   return ret;
184 }
185 
avb_calloc(size_t size)186 void* avb_calloc(size_t size) {
187   void* ret = avb_malloc(size);
188   if (ret == NULL) {
189     return NULL;
190   }
191 
192   avb_memset(ret, '\0', size);
193   return ret;
194 }
195 
avb_strdup(const char * str)196 char* avb_strdup(const char* str) {
197   size_t len = avb_strlen(str);
198   char* ret = avb_malloc(len + 1);
199   if (ret == NULL) {
200     return NULL;
201   }
202 
203   avb_memcpy(ret, str, len);
204   ret[len] = '\0';
205 
206   return ret;
207 }
208 
avb_strstr(const char * haystack,const char * needle)209 const char* avb_strstr(const char* haystack, const char* needle) {
210   size_t n, m;
211 
212   /* Look through |haystack| and check if the first character of
213    * |needle| matches. If so, check the rest of |needle|.
214    */
215   for (n = 0; haystack[n] != '\0'; n++) {
216     if (haystack[n] != needle[0]) {
217       continue;
218     }
219 
220     for (m = 1;; m++) {
221       if (needle[m] == '\0') {
222         return haystack + n;
223       }
224 
225       if (haystack[n + m] != needle[m]) {
226         break;
227       }
228     }
229   }
230 
231   return NULL;
232 }
233 
avb_strv_find_str(const char * const * strings,const char * str,size_t str_size)234 const char* avb_strv_find_str(const char* const* strings,
235                               const char* str,
236                               size_t str_size) {
237   size_t n;
238   for (n = 0; strings[n] != NULL; n++) {
239     if (avb_strlen(strings[n]) == str_size &&
240         avb_memcmp(strings[n], str, str_size) == 0) {
241       return strings[n];
242     }
243   }
244   return NULL;
245 }
246 
avb_replace(const char * str,const char * search,const char * replace)247 char* avb_replace(const char* str, const char* search, const char* replace) {
248   char* ret = NULL;
249   size_t ret_len = 0;
250   size_t search_len, replace_len;
251   const char* str_after_last_replace;
252 
253   search_len = avb_strlen(search);
254   replace_len = avb_strlen(replace);
255 
256   str_after_last_replace = str;
257   while (*str != '\0') {
258     const char* s;
259     size_t num_before;
260     size_t num_new;
261 
262     s = avb_strstr(str, search);
263     if (s == NULL) {
264       break;
265     }
266 
267     num_before = s - str;
268 
269     if (ret == NULL) {
270       num_new = num_before + replace_len + 1;
271       ret = avb_malloc(num_new);
272       if (ret == NULL) {
273         goto out;
274       }
275       avb_memcpy(ret, str, num_before);
276       avb_memcpy(ret + num_before, replace, replace_len);
277       ret[num_new - 1] = '\0';
278       ret_len = num_new - 1;
279     } else {
280       char* new_str;
281       num_new = ret_len + num_before + replace_len + 1;
282       new_str = avb_malloc(num_new);
283       if (new_str == NULL) {
284         goto out;
285       }
286       avb_memcpy(new_str, ret, ret_len);
287       avb_memcpy(new_str + ret_len, str, num_before);
288       avb_memcpy(new_str + ret_len + num_before, replace, replace_len);
289       new_str[num_new - 1] = '\0';
290       avb_free(ret);
291       ret = new_str;
292       ret_len = num_new - 1;
293     }
294 
295     str = s + search_len;
296     str_after_last_replace = str;
297   }
298 
299   if (ret == NULL) {
300     ret = avb_strdup(str_after_last_replace);
301     if (ret == NULL) {
302       goto out;
303     }
304   } else {
305     size_t num_remaining = avb_strlen(str_after_last_replace);
306     size_t num_new = ret_len + num_remaining + 1;
307     char* new_str = avb_malloc(num_new);
308     if (new_str == NULL) {
309       goto out;
310     }
311     avb_memcpy(new_str, ret, ret_len);
312     avb_memcpy(new_str + ret_len, str_after_last_replace, num_remaining);
313     new_str[num_new - 1] = '\0';
314     avb_free(ret);
315     ret = new_str;
316     ret_len = num_new - 1;
317   }
318 
319 out:
320   return ret;
321 }
322 
323 /* We only support a limited amount of strings in avb_strdupv(). */
324 #define AVB_STRDUPV_MAX_NUM_STRINGS 32
325 
avb_strdupv(const char * str,...)326 char* avb_strdupv(const char* str, ...) {
327   va_list ap;
328   const char* strings[AVB_STRDUPV_MAX_NUM_STRINGS];
329   size_t lengths[AVB_STRDUPV_MAX_NUM_STRINGS];
330   size_t num_strings, n;
331   uint64_t total_length;
332   char *ret = NULL, *dest;
333 
334   num_strings = 0;
335   total_length = 0;
336   va_start(ap, str);
337   do {
338     size_t str_len = avb_strlen(str);
339     strings[num_strings] = str;
340     lengths[num_strings] = str_len;
341     if (!avb_safe_add_to(&total_length, str_len)) {
342       avb_fatal("Overflow while determining total length.\n");
343       break;
344     }
345     num_strings++;
346     if (num_strings == AVB_STRDUPV_MAX_NUM_STRINGS) {
347       avb_fatal("Too many strings passed.\n");
348       break;
349     }
350     str = va_arg(ap, const char*);
351   } while (str != NULL);
352   va_end(ap);
353 
354   ret = avb_malloc(total_length + 1);
355   if (ret == NULL) {
356     goto out;
357   }
358 
359   dest = ret;
360   for (n = 0; n < num_strings; n++) {
361     avb_memcpy(dest, strings[n], lengths[n]);
362     dest += lengths[n];
363   }
364   *dest = '\0';
365   avb_assert(dest == ret + total_length);
366 
367 out:
368   return ret;
369 }
370 
avb_basename(const char * str)371 const char* avb_basename(const char* str) {
372   int64_t n;
373   size_t len;
374 
375   len = avb_strlen(str);
376   if (len >= 2) {
377     for (n = len - 2; n >= 0; n--) {
378       if (str[n] == '/') {
379         return str + n + 1;
380       }
381     }
382   }
383   return str;
384 }
385 
avb_uppercase(char * str)386 void avb_uppercase(char* str) {
387   size_t i;
388   for (i = 0; str[i] != '\0'; ++i) {
389     if (str[i] <= 0x7A && str[i] >= 0x61) {
390       str[i] -= 0x20;
391     }
392   }
393 }
394 
avb_bin2hex(const uint8_t * data,size_t data_len)395 char* avb_bin2hex(const uint8_t* data, size_t data_len) {
396   const char hex_digits[17] = "0123456789abcdef";
397   char* hex_data;
398   size_t n;
399 
400   hex_data = avb_malloc(data_len * 2 + 1);
401   if (hex_data == NULL) {
402     return NULL;
403   }
404 
405   for (n = 0; n < data_len; n++) {
406     hex_data[n * 2] = hex_digits[data[n] >> 4];
407     hex_data[n * 2 + 1] = hex_digits[data[n] & 0x0f];
408   }
409   hex_data[n * 2] = '\0';
410   return hex_data;
411 }
412