Home | History | Annotate | Download | only in openssl
      1 /* Copyright (C) 1995-1998 Eric Young (eay (at) cryptsoft.com)
      2  * All rights reserved.
      3  *
      4  * This package is an SSL implementation written
      5  * by Eric Young (eay (at) cryptsoft.com).
      6  * The implementation was written so as to conform with Netscapes SSL.
      7  *
      8  * This library is free for commercial and non-commercial use as long as
      9  * the following conditions are aheared to.  The following conditions
     10  * apply to all code found in this distribution, be it the RC4, RSA,
     11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
     12  * included with this distribution is covered by the same copyright terms
     13  * except that the holder is Tim Hudson (tjh (at) cryptsoft.com).
     14  *
     15  * Copyright remains Eric Young's, and as such any Copyright notices in
     16  * the code are not to be removed.
     17  * If this package is used in a product, Eric Young should be given attribution
     18  * as the author of the parts of the library used.
     19  * This can be in the form of a textual message at program startup or
     20  * in documentation (online or textual) provided with the package.
     21  *
     22  * Redistribution and use in source and binary forms, with or without
     23  * modification, are permitted provided that the following conditions
     24  * are met:
     25  * 1. Redistributions of source code must retain the copyright
     26  *    notice, this list of conditions and the following disclaimer.
     27  * 2. Redistributions in binary form must reproduce the above copyright
     28  *    notice, this list of conditions and the following disclaimer in the
     29  *    documentation and/or other materials provided with the distribution.
     30  * 3. All advertising materials mentioning features or use of this software
     31  *    must display the following acknowledgement:
     32  *    "This product includes cryptographic software written by
     33  *     Eric Young (eay (at) cryptsoft.com)"
     34  *    The word 'cryptographic' can be left out if the rouines from the library
     35  *    being used are not cryptographic related :-).
     36  * 4. If you include any Windows specific code (or a derivative thereof) from
     37  *    the apps directory (application code) you must include an acknowledgement:
     38  *    "This product includes software written by Tim Hudson (tjh (at) cryptsoft.com)"
     39  *
     40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
     41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     50  * SUCH DAMAGE.
     51  *
     52  * The licence and distribution terms for any publically available version or
     53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
     54  * copied and put under another distribution licence
     55  * [including the GNU Public Licence.] */
     56 
     57 #ifndef OPENSSL_HEADER_BASE64_H
     58 #define OPENSSL_HEADER_BASE64_H
     59 
     60 #include <openssl/base.h>
     61 
     62 #if defined(__cplusplus)
     63 extern "C" {
     64 #endif
     65 
     66 
     67 // base64 functions.
     68 //
     69 // For historical reasons, these functions have the EVP_ prefix but just do
     70 // base64 encoding and decoding.
     71 
     72 
     73 // Encoding
     74 
     75 // EVP_EncodeBlock encodes |src_len| bytes from |src| and writes the
     76 // result to |dst| with a trailing NUL. It returns the number of bytes
     77 // written, not including this trailing NUL.
     78 OPENSSL_EXPORT size_t EVP_EncodeBlock(uint8_t *dst, const uint8_t *src,
     79                                       size_t src_len);
     80 
     81 // EVP_EncodedLength sets |*out_len| to the number of bytes that will be needed
     82 // to call |EVP_EncodeBlock| on an input of length |len|. This includes the
     83 // final NUL that |EVP_EncodeBlock| writes. It returns one on success or zero
     84 // on error.
     85 OPENSSL_EXPORT int EVP_EncodedLength(size_t *out_len, size_t len);
     86 
     87 
     88 // Decoding
     89 
     90 // EVP_DecodedLength sets |*out_len| to the maximum number of bytes that will
     91 // be needed to call |EVP_DecodeBase64| on an input of length |len|. It returns
     92 // one on success or zero if |len| is not a valid length for a base64-encoded
     93 // string.
     94 OPENSSL_EXPORT int EVP_DecodedLength(size_t *out_len, size_t len);
     95 
     96 // EVP_DecodeBase64 decodes |in_len| bytes from base64 and writes
     97 // |*out_len| bytes to |out|. |max_out| is the size of the output
     98 // buffer. If it is not enough for the maximum output size, the
     99 // operation fails. It returns one on success or zero on error.
    100 OPENSSL_EXPORT int EVP_DecodeBase64(uint8_t *out, size_t *out_len,
    101                                     size_t max_out, const uint8_t *in,
    102                                     size_t in_len);
    103 
    104 
    105 // Deprecated functions.
    106 //
    107 // OpenSSL provides a streaming base64 implementation, however its behavior is
    108 // very specific to PEM. It is also very lenient of invalid input. Use of any of
    109 // these functions is thus deprecated.
    110 
    111 // EVP_EncodeInit initialises |*ctx|, which is typically stack
    112 // allocated, for an encoding operation.
    113 //
    114 // NOTE: The encoding operation breaks its output with newlines every
    115 // 64 characters of output (48 characters of input). Use
    116 // EVP_EncodeBlock to encode raw base64.
    117 OPENSSL_EXPORT void EVP_EncodeInit(EVP_ENCODE_CTX *ctx);
    118 
    119 // EVP_EncodeUpdate encodes |in_len| bytes from |in| and writes an encoded
    120 // version of them to |out| and sets |*out_len| to the number of bytes written.
    121 // Some state may be contained in |ctx| so |EVP_EncodeFinal| must be used to
    122 // flush it before using the encoded data.
    123 OPENSSL_EXPORT void EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, uint8_t *out,
    124                                      int *out_len, const uint8_t *in,
    125                                      size_t in_len);
    126 
    127 // EVP_EncodeFinal flushes any remaining output bytes from |ctx| to |out| and
    128 // sets |*out_len| to the number of bytes written.
    129 OPENSSL_EXPORT void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, uint8_t *out,
    130                                     int *out_len);
    131 
    132 // EVP_DecodeInit initialises |*ctx|, which is typically stack allocated, for
    133 // a decoding operation.
    134 //
    135 // TODO(davidben): This isn't a straight-up base64 decode either. Document
    136 // and/or fix exactly what's going on here; maximum line length and such.
    137 OPENSSL_EXPORT void EVP_DecodeInit(EVP_ENCODE_CTX *ctx);
    138 
    139 // EVP_DecodeUpdate decodes |in_len| bytes from |in| and writes the decoded
    140 // data to |out| and sets |*out_len| to the number of bytes written. Some state
    141 // may be contained in |ctx| so |EVP_DecodeFinal| must be used to flush it
    142 // before using the encoded data.
    143 //
    144 // It returns -1 on error, one if a full line of input was processed and zero
    145 // if the line was short (i.e. it was the last line).
    146 OPENSSL_EXPORT int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, uint8_t *out,
    147                                     int *out_len, const uint8_t *in,
    148                                     size_t in_len);
    149 
    150 // EVP_DecodeFinal flushes any remaining output bytes from |ctx| to |out| and
    151 // sets |*out_len| to the number of bytes written. It returns one on success
    152 // and minus one on error.
    153 OPENSSL_EXPORT int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, uint8_t *out,
    154                                    int *out_len);
    155 
    156 // EVP_DecodeBlock encodes |src_len| bytes from |src| and writes the result to
    157 // |dst|. It returns the number of bytes written or -1 on error.
    158 //
    159 // WARNING: EVP_DecodeBlock's return value does not take padding into
    160 // account. It also strips leading whitespace and trailing
    161 // whitespace and minuses.
    162 OPENSSL_EXPORT int EVP_DecodeBlock(uint8_t *dst, const uint8_t *src,
    163                                    size_t src_len);
    164 
    165 
    166 struct evp_encode_ctx_st {
    167   // data_used indicates the number of bytes of |data| that are valid. When
    168   // encoding, |data| will be filled and encoded as a lump. When decoding, only
    169   // the first four bytes of |data| will be used.
    170   unsigned data_used;
    171   uint8_t data[48];
    172 
    173   // eof_seen indicates that the end of the base64 data has been seen when
    174   // decoding. Only whitespace can follow.
    175   char eof_seen;
    176 
    177   // error_encountered indicates that invalid base64 data was found. This will
    178   // cause all future calls to fail.
    179   char error_encountered;
    180 };
    181 
    182 
    183 #if defined(__cplusplus)
    184 }  // extern C
    185 #endif
    186 
    187 #endif  // OPENSSL_HEADER_BASE64_H
    188