contrib/ldns/compat/b64_pton.c

   1 /*
   2  * Copyright (c) 1996, 1998 by Internet Software Consortium.
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
   9  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
  10  * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
  11  * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  12  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  13  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  14  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  15  * SOFTWARE.
  16  */
  17
  18 /*
  19  * Portions Copyright (c) 1995 by International Business Machines, Inc.
  20  *
  21  * International Business Machines, Inc. (hereinafter called IBM) grants
  22  * permission under its copyrights to use, copy, modify, and distribute this
  23  * Software with or without fee, provided that the above copyright notice and
  24  * all paragraphs of this notice appear in all copies, and that the name of IBM
  25  * not be used in connection with the marketing of any product incorporating
  26  * the Software or modifications thereof, without specific, written prior
  27  * permission.
  28  *
  29  * To the extent it has a right to do so, IBM grants an immunity from suit
  30  * under its patents, if any, for the use, sale or manufacture of products to
  31  * the extent that such products are used for performing Domain Name System
  32  * dynamic updates in TCP/IP networks by means of the Software.  No immunity is
  33  * granted for any product per se or for any other function of any product.
  34  *
  35  * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
  36  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  37  * PARTICULAR PURPOSE.  IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
  38  * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
  39  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
  40  * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
  41  */
  42 #include <ldns/config.h>
  43
  44 #include <ldns/ldns.h>
  45
  46 #include <sys/types.h>
  47 #include <sys/param.h>
  48 #ifdef HAVE_SYS_SOCKET_H
  49 #include <sys/socket.h>
  50 #endif
  51
  52 #ifdef HAVE_NETINET_IN_H
  53 #include <netinet/in.h>
  54 #endif
  55 #ifdef HAVE_ARPA_INET_H
  56 #include <arpa/inet.h>
  57 #endif
  58
  59 #include <ctype.h>
  60 #include <stdio.h>
  61 #include <stdlib.h>
  62 #include <string.h>
  63
  64 #define Assert(Cond) if (!(Cond)) abort()
  65
  66 static const char Base64[] =
  67         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  68 static const char Pad64 = '=';
  69
  70 /* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
  71    The following encoding technique is taken from RFC 1521 by Borenstein
  72    and Freed.  It is reproduced here in a slightly edited form for
  73    convenience.
  74
  75    A 65-character subset of US-ASCII is used, enabling 6 bits to be
  76    represented per printable character. (The extra 65th character, "=",
  77    is used to signify a special processing function.)
  78
  79    The encoding process represents 24-bit groups of input bits as output
  80    strings of 4 encoded characters. Proceeding from left to right, a
  81    24-bit input group is formed by concatenating 3 8-bit input groups.
  82    These 24 bits are then treated as 4 concatenated 6-bit groups, each
  83    of which is translated into a single digit in the base64 alphabet.
  84
  85    Each 6-bit group is used as an index into an array of 64 printable
  86    characters. The character referenced by the index is placed in the
  87    output string.
  88
  89                          Table 1: The Base64 Alphabet
  90
  91       Value Encoding  Value Encoding  Value Encoding  Value Encoding
  92           0 A            17 R            34 i            51 z
  93           1 B            18 S            35 j            52 0
  94           2 C            19 T            36 k            53 1
  95           3 D            20 U            37 l            54 2
  96           4 E            21 V            38 m            55 3
  97           5 F            22 W            39 n            56 4
  98           6 G            23 X            40 o            57 5
  99           7 H            24 Y            41 p            58 6
 100           8 I            25 Z            42 q            59 7
 101           9 J            26 a            43 r            60 8
 102          10 K            27 b            44 s            61 9
 103          11 L            28 c            45 t            62 +
 104          12 M            29 d            46 u            63 /
 105          13 N            30 e            47 v
 106          14 O            31 f            48 w         (pad) =
 107          15 P            32 g            49 x
 108          16 Q            33 h            50 y
 109
 110    Special processing is performed if fewer than 24 bits are available
 111    at the end of the data being encoded.  A full encoding quantum is
 112    always completed at the end of a quantity.  When fewer than 24 input
 113    bits are available in an input group, zero bits are added (on the
 114    right) to form an integral number of 6-bit groups.  Padding at the
 115    end of the data is performed using the '=' character.
 116
 117    Since all base64 input is an integral number of octets, only the
 118          -------------------------------------------------
 119    following cases can arise:
 120
 121        (1) the final quantum of encoding input is an integral
 122            multiple of 24 bits; here, the final unit of encoded
 123            output will be an integral multiple of 4 characters
 124            with no "=" padding,
 125        (2) the final quantum of encoding input is exactly 8 bits;
 126            here, the final unit of encoded output will be two
 127            characters followed by two "=" padding characters, or
 128        (3) the final quantum of encoding input is exactly 16 bits;
 129            here, the final unit of encoded output will be three
 130            characters followed by one "=" padding character.
 131    */
 132
 133 /* skips all whitespace anywhere.
 134    converts characters, four at a time, starting at (or after)
 135    src from base - 64 numbers into three 8 bit bytes in the target area.
 136    it returns the number of data bytes stored at the target, or -1 on error.
 137  */
 138
 139 int
 140 ldns_b64_pton(char const *src, uint8_t *target, size_t targsize)
 141 {
 142         int tarindex, state, ch;
 143         char *pos;
 144
 145         state = 0;
 146         tarindex = 0;
 147
 148         if (strlen(src) == 0) {
 149                 return 0;
 150         }
 151
 152         while ((ch = *src++) != '\0') {
 153                 if (isspace((unsigned char)ch))        /* Skip whitespace anywhere. */
 154                         continue;
 155
 156                 if (ch == Pad64)
 157                         break;
 158
 159                 pos = strchr(Base64, ch);
 160                 if (pos == 0) {
 161                         /* A non-base64 character. */
 162                         return (-1);
 163                 }
 164
 165                 switch (state) {
 166                 case 0:
 167                         if (target) {
 168                                 if ((size_t)tarindex >= targsize)
 169                                         return (-1);
 170                                 target[tarindex] = (pos - Base64) << 2;
 171                         }
 172                         state = 1;
 173                         break;
 174                 case 1:
 175                         if (target) {
 176                                 if ((size_t)tarindex + 1 >= targsize)
 177                                         return (-1);
 178                                 target[tarindex]   |=  (pos - Base64) >> 4;
 179                                 target[tarindex+1]  = ((pos - Base64) & 0x0f)
 180                                                         << 4 ;
 181                         }
 182                         tarindex++;
 183                         state = 2;
 184                         break;
 185                 case 2:
 186                         if (target) {
 187                                 if ((size_t)tarindex + 1 >= targsize)
 188                                         return (-1);
 189                                 target[tarindex]   |=  (pos - Base64) >> 2;
 190                                 target[tarindex+1]  = ((pos - Base64) & 0x03)
 191                                                         << 6;
 192                         }
 193                         tarindex++;
 194                         state = 3;
 195                         break;
 196                 case 3:
 197                         if (target) {
 198                                 if ((size_t)tarindex >= targsize)
 199                                         return (-1);
 200                                 target[tarindex] |= (pos - Base64);
 201                         }
 202                         tarindex++;
 203                         state = 0;
 204                         break;
 205                 default:
 206                         abort();
 207                 }
 208         }
 209
 210         /*
 211          * We are done decoding Base-64 chars.  Let's see if we ended
 212          * on a byte boundary, and/or with erroneous trailing characters.
 213          */
 214
 215         if (ch == Pad64) {              /* We got a pad char. */
 216                 ch = *src++;            /* Skip it, get next. */
 217                 switch (state) {
 218                 case 0:         /* Invalid = in first position */
 219                 case 1:         /* Invalid = in second position */
 220                         return (-1);
 221
 222                 case 2:         /* Valid, means one byte of info */
 223                         /* Skip any number of spaces. */
 224                         for ((void)NULL; ch != '\0'; ch = *src++)
 225                                 if (!isspace((unsigned char)ch))
 226                                         break;
 227                         /* Make sure there is another trailing = sign. */
 228                         if (ch != Pad64)
 229                                 return (-1);
 230                         ch = *src++;            /* Skip the = */
 231                         /* Fall through to "single trailing =" case. */
 232                         /* FALLTHROUGH */
 233
 234                 case 3:         /* Valid, means two bytes of info */
 235                         /*
 236                          * We know this char is an =.  Is there anything but
 237                          * whitespace after it?
 238                          */
 239                         for ((void)NULL; ch != '\0'; ch = *src++)
 240                                 if (!isspace((unsigned char)ch))
 241                                         return (-1);
 242
 243                         /*
 244                          * Now make sure for cases 2 and 3 that the "extra"
 245                          * bits that slopped past the last full byte were
 246                          * zeros.  If we don't check them, they become a
 247                          * subliminal channel.
 248                          */
 249                         if (target && target[tarindex] != 0)
 250                                 return (-1);
 251                 }
 252         } else {
 253                 /*
 254                  * We ended by seeing the end of the string.  Make sure we
 255                  * have no partial bytes lying around.
 256                  */
 257                 if (state != 0)
 258                         return (-1);
 259         }
 260
 261         return (tarindex);
 262 }