--- /dev/null
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
+ * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ *
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to. The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code. The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh@cryptsoft.com).
+ *
+ * Copyright remains Eric Young's, and as such any Copyright notices in
+ * the code are not to be removed.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * "This product includes cryptographic software written by
+ * Eric Young (eay@cryptsoft.com)"
+ * The word 'cryptographic' can be left out if the rouines from the library
+ * being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from
+ * the apps directory (application code) you must include an acknowledgement:
+ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed. i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.] */
+
+#include <openssl/base64.h>
+
+#include <assert.h>
+#include <limits.h>
+#include <string.h>
+
+#include <openssl/type_check.h>
+
+#include "../internal.h"
+
+
+// constant_time_lt_args_8 behaves like |constant_time_lt_8| but takes |uint8_t|
+// arguments for a slightly simpler implementation.
+static inline uint8_t constant_time_lt_args_8(uint8_t a, uint8_t b) {
+ crypto_word_t aw = a;
+ crypto_word_t bw = b;
+ // |crypto_word_t| is larger than |uint8_t|, so |aw| and |bw| have the same
+ // MSB. |aw| < |bw| iff MSB(|aw| - |bw|) is 1.
+ return constant_time_msb_w(aw - bw);
+}
+
+// constant_time_in_range_8 returns |CONSTTIME_TRUE_8| if |min| <= |a| <= |max|
+// and |CONSTTIME_FALSE_8| otherwise.
+static inline uint8_t constant_time_in_range_8(uint8_t a, uint8_t min,
+ uint8_t max) {
+ a -= min;
+ return constant_time_lt_args_8(a, max - min + 1);
+}
+
+// Encoding.
+
+static uint8_t conv_bin2ascii(uint8_t a) {
+ // Since PEM is sometimes used to carry private keys, we encode base64 data
+ // itself in constant-time.
+ a &= 0x3f;
+ uint8_t ret = constant_time_select_8(constant_time_eq_8(a, 62), '+', '/');
+ ret =
+ constant_time_select_8(constant_time_lt_args_8(a, 62), a - 52 + '0', ret);
+ ret =
+ constant_time_select_8(constant_time_lt_args_8(a, 52), a - 26 + 'a', ret);
+ ret = constant_time_select_8(constant_time_lt_args_8(a, 26), a + 'A', ret);
+ return ret;
+}
+
+OPENSSL_COMPILE_ASSERT(sizeof(((EVP_ENCODE_CTX *)(NULL))->data) % 3 == 0,
+ data_length_must_be_multiple_of_base64_chunk_size);
+
+int EVP_EncodedLength(size_t *out_len, size_t len) {
+ if (len + 2 < len) {
+ return 0;
+ }
+ len += 2;
+ len /= 3;
+
+ if (((len << 2) >> 2) != len) {
+ return 0;
+ }
+ len <<= 2;
+
+ if (len + 1 < len) {
+ return 0;
+ }
+ len++;
+
+ *out_len = len;
+ return 1;
+}
+
+void EVP_EncodeInit(EVP_ENCODE_CTX *ctx) {
+ OPENSSL_memset(ctx, 0, sizeof(EVP_ENCODE_CTX));
+}
+
+void EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, uint8_t *out, int *out_len,
+ const uint8_t *in, size_t in_len) {
+ size_t total = 0;
+
+ *out_len = 0;
+ if (in_len == 0) {
+ return;
+ }
+
+ assert(ctx->data_used < sizeof(ctx->data));
+
+ if (sizeof(ctx->data) - ctx->data_used > in_len) {
+ OPENSSL_memcpy(&ctx->data[ctx->data_used], in, in_len);
+ ctx->data_used += (unsigned)in_len;
+ return;
+ }
+
+ if (ctx->data_used != 0) {
+ const size_t todo = sizeof(ctx->data) - ctx->data_used;
+ OPENSSL_memcpy(&ctx->data[ctx->data_used], in, todo);
+ in += todo;
+ in_len -= todo;
+
+ size_t encoded = EVP_EncodeBlock(out, ctx->data, sizeof(ctx->data));
+ ctx->data_used = 0;
+
+ out += encoded;
+ *(out++) = '\n';
+ *out = '\0';
+
+ total = encoded + 1;
+ }
+
+ while (in_len >= sizeof(ctx->data)) {
+ size_t encoded = EVP_EncodeBlock(out, in, sizeof(ctx->data));
+ in += sizeof(ctx->data);
+ in_len -= sizeof(ctx->data);
+
+ out += encoded;
+ *(out++) = '\n';
+ *out = '\0';
+
+ if (total + encoded + 1 < total) {
+ *out_len = 0;
+ return;
+ }
+
+ total += encoded + 1;
+ }
+
+ if (in_len != 0) {
+ OPENSSL_memcpy(ctx->data, in, in_len);
+ }
+
+ ctx->data_used = (unsigned)in_len;
+
+ if (total > INT_MAX) {
+ // We cannot signal an error, but we can at least avoid making *out_len
+ // negative.
+ total = 0;
+ }
+ *out_len = (int)total;
+}
+
+void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, uint8_t *out, int *out_len) {
+ if (ctx->data_used == 0) {
+ *out_len = 0;
+ return;
+ }
+
+ size_t encoded = EVP_EncodeBlock(out, ctx->data, ctx->data_used);
+ out[encoded++] = '\n';
+ out[encoded] = '\0';
+ ctx->data_used = 0;
+
+ // ctx->data_used is bounded by sizeof(ctx->data), so this does not
+ // overflow.
+ assert(encoded <= INT_MAX);
+ *out_len = (int)encoded;
+}
+
+size_t EVP_EncodeBlock(uint8_t *dst, const uint8_t *src, size_t src_len) {
+ uint32_t l;
+ size_t remaining = src_len, ret = 0;
+
+ while (remaining) {
+ if (remaining >= 3) {
+ l = (((uint32_t)src[0]) << 16L) | (((uint32_t)src[1]) << 8L) | src[2];
+ *(dst++) = conv_bin2ascii(l >> 18L);
+ *(dst++) = conv_bin2ascii(l >> 12L);
+ *(dst++) = conv_bin2ascii(l >> 6L);
+ *(dst++) = conv_bin2ascii(l);
+ remaining -= 3;
+ } else {
+ l = ((uint32_t)src[0]) << 16L;
+ if (remaining == 2) {
+ l |= ((uint32_t)src[1] << 8L);
+ }
+
+ *(dst++) = conv_bin2ascii(l >> 18L);
+ *(dst++) = conv_bin2ascii(l >> 12L);
+ *(dst++) = (remaining == 1) ? '=' : conv_bin2ascii(l >> 6L);
+ *(dst++) = '=';
+ remaining = 0;
+ }
+ ret += 4;
+ src += 3;
+ }
+
+ *dst = '\0';
+ return ret;
+}
+
+
+// Decoding.
+
+int EVP_DecodedLength(size_t *out_len, size_t len) {
+ if (len % 4 != 0) {
+ return 0;
+ }
+
+ *out_len = (len / 4) * 3;
+ return 1;
+}
+
+void EVP_DecodeInit(EVP_ENCODE_CTX *ctx) {
+ OPENSSL_memset(ctx, 0, sizeof(EVP_ENCODE_CTX));
+}
+
+static uint8_t base64_ascii_to_bin(uint8_t a) {
+ // Since PEM is sometimes used to carry private keys, we decode base64 data
+ // itself in constant-time.
+ const uint8_t is_upper = constant_time_in_range_8(a, 'A', 'Z');
+ const uint8_t is_lower = constant_time_in_range_8(a, 'a', 'z');
+ const uint8_t is_digit = constant_time_in_range_8(a, '0', '9');
+ const uint8_t is_plus = constant_time_eq_8(a, '+');
+ const uint8_t is_slash = constant_time_eq_8(a, '/');
+ const uint8_t is_equals = constant_time_eq_8(a, '=');
+
+ uint8_t ret = 0xff; // 0xff signals invalid.
+ ret = constant_time_select_8(is_upper, a - 'A', ret); // [0,26)
+ ret = constant_time_select_8(is_lower, a - 'a' + 26, ret); // [26,52)
+ ret = constant_time_select_8(is_digit, a - '0' + 52, ret); // [52,62)
+ ret = constant_time_select_8(is_plus, 62, ret);
+ ret = constant_time_select_8(is_slash, 63, ret);
+ // Padding maps to zero, to be further handled by the caller.
+ ret = constant_time_select_8(is_equals, 0, ret);
+ return ret;
+}
+
+// base64_decode_quad decodes a single “quad” (i.e. four characters) of base64
+// data and writes up to three bytes to |out|. It sets |*out_num_bytes| to the
+// number of bytes written, which will be less than three if the quad ended
+// with padding. It returns one on success or zero on error.
+static int base64_decode_quad(uint8_t *out, size_t *out_num_bytes,
+ const uint8_t *in) {
+ const uint8_t a = base64_ascii_to_bin(in[0]);
+ const uint8_t b = base64_ascii_to_bin(in[1]);
+ const uint8_t c = base64_ascii_to_bin(in[2]);
+ const uint8_t d = base64_ascii_to_bin(in[3]);
+ if (a == 0xff || b == 0xff || c == 0xff || d == 0xff) {
+ return 0;
+ }
+
+ const uint32_t v = ((uint32_t)a) << 18 | ((uint32_t)b) << 12 |
+ ((uint32_t)c) << 6 | (uint32_t)d;
+
+ const unsigned padding_pattern = (in[0] == '=') << 3 |
+ (in[1] == '=') << 2 |
+ (in[2] == '=') << 1 |
+ (in[3] == '=');
+
+ switch (padding_pattern) {
+ case 0:
+ // The common case of no padding.
+ *out_num_bytes = 3;
+ out[0] = v >> 16;
+ out[1] = v >> 8;
+ out[2] = v;
+ break;
+
+ case 1: // xxx=
+ *out_num_bytes = 2;
+ out[0] = v >> 16;
+ out[1] = v >> 8;
+ break;
+
+ case 3: // xx==
+ *out_num_bytes = 1;
+ out[0] = v >> 16;
+ break;
+
+ default:
+ return 0;
+ }
+
+ return 1;
+}
+
+int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, uint8_t *out, int *out_len,
+ const uint8_t *in, size_t in_len) {
+ *out_len = 0;
+
+ if (ctx->error_encountered) {
+ return -1;
+ }
+
+ size_t bytes_out = 0, i;
+ for (i = 0; i < in_len; i++) {
+ const char c = in[i];
+ switch (c) {
+ case ' ':
+ case '\t':
+ case '\r':
+ case '\n':
+ continue;
+ }
+
+ if (ctx->eof_seen) {
+ ctx->error_encountered = 1;
+ return -1;
+ }
+
+ ctx->data[ctx->data_used++] = c;
+ if (ctx->data_used == 4) {
+ size_t num_bytes_resulting;
+ if (!base64_decode_quad(out, &num_bytes_resulting, ctx->data)) {
+ ctx->error_encountered = 1;
+ return -1;
+ }
+
+ ctx->data_used = 0;
+ bytes_out += num_bytes_resulting;
+ out += num_bytes_resulting;
+
+ if (num_bytes_resulting < 3) {
+ ctx->eof_seen = 1;
+ }
+ }
+ }
+
+ if (bytes_out > INT_MAX) {
+ ctx->error_encountered = 1;
+ *out_len = 0;
+ return -1;
+ }
+ *out_len = (int)bytes_out;
+
+ if (ctx->eof_seen) {
+ return 0;
+ }
+
+ return 1;
+}
+
+int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, uint8_t *out, int *out_len) {
+ *out_len = 0;
+ if (ctx->error_encountered || ctx->data_used != 0) {
+ return -1;
+ }
+
+ return 1;
+}
+
+int EVP_DecodeBase64(uint8_t *out, size_t *out_len, size_t max_out,
+ const uint8_t *in, size_t in_len) {
+ *out_len = 0;
+
+ if (in_len % 4 != 0) {
+ return 0;
+ }
+
+ size_t max_len;
+ if (!EVP_DecodedLength(&max_len, in_len) ||
+ max_out < max_len) {
+ return 0;
+ }
+
+ size_t i, bytes_out = 0;
+ for (i = 0; i < in_len; i += 4) {
+ size_t num_bytes_resulting;
+
+ if (!base64_decode_quad(out, &num_bytes_resulting, &in[i])) {
+ return 0;
+ }
+
+ bytes_out += num_bytes_resulting;
+ out += num_bytes_resulting;
+ if (num_bytes_resulting != 3 && i != in_len - 4) {
+ return 0;
+ }
+ }
+
+ *out_len = bytes_out;
+ return 1;
+}
+
+int EVP_DecodeBlock(uint8_t *dst, const uint8_t *src, size_t src_len) {
+ // Trim spaces and tabs from the beginning of the input.
+ while (src_len > 0) {
+ if (src[0] != ' ' && src[0] != '\t') {
+ break;
+ }
+
+ src++;
+ src_len--;
+ }
+
+ // Trim newlines, spaces and tabs from the end of the line.
+ while (src_len > 0) {
+ switch (src[src_len-1]) {
+ case ' ':
+ case '\t':
+ case '\r':
+ case '\n':
+ src_len--;
+ continue;
+ }
+
+ break;
+ }
+
+ size_t dst_len;
+ if (!EVP_DecodedLength(&dst_len, src_len) ||
+ dst_len > INT_MAX ||
+ !EVP_DecodeBase64(dst, &dst_len, dst_len, src, src_len)) {
+ return -1;
+ }
+
+ // EVP_DecodeBlock does not take padding into account, so put the
+ // NULs back in... so the caller can strip them back out.
+ while (dst_len % 3 != 0) {
+ dst[dst_len++] = '\0';
+ }
+ assert(dst_len <= INT_MAX);
+
+ return (int)dst_len;
+}
git://repos.xcallymotion.com / motion2.git / blobdiff