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