src/test/test-hexdecoct.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include "alloc-util.h"
  22 #include "hexdecoct.h"
  23 #include "macro.h"
  24 #include "string-util.h"
  25
  26 static void test_hexchar(void) {
  27         assert_se(hexchar(0xa) == 'a');
  28         assert_se(hexchar(0x0) == '0');
  29 }
  30
  31 static void test_unhexchar(void) {
  32         assert_se(unhexchar('a') == 0xA);
  33         assert_se(unhexchar('A') == 0xA);
  34         assert_se(unhexchar('0') == 0x0);
  35 }
  36
  37 static void test_base32hexchar(void) {
  38         assert_se(base32hexchar(0) == '0');
  39         assert_se(base32hexchar(9) == '9');
  40         assert_se(base32hexchar(10) == 'A');
  41         assert_se(base32hexchar(31) == 'V');
  42 }
  43
  44 static void test_unbase32hexchar(void) {
  45         assert_se(unbase32hexchar('0') == 0);
  46         assert_se(unbase32hexchar('9') == 9);
  47         assert_se(unbase32hexchar('A') == 10);
  48         assert_se(unbase32hexchar('V') == 31);
  49         assert_se(unbase32hexchar('=') == -EINVAL);
  50 }
  51
  52 static void test_base64char(void) {
  53         assert_se(base64char(0) == 'A');
  54         assert_se(base64char(26) == 'a');
  55         assert_se(base64char(63) == '/');
  56 }
  57
  58 static void test_unbase64char(void) {
  59         assert_se(unbase64char('A') == 0);
  60         assert_se(unbase64char('Z') == 25);
  61         assert_se(unbase64char('a') == 26);
  62         assert_se(unbase64char('z') == 51);
  63         assert_se(unbase64char('0') == 52);
  64         assert_se(unbase64char('9') == 61);
  65         assert_se(unbase64char('+') == 62);
  66         assert_se(unbase64char('/') == 63);
  67         assert_se(unbase64char('=') == -EINVAL);
  68 }
  69
  70 static void test_octchar(void) {
  71         assert_se(octchar(00) == '0');
  72         assert_se(octchar(07) == '7');
  73 }
  74
  75 static void test_unoctchar(void) {
  76         assert_se(unoctchar('0') == 00);
  77         assert_se(unoctchar('7') == 07);
  78 }
  79
  80 static void test_decchar(void) {
  81         assert_se(decchar(0) == '0');
  82         assert_se(decchar(9) == '9');
  83 }
  84
  85 static void test_undecchar(void) {
  86         assert_se(undecchar('0') == 0);
  87         assert_se(undecchar('9') == 9);
  88 }
  89
  90 static void test_unhexmem(void) {
  91         const char *hex = "efa2149213";
  92         const char *hex_invalid = "efa214921o";
  93         _cleanup_free_ char *hex2 = NULL;
  94         _cleanup_free_ void *mem = NULL;
  95         size_t len;
  96
  97         assert_se(unhexmem(hex_invalid, strlen(hex_invalid), &mem, &len) == -EINVAL);
  98         assert_se(unhexmem(hex, strlen(hex) + 1, &mem, &len) == -EINVAL);
  99         assert_se(unhexmem(hex, strlen(hex) - 1, &mem, &len) == -EINVAL);
 100         assert_se(unhexmem(hex, strlen(hex), &mem, &len) == 0);
 101
 102         assert_se((hex2 = hexmem(mem, len)));
 103         assert_se(streq(hex, hex2));
 104 }
 105
 106 /* https://tools.ietf.org/html/rfc4648#section-10 */
 107 static void test_base32hexmem(void) {
 108         char *b32;
 109
 110         b32 = base32hexmem("", STRLEN(""), true);
 111         assert_se(b32);
 112         assert_se(streq(b32, ""));
 113         free(b32);
 114
 115         b32 = base32hexmem("f", STRLEN("f"), true);
 116         assert_se(b32);
 117         assert_se(streq(b32, "CO======"));
 118         free(b32);
 119
 120         b32 = base32hexmem("fo", STRLEN("fo"), true);
 121         assert_se(b32);
 122         assert_se(streq(b32, "CPNG===="));
 123         free(b32);
 124
 125         b32 = base32hexmem("foo", STRLEN("foo"), true);
 126         assert_se(b32);
 127         assert_se(streq(b32, "CPNMU==="));
 128         free(b32);
 129
 130         b32 = base32hexmem("foob", STRLEN("foob"), true);
 131         assert_se(b32);
 132         assert_se(streq(b32, "CPNMUOG="));
 133         free(b32);
 134
 135         b32 = base32hexmem("fooba", STRLEN("fooba"), true);
 136         assert_se(b32);
 137         assert_se(streq(b32, "CPNMUOJ1"));
 138         free(b32);
 139
 140         b32 = base32hexmem("foobar", STRLEN("foobar"), true);
 141         assert_se(b32);
 142         assert_se(streq(b32, "CPNMUOJ1E8======"));
 143         free(b32);
 144
 145         b32 = base32hexmem("", STRLEN(""), false);
 146         assert_se(b32);
 147         assert_se(streq(b32, ""));
 148         free(b32);
 149
 150         b32 = base32hexmem("f", STRLEN("f"), false);
 151         assert_se(b32);
 152         assert_se(streq(b32, "CO"));
 153         free(b32);
 154
 155         b32 = base32hexmem("fo", STRLEN("fo"), false);
 156         assert_se(b32);
 157         assert_se(streq(b32, "CPNG"));
 158         free(b32);
 159
 160         b32 = base32hexmem("foo", STRLEN("foo"), false);
 161         assert_se(b32);
 162         assert_se(streq(b32, "CPNMU"));
 163         free(b32);
 164
 165         b32 = base32hexmem("foob", STRLEN("foob"), false);
 166         assert_se(b32);
 167         assert_se(streq(b32, "CPNMUOG"));
 168         free(b32);
 169
 170         b32 = base32hexmem("fooba", STRLEN("fooba"), false);
 171         assert_se(b32);
 172         assert_se(streq(b32, "CPNMUOJ1"));
 173         free(b32);
 174
 175         b32 = base32hexmem("foobar", STRLEN("foobar"), false);
 176         assert_se(b32);
 177         assert_se(streq(b32, "CPNMUOJ1E8"));
 178         free(b32);
 179 }
 180
 181 static void test_unbase32hexmem(void) {
 182         void *mem;
 183         size_t len;
 184
 185         assert_se(unbase32hexmem("", STRLEN(""), true, &mem, &len) == 0);
 186         assert_se(streq(strndupa(mem, len), ""));
 187         free(mem);
 188
 189         assert_se(unbase32hexmem("CO======", STRLEN("CO======"), true, &mem, &len) == 0);
 190         assert_se(streq(strndupa(mem, len), "f"));
 191         free(mem);
 192
 193         assert_se(unbase32hexmem("CPNG====", STRLEN("CPNG===="), true, &mem, &len) == 0);
 194         assert_se(streq(strndupa(mem, len), "fo"));
 195         free(mem);
 196
 197         assert_se(unbase32hexmem("CPNMU===", STRLEN("CPNMU==="), true, &mem, &len) == 0);
 198         assert_se(streq(strndupa(mem, len), "foo"));
 199         free(mem);
 200
 201         assert_se(unbase32hexmem("CPNMUOG=", STRLEN("CPNMUOG="), true, &mem, &len) == 0);
 202         assert_se(streq(strndupa(mem, len), "foob"));
 203         free(mem);
 204
 205         assert_se(unbase32hexmem("CPNMUOJ1", STRLEN("CPNMUOJ1"), true, &mem, &len) == 0);
 206         assert_se(streq(strndupa(mem, len), "fooba"));
 207         free(mem);
 208
 209         assert_se(unbase32hexmem("CPNMUOJ1E8======", STRLEN("CPNMUOJ1E8======"), true, &mem, &len) == 0);
 210         assert_se(streq(strndupa(mem, len), "foobar"));
 211         free(mem);
 212
 213         assert_se(unbase32hexmem("A", STRLEN("A"), true, &mem, &len) == -EINVAL);
 214         assert_se(unbase32hexmem("A=======", STRLEN("A======="), true, &mem, &len) == -EINVAL);
 215         assert_se(unbase32hexmem("AAA=====", STRLEN("AAA====="), true, &mem, &len) == -EINVAL);
 216         assert_se(unbase32hexmem("AAAAAA==", STRLEN("AAAAAA=="), true, &mem, &len) == -EINVAL);
 217         assert_se(unbase32hexmem("AB======", STRLEN("AB======"), true, &mem, &len) == -EINVAL);
 218         assert_se(unbase32hexmem("AAAB====", STRLEN("AAAB===="), true, &mem, &len) == -EINVAL);
 219         assert_se(unbase32hexmem("AAAAB===", STRLEN("AAAAB==="), true, &mem, &len) == -EINVAL);
 220         assert_se(unbase32hexmem("AAAAAAB=", STRLEN("AAAAAAB="), true, &mem, &len) == -EINVAL);
 221
 222         assert_se(unbase32hexmem("XPNMUOJ1", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
 223         assert_se(unbase32hexmem("CXNMUOJ1", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
 224         assert_se(unbase32hexmem("CPXMUOJ1", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
 225         assert_se(unbase32hexmem("CPNXUOJ1", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
 226         assert_se(unbase32hexmem("CPNMXOJ1", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
 227         assert_se(unbase32hexmem("CPNMUXJ1", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
 228         assert_se(unbase32hexmem("CPNMUOX1", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
 229         assert_se(unbase32hexmem("CPNMUOJX", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
 230
 231         assert_se(unbase32hexmem("", STRLEN(""), false, &mem, &len) == 0);
 232         assert_se(streq(strndupa(mem, len), ""));
 233         free(mem);
 234
 235         assert_se(unbase32hexmem("CO", STRLEN("CO"), false, &mem, &len) == 0);
 236         assert_se(streq(strndupa(mem, len), "f"));
 237         free(mem);
 238
 239         assert_se(unbase32hexmem("CPNG", STRLEN("CPNG"), false, &mem, &len) == 0);
 240         assert_se(streq(strndupa(mem, len), "fo"));
 241         free(mem);
 242
 243         assert_se(unbase32hexmem("CPNMU", STRLEN("CPNMU"), false, &mem, &len) == 0);
 244         assert_se(streq(strndupa(mem, len), "foo"));
 245         free(mem);
 246
 247         assert_se(unbase32hexmem("CPNMUOG", STRLEN("CPNMUOG"), false, &mem, &len) == 0);
 248         assert_se(streq(strndupa(mem, len), "foob"));
 249         free(mem);
 250
 251         assert_se(unbase32hexmem("CPNMUOJ1", STRLEN("CPNMUOJ1"), false, &mem, &len) == 0);
 252         assert_se(streq(strndupa(mem, len), "fooba"));
 253         free(mem);
 254
 255         assert_se(unbase32hexmem("CPNMUOJ1E8", STRLEN("CPNMUOJ1E8"), false, &mem, &len) == 0);
 256         assert_se(streq(strndupa(mem, len), "foobar"));
 257         free(mem);
 258
 259         assert_se(unbase32hexmem("CPNMUOG=", STRLEN("CPNMUOG="), false, &mem, &len) == -EINVAL);
 260         assert_se(unbase32hexmem("CPNMUOJ1E8======", STRLEN("CPNMUOJ1E8======"), false, &mem, &len) == -EINVAL);
 261         assert_se(unbase32hexmem("A", STRLEN("A"), false, &mem, &len) == -EINVAL);
 262         assert_se(unbase32hexmem("A", STRLEN("A"), false, &mem, &len) == -EINVAL);
 263         assert_se(unbase32hexmem("AAA", STRLEN("AAA"), false, &mem, &len) == -EINVAL);
 264         assert_se(unbase32hexmem("AAAAAA", STRLEN("AAAAAA"), false, &mem, &len) == -EINVAL);
 265         assert_se(unbase32hexmem("AB", STRLEN("AB"), false, &mem, &len) == -EINVAL);
 266         assert_se(unbase32hexmem("AAAB", STRLEN("AAAB"), false, &mem, &len) == -EINVAL);
 267         assert_se(unbase32hexmem("AAAAB", STRLEN("AAAAB"), false, &mem, &len) == -EINVAL);
 268         assert_se(unbase32hexmem("AAAAAAB", STRLEN("AAAAAAB"), false, &mem, &len) == -EINVAL);
 269 }
 270
 271 /* https://tools.ietf.org/html/rfc4648#section-10 */
 272 static void test_base64mem(void) {
 273         char *b64;
 274
 275         assert_se(base64mem("", STRLEN(""), &b64) == 0);
 276         assert_se(streq(b64, ""));
 277         free(b64);
 278
 279         assert_se(base64mem("f", STRLEN("f"), &b64) == 4);
 280         assert_se(streq(b64, "Zg=="));
 281         free(b64);
 282
 283         assert_se(base64mem("fo", STRLEN("fo"), &b64) == 4);
 284         assert_se(streq(b64, "Zm8="));
 285         free(b64);
 286
 287         assert_se(base64mem("foo", STRLEN("foo"), &b64) == 4);
 288         assert_se(streq(b64, "Zm9v"));
 289         free(b64);
 290
 291         assert_se(base64mem("foob", STRLEN("foob"), &b64) == 8);
 292         assert_se(streq(b64, "Zm9vYg=="));
 293         free(b64);
 294
 295         assert_se(base64mem("fooba", STRLEN("fooba"), &b64) == 8);
 296         assert_se(streq(b64, "Zm9vYmE="));
 297         free(b64);
 298
 299         assert_se(base64mem("foobar", STRLEN("foobar"), &b64) == 8);
 300         assert_se(streq(b64, "Zm9vYmFy"));
 301         free(b64);
 302 }
 303
 304 static void test_unbase64mem_one(const char *input, const char *output, int ret) {
 305         _cleanup_free_ void *buffer = NULL;
 306         size_t size = 0;
 307
 308         assert_se(unbase64mem(input, (size_t) -1, &buffer, &size) == ret);
 309
 310         if (ret >= 0) {
 311                 assert_se(size == strlen(output));
 312                 assert_se(memcmp(buffer, output, size) == 0);
 313                 assert_se(((char*) buffer)[size] == 0);
 314         }
 315 }
 316
 317 static void test_unbase64mem(void) {
 318
 319         test_unbase64mem_one("", "", 0);
 320         test_unbase64mem_one("Zg==", "f", 0);
 321         test_unbase64mem_one("Zm8=", "fo", 0);
 322         test_unbase64mem_one("Zm9v", "foo", 0);
 323         test_unbase64mem_one("Zm9vYg==", "foob", 0);
 324         test_unbase64mem_one("Zm9vYmE=", "fooba", 0);
 325         test_unbase64mem_one("Zm9vYmFy", "foobar", 0);
 326
 327         test_unbase64mem_one(" ", "", 0);
 328         test_unbase64mem_one(" \n\r ", "", 0);
 329         test_unbase64mem_one("    Zg\n==       ", "f", 0);
 330         test_unbase64mem_one(" Zm 8=\r", "fo", 0);
 331         test_unbase64mem_one("  Zm9\n\r\r\nv   ", "foo", 0);
 332         test_unbase64mem_one(" Z m9vYg==\n\r", "foob", 0);
 333         test_unbase64mem_one(" Zm 9vYmE=   ", "fooba", 0);
 334         test_unbase64mem_one("   Z m9v    YmFy   ", "foobar", 0);
 335
 336         test_unbase64mem_one("A", NULL, -EPIPE);
 337         test_unbase64mem_one("A====", NULL, -EINVAL);
 338         test_unbase64mem_one("AAB==", NULL, -EINVAL);
 339         test_unbase64mem_one(" A A A B = ", NULL, -EINVAL);
 340         test_unbase64mem_one(" Z m 8 = q u u x ", NULL, -ENAMETOOLONG);
 341 }
 342
 343 static void test_hexdump(void) {
 344         uint8_t data[146];
 345         unsigned i;
 346
 347         hexdump(stdout, NULL, 0);
 348         hexdump(stdout, "", 0);
 349         hexdump(stdout, "", 1);
 350         hexdump(stdout, "x", 1);
 351         hexdump(stdout, "x", 2);
 352         hexdump(stdout, "foobar", 7);
 353         hexdump(stdout, "f\nobar", 7);
 354         hexdump(stdout, "xxxxxxxxxxxxxxxxxxxxyz", 23);
 355
 356         for (i = 0; i < ELEMENTSOF(data); i++)
 357                 data[i] = i*2;
 358
 359         hexdump(stdout, data, sizeof(data));
 360 }
 361
 362 int main(int argc, char *argv[]) {
 363         test_hexchar();
 364         test_unhexchar();
 365         test_base32hexchar();
 366         test_unbase32hexchar();
 367         test_base64char();
 368         test_unbase64char();
 369         test_octchar();
 370         test_unoctchar();
 371         test_decchar();
 372         test_undecchar();
 373         test_unhexmem();
 374         test_base32hexmem();
 375         test_unbase32hexmem();
 376         test_base64mem();
 377         test_unbase64mem();
 378         test_hexdump();
 379
 380         return 0;
 381 }