Line data    Source code

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