StdLib/BsdSocketLib/base64.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
  43 /*
  44  * Portions copyright (c) 1999, 2000
  45  * Intel Corporation.
  46  * All rights reserved.
  47  *
  48  * Redistribution and use in source and binary forms, with or without
  49  * modification, are permitted provided that the following conditions
  50  * are met:
  51  *
  52  * 1. Redistributions of source code must retain the above copyright
  53  *    notice, this list of conditions and the following disclaimer.
  54  *
  55  * 2. Redistributions in binary form must reproduce the above copyright
  56  *    notice, this list of conditions and the following disclaimer in the
  57  *    documentation and/or other materials provided with the distribution.
  58  *
  59  * 3. All advertising materials mentioning features or use of this software
  60  *    must display the following acknowledgement:
  61  *
  62  *    This product includes software developed by Intel Corporation and
  63  *    its contributors.
  64  *
  65  * 4. Neither the name of Intel Corporation or its contributors may be
  66  *    used to endorse or promote products derived from this software
  67  *    without specific prior written permission.
  68  *
  69  * THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION AND CONTRIBUTORS ``AS IS''
  70  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  71  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  72  * ARE DISCLAIMED.  IN NO EVENT SHALL INTEL CORPORATION OR CONTRIBUTORS BE
  73  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  74  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  75  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  76  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  77  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  78  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  79  * THE POSSIBILITY OF SUCH DAMAGE.
  80  *
  81  */
  82
  83 #if !defined(LINT) && !defined(CODECENTER)
  84 static char rcsid[] = "$Id: base64.c,v 1.1.1.1 2003/11/19 01:51:25 kyu3 Exp $";
  85 #endif /* not lint */
  86
  87 #include <sys/types.h>
  88 #include <sys/param.h>
  89 #include <sys/socket.h>
  90
  91 #include <netinet/in.h>
  92 #include <arpa/inet.h>
  93 #include <arpa/nameser.h>
  94
  95 #include <ctype.h>
  96 #include <resolv.h>
  97 #include <stdio.h>
  98 #include <stdlib.h>
  99 #include <string.h>
 100
 101 #define Assert(Cond) if (!(Cond)) abort()
 102
 103 static const char Base64[] =
 104         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 105 static const char Pad64 = '=';
 106
 107 /* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
 108    The following encoding technique is taken from RFC 1521 by Borenstein
 109    and Freed.  It is reproduced here in a slightly edited form for
 110    convenience.
 111
 112    A 65-character subset of US-ASCII is used, enabling 6 bits to be
 113    represented per printable character. (The extra 65th character, "=",
 114    is used to signify a special processing function.)
 115
 116    The encoding process represents 24-bit groups of input bits as output
 117    strings of 4 encoded characters. Proceeding from left to right, a
 118    24-bit input group is formed by concatenating 3 8-bit input groups.
 119    These 24 bits are then treated as 4 concatenated 6-bit groups, each
 120    of which is translated into a single digit in the base64 alphabet.
 121
 122    Each 6-bit group is used as an index into an array of 64 printable
 123    characters. The character referenced by the index is placed in the
 124    output string.
 125
 126                          Table 1: The Base64 Alphabet
 127
 128       Value Encoding  Value Encoding  Value Encoding  Value Encoding
 129           0 A            17 R            34 i            51 z
 130           1 B            18 S            35 j            52 0
 131           2 C            19 T            36 k            53 1
 132           3 D            20 U            37 l            54 2
 133           4 E            21 V            38 m            55 3
 134           5 F            22 W            39 n            56 4
 135           6 G            23 X            40 o            57 5
 136           7 H            24 Y            41 p            58 6
 137           8 I            25 Z            42 q            59 7
 138           9 J            26 a            43 r            60 8
 139          10 K            27 b            44 s            61 9
 140          11 L            28 c            45 t            62 +
 141          12 M            29 d            46 u            63 /
 142          13 N            30 e            47 v
 143          14 O            31 f            48 w         (pad) =
 144          15 P            32 g            49 x
 145          16 Q            33 h            50 y
 146
 147    Special processing is performed if fewer than 24 bits are available
 148    at the end of the data being encoded.  A full encoding quantum is
 149    always completed at the end of a quantity.  When fewer than 24 input
 150    bits are available in an input group, zero bits are added (on the
 151    right) to form an integral number of 6-bit groups.  Padding at the
 152    end of the data is performed using the '=' character.
 153
 154    Since all base64 input is an integral number of octets, only the
 155          -------------------------------------------------
 156    following cases can arise:
 157
 158        (1) the final quantum of encoding input is an integral
 159            multiple of 24 bits; here, the final unit of encoded
 160            output will be an integral multiple of 4 characters
 161            with no "=" padding,
 162        (2) the final quantum of encoding input is exactly 8 bits;
 163            here, the final unit of encoded output will be two
 164            characters followed by two "=" padding characters, or
 165        (3) the final quantum of encoding input is exactly 16 bits;
 166            here, the final unit of encoded output will be three
 167            characters followed by one "=" padding character.
 168    */
 169
 170 int
 171 b64_ntop(u_char const *src, size_t srclength, char *target, size_t targsize) {
 172         size_t datalength = 0;
 173         u_char input[3];
 174         u_char output[4];
 175         size_t i;
 176
 177         while (2 < srclength) {
 178                 input[0] = *src++;
 179                 input[1] = *src++;
 180                 input[2] = *src++;
 181                 srclength -= 3;
 182
 183                 output[0] = input[0] >> 2;
 184                 output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
 185                 output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
 186                 output[3] = input[2] & 0x3f;
 187                 Assert(output[0] < 64);
 188                 Assert(output[1] < 64);
 189                 Assert(output[2] < 64);
 190                 Assert(output[3] < 64);
 191
 192                 if (datalength + 4 > targsize)
 193                         return (-1);
 194                 target[datalength++] = Base64[output[0]];
 195                 target[datalength++] = Base64[output[1]];
 196                 target[datalength++] = Base64[output[2]];
 197                 target[datalength++] = Base64[output[3]];
 198         }
 199
 200         /* Now we worry about padding. */
 201         if (0 != srclength) {
 202                 /* Get what's left. */
 203                 input[0] = input[1] = input[2] = '\0';
 204                 for (i = 0; i < srclength; i++)
 205                         input[i] = *src++;
 206
 207                 output[0] = input[0] >> 2;
 208                 output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
 209                 output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
 210                 Assert(output[0] < 64);
 211                 Assert(output[1] < 64);
 212                 Assert(output[2] < 64);
 213
 214                 if (datalength + 4 > targsize)
 215                         return (-1);
 216                 target[datalength++] = Base64[output[0]];
 217                 target[datalength++] = Base64[output[1]];
 218                 if (srclength == 1)
 219                         target[datalength++] = Pad64;
 220                 else
 221                         target[datalength++] = Base64[output[2]];
 222                 target[datalength++] = Pad64;
 223         }
 224         if (datalength >= targsize)
 225                 return (-1);
 226         target[datalength] = '\0';      /* Returned value doesn't count \0. */
 227         return ((int)datalength);
 228 }
 229
 230 /* skips all whitespace anywhere.
 231    converts characters, four at a time, starting at (or after)
 232    src from base - 64 numbers into three 8 bit bytes in the target area.
 233    it returns the number of data bytes stored at the target, or -1 on error.
 234  */
 235
 236 int
 237 b64_pton(
 238         char const *src,
 239         u_char *target,
 240         size_t targsize
 241         )
 242 {
 243         int tarindex, state, ch;
 244         char *pos;
 245
 246         state = 0;
 247         tarindex = 0;
 248
 249         while ((ch = *src++) != '\0') {
 250                 if (isspace(ch))        /* Skip whitespace anywhere. */
 251                         continue;
 252
 253                 if (ch == Pad64)
 254                         break;
 255
 256                 pos = strchr(Base64, ch);
 257                 if (pos == 0)           /* A non-base64 character. */
 258                         return (-1);
 259
 260                 switch (state) {
 261                 case 0:
 262                         if (target) {
 263                                 if ((size_t)tarindex >= targsize)
 264                                         return (-1);
 265                                 target[tarindex] = (u_char)((pos - Base64) << 2);
 266                         }
 267                         state = 1;
 268                         break;
 269                 case 1:
 270                         if (target) {
 271                                 if ((size_t)tarindex + 1 >= targsize)
 272                                         return (-1);
 273                                 target[tarindex]   |= (u_char)((pos - Base64) >> 4);
 274                                 target[tarindex+1]  = (u_char)(((pos - Base64) & 0x0f)
 275                                                         << 4) ;
 276                         }
 277                         tarindex++;
 278                         state = 2;
 279                         break;
 280                 case 2:
 281                         if (target) {
 282                                 if ((size_t)tarindex + 1 >= targsize)
 283                                         return (-1);
 284                                 target[tarindex]   |= (u_char)((pos - Base64) >> 2);
 285                                 target[tarindex+1]  = (u_char)(((pos - Base64) & 0x03)
 286                                                         << 6);
 287                         }
 288                         tarindex++;
 289                         state = 3;
 290                         break;
 291                 case 3:
 292                         if (target) {
 293                                 if ((size_t)tarindex >= targsize)
 294                                         return (-1);
 295                                 target[tarindex] |= (u_char)(pos - Base64);
 296                         }
 297                         tarindex++;
 298                         state = 0;
 299                         break;
 300                 default:
 301                         abort();
 302                 }
 303         }
 304
 305         /*
 306          * We are done decoding Base-64 chars.  Let's see if we ended
 307          * on a byte boundary, and/or with erroneous trailing characters.
 308          */
 309
 310         if (ch == Pad64) {              /* We got a pad char. */
 311                 ch = *src++;            /* Skip it, get next. */
 312                 switch (state) {
 313                 case 0:         /* Invalid = in first position */
 314                 case 1:         /* Invalid = in second position */
 315                         return (-1);
 316
 317                 case 2:         /* Valid, means one byte of info */
 318                         /* Skip any number of spaces. */
 319                         for ((void)NULL; ch != '\0'; ch = *src++)
 320                                 if (!isspace(ch))
 321                                         break;
 322                         /* Make sure there is another trailing = sign. */
 323                         if (ch != Pad64)
 324                                 return (-1);
 325                         ch = *src++;            /* Skip the = */
 326                         /* Fall through to "single trailing =" case. */
 327                         /* FALLTHROUGH */
 328
 329                 case 3:         /* Valid, means two bytes of info */
 330                         /*
 331                          * We know this char is an =.  Is there anything but
 332                          * whitespace after it?
 333                          */
 334                         for ((void)NULL; ch != '\0'; ch = *src++)
 335                                 if (!isspace(ch))
 336                                         return (-1);
 337
 338                         /*
 339                          * Now make sure for cases 2 and 3 that the "extra"
 340                          * bits that slopped past the last full byte were
 341                          * zeros.  If we don't check them, they become a
 342                          * subliminal channel.
 343                          */
 344                         if (target && target[tarindex] != 0)
 345                                 return (-1);
 346                 }
 347         } else {
 348                 /*
 349                  * We ended by seeing the end of the string.  Make sure we
 350                  * have no partial bytes lying around.
 351                  */
 352                 if (state != 0)
 353                         return (-1);
 354         }
 355
 356         return (tarindex);
 357 }