test/core/slice/b64_test.cc

   1 /*
   2  *
   3  * Copyright 2015 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 #include "src/core/lib/slice/b64.h"
  20
  21 #include <string.h>
  22
  23 #include <grpc/grpc.h>
  24 #include <grpc/slice.h>
  25 #include <grpc/support/alloc.h>
  26 #include <grpc/support/log.h>
  27
  28 #include "src/core/lib/iomgr/exec_ctx.h"
  29 #include "src/core/lib/slice/slice_internal.h"
  30 #include "test/core/util/test_config.h"
  31
  32 static int buffers_are_equal(const unsigned char* buf1,
  33                              const unsigned char* buf2, size_t size) {
  34   size_t i;
  35   for (i = 0; i < size; i++) {
  36     if (buf1[i] != buf2[i]) {
  37       gpr_log(GPR_ERROR, "buf1 and buf2 differ: buf1[%d] = %x vs buf2[%d] = %x",
  38               static_cast<int>(i), buf1[i], static_cast<int>(i), buf2[i]);
  39       return 0;
  40     }
  41   }
  42   return 1;
  43 }
  44
  45 static void test_simple_encode_decode_b64(int url_safe, int multiline) {
  46   const char* hello = "hello";
  47   char* hello_b64 =
  48       grpc_base64_encode(hello, strlen(hello), url_safe, multiline);
  49   grpc_core::ExecCtx exec_ctx;
  50   grpc_slice hello_slice = grpc_base64_decode(hello_b64, url_safe);
  51   GPR_ASSERT(GRPC_SLICE_LENGTH(hello_slice) == strlen(hello));
  52   GPR_ASSERT(strncmp((const char*)GRPC_SLICE_START_PTR(hello_slice), hello,
  53                      GRPC_SLICE_LENGTH(hello_slice)) == 0);
  54
  55   grpc_slice_unref_internal(hello_slice);
  56
  57   gpr_free(hello_b64);
  58 }
  59
  60 static void test_full_range_encode_decode_b64(int url_safe, int multiline) {
  61   unsigned char orig[256];
  62   size_t i;
  63   char* b64;
  64   grpc_slice orig_decoded;
  65   for (i = 0; i < sizeof(orig); i++) orig[i] = static_cast<uint8_t>(i);
  66
  67   /* Try all the different paddings. */
  68   for (i = 0; i < 3; i++) {
  69     grpc_core::ExecCtx exec_ctx;
  70     b64 = grpc_base64_encode(orig, sizeof(orig) - i, url_safe, multiline);
  71     orig_decoded = grpc_base64_decode(b64, url_safe);
  72     GPR_ASSERT(GRPC_SLICE_LENGTH(orig_decoded) == (sizeof(orig) - i));
  73     GPR_ASSERT(buffers_are_equal(orig, GRPC_SLICE_START_PTR(orig_decoded),
  74                                  sizeof(orig) - i));
  75     grpc_slice_unref_internal(orig_decoded);
  76     gpr_free(b64);
  77   }
  78 }
  79
  80 static void test_simple_encode_decode_b64_no_multiline(void) {
  81   test_simple_encode_decode_b64(0, 0);
  82 }
  83
  84 static void test_simple_encode_decode_b64_multiline(void) {
  85   test_simple_encode_decode_b64(0, 1);
  86 }
  87
  88 static void test_simple_encode_decode_b64_urlsafe_no_multiline(void) {
  89   test_simple_encode_decode_b64(1, 0);
  90 }
  91
  92 static void test_simple_encode_decode_b64_urlsafe_multiline(void) {
  93   test_simple_encode_decode_b64(1, 1);
  94 }
  95
  96 static void test_full_range_encode_decode_b64_no_multiline(void) {
  97   test_full_range_encode_decode_b64(0, 0);
  98 }
  99
 100 static void test_full_range_encode_decode_b64_multiline(void) {
 101   test_full_range_encode_decode_b64(0, 1);
 102 }
 103
 104 static void test_full_range_encode_decode_b64_urlsafe_no_multiline(void) {
 105   test_full_range_encode_decode_b64(1, 0);
 106 }
 107
 108 static void test_full_range_encode_decode_b64_urlsafe_multiline(void) {
 109   test_full_range_encode_decode_b64(1, 1);
 110 }
 111
 112 static void test_url_safe_unsafe_mismatch_failure(void) {
 113   unsigned char orig[256];
 114   size_t i;
 115   char* b64;
 116   grpc_slice orig_decoded;
 117   int url_safe = 1;
 118   for (i = 0; i < sizeof(orig); i++) orig[i] = static_cast<uint8_t>(i);
 119
 120   grpc_core::ExecCtx exec_ctx;
 121   b64 = grpc_base64_encode(orig, sizeof(orig), url_safe, 0);
 122   orig_decoded = grpc_base64_decode(b64, !url_safe);
 123   GPR_ASSERT(GRPC_SLICE_IS_EMPTY(orig_decoded));
 124   gpr_free(b64);
 125   grpc_slice_unref_internal(orig_decoded);
 126
 127   b64 = grpc_base64_encode(orig, sizeof(orig), !url_safe, 0);
 128   orig_decoded = grpc_base64_decode(b64, url_safe);
 129   GPR_ASSERT(GRPC_SLICE_IS_EMPTY(orig_decoded));
 130   gpr_free(b64);
 131   grpc_slice_unref_internal(orig_decoded);
 132 }
 133
 134 static void test_rfc4648_test_vectors(void) {
 135   char* b64;
 136
 137   b64 = grpc_base64_encode("", 0, 0, 0);
 138   GPR_ASSERT(strcmp("", b64) == 0);
 139   gpr_free(b64);
 140
 141   b64 = grpc_base64_encode("f", 1, 0, 0);
 142   GPR_ASSERT(strcmp("Zg==", b64) == 0);
 143   gpr_free(b64);
 144
 145   b64 = grpc_base64_encode("fo", 2, 0, 0);
 146   GPR_ASSERT(strcmp("Zm8=", b64) == 0);
 147   gpr_free(b64);
 148
 149   b64 = grpc_base64_encode("foo", 3, 0, 0);
 150   GPR_ASSERT(strcmp("Zm9v", b64) == 0);
 151   gpr_free(b64);
 152
 153   b64 = grpc_base64_encode("foob", 4, 0, 0);
 154   GPR_ASSERT(strcmp("Zm9vYg==", b64) == 0);
 155   gpr_free(b64);
 156
 157   b64 = grpc_base64_encode("fooba", 5, 0, 0);
 158   GPR_ASSERT(strcmp("Zm9vYmE=", b64) == 0);
 159   gpr_free(b64);
 160
 161   b64 = grpc_base64_encode("foobar", 6, 0, 0);
 162   GPR_ASSERT(strcmp("Zm9vYmFy", b64) == 0);
 163   gpr_free(b64);
 164 }
 165
 166 static void test_unpadded_decode(void) {
 167   grpc_slice decoded;
 168
 169   grpc_core::ExecCtx exec_ctx;
 170   decoded = grpc_base64_decode("Zm9vYmFy", 0);
 171   GPR_ASSERT(!GRPC_SLICE_IS_EMPTY(decoded));
 172   GPR_ASSERT(grpc_slice_str_cmp(decoded, "foobar") == 0);
 173   grpc_slice_unref(decoded);
 174
 175   decoded = grpc_base64_decode("Zm9vYmE", 0);
 176   GPR_ASSERT(!GRPC_SLICE_IS_EMPTY(decoded));
 177   GPR_ASSERT(grpc_slice_str_cmp(decoded, "fooba") == 0);
 178   grpc_slice_unref(decoded);
 179
 180   decoded = grpc_base64_decode("Zm9vYg", 0);
 181   GPR_ASSERT(!GRPC_SLICE_IS_EMPTY(decoded));
 182   GPR_ASSERT(grpc_slice_str_cmp(decoded, "foob") == 0);
 183   grpc_slice_unref(decoded);
 184
 185   decoded = grpc_base64_decode("Zm9v", 0);
 186   GPR_ASSERT(!GRPC_SLICE_IS_EMPTY(decoded));
 187   GPR_ASSERT(grpc_slice_str_cmp(decoded, "foo") == 0);
 188   grpc_slice_unref(decoded);
 189
 190   decoded = grpc_base64_decode("Zm8", 0);
 191   GPR_ASSERT(!GRPC_SLICE_IS_EMPTY(decoded));
 192   GPR_ASSERT(grpc_slice_str_cmp(decoded, "fo") == 0);
 193   grpc_slice_unref(decoded);
 194
 195   decoded = grpc_base64_decode("Zg", 0);
 196   GPR_ASSERT(!GRPC_SLICE_IS_EMPTY(decoded));
 197   GPR_ASSERT(grpc_slice_str_cmp(decoded, "f") == 0);
 198   grpc_slice_unref(decoded);
 199
 200   decoded = grpc_base64_decode("", 0);
 201   GPR_ASSERT(GRPC_SLICE_IS_EMPTY(decoded));
 202 }
 203
 204 int main(int argc, char** argv) {
 205   grpc::testing::TestEnvironment env(argc, argv);
 206   grpc_init();
 207   test_simple_encode_decode_b64_no_multiline();
 208   test_simple_encode_decode_b64_multiline();
 209   test_simple_encode_decode_b64_urlsafe_no_multiline();
 210   test_simple_encode_decode_b64_urlsafe_multiline();
 211   test_full_range_encode_decode_b64_no_multiline();
 212   test_full_range_encode_decode_b64_multiline();
 213   test_full_range_encode_decode_b64_urlsafe_no_multiline();
 214   test_full_range_encode_decode_b64_urlsafe_multiline();
 215   test_url_safe_unsafe_mismatch_failure();
 216   test_rfc4648_test_vectors();
 217   test_unpadded_decode();
 218   grpc_shutdown();
 219   return 0;
 220 }