tripcodes.c

   1 /*
   2  * Copyright (c) 2017, De Rais <derais@cock.li>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for
   5  * any purpose with or without fee is hereby granted, provided that the
   6  * above copyright notice and this permission notice appear in all
   7  * copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  10  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  11  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  12  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  13  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  14  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  15  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  16  * PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #include <stdint.h>
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #include <sodium.h>
  24
  25 #include "macros.h"
  26 #include "rb79.h"
  27
  28 /* Global configuration */
  29 static const struct configuration *conf;
  30
  31 /* Characters for Base64 */
  32 static const char *base64_elts =
  33         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
  34
  35 /* This should be a multiple of 3, so that base64 gives no '=' */
  36 #define OUT_HASH_LEN (3 * 3)
  37
  38 /*
  39  * Initialize any static elements needed for this file
  40  *
  41  * Preconditions:
  42  *
  43  *  - setup_tripcodes() was not invoked more recently than
  44  *    clean_tripcodes().
  45  *
  46  * Postconditions (success):
  47  *
  48  *  - Any other function in this file may be safely called.
  49  */
  50 int setup_tripcodes(const struct configuration *in_conf)
  51 {
  52         conf = in_conf;
  53
  54         return 0;
  55 }
  56
  57 /*
  58  * Base64 encode in to *out.
  59  *
  60  * Preconditions:
  61  *
  62  *  - in is an array of memory of length in_len (it need not be a string).
  63  *
  64  *  - in_len is a multiple of 3.
  65  *
  66  *  - out and out_len are not 0.
  67  *
  68  *  - overwriting *out shall not cause a memory leak.
  69  *
  70  * Postconditions (success):
  71  *
  72  *  - *out is a string of length *out_len.
  73  *
  74  *  - The contents of *out are the base64 encoding of the first
  75  *    in_len bytes of in.
  76  */
  77 static int base64_encode(const unsigned char *in, size_t in_len, char **out,
  78                          size_t *out_len)
  79 {
  80         int ret = -1;
  81         size_t built_len = in_len * 4 / 3 + 3;
  82         size_t out_idx = 0;
  83         char *built = 0;
  84
  85         if (!(built = malloc(built_len))) {
  86                 PERROR_MESSAGE("malloc");
  87                 goto done;
  88         }
  89
  90         for (size_t in_idx = 0; in_idx + 2 < in_len; in_idx += 3) {
  91                 unsigned char i1 = in[in_idx + 0];
  92                 unsigned char i2 = in[in_idx + 1];
  93                 unsigned char i3 = in[in_idx + 2];
  94                 size_t j1 = i1 >> 2;
  95                 size_t j2 = ((i1 & 0x03) << 4) | (i2 >> 4);
  96                 size_t j3 = ((i2 & 0x0F) << 2) | ((i3 & 0xC0) >> 6);
  97                 size_t j4 = (i3 & 0x3F);
  98
  99                 built[out_idx++] = base64_elts[j1];
 100                 built[out_idx++] = base64_elts[j2];
 101                 built[out_idx++] = base64_elts[j3];
 102                 built[out_idx++] = base64_elts[j4];
 103         }
 104
 105         built[out_idx] = '\0';
 106         *out = built;
 107         *out_len = out_idx;
 108         ret = 0;
 109 done:
 110
 111         return ret;
 112 }
 113
 114 /*
 115  * Calculate (raw) tripcode from (raw) name, if necessary. Name is
 116  * truncated to hide the input. This assumes p->raw.tripcode is
 117  * empty.
 118  *
 119  * Preconditions:
 120  *
 121  *  - p is not 0.
 122  *
 123  *  - p->raw.name is either 0, or is a string of length p->raw.name_len.
 124  *
 125  *  - Overwriting p->raw.tripcode shall not cause a memory leak.
 126  *
 127  * Postconditions (success):
 128  *
 129  *  - If p->raw.name was of the form "foo#bar", it is now of the
 130  *    form "foo". p->raw.name_len has been adjusted accordingly.
 131  *
 132  *  - If p->raw.name was of the form "foo#bar", p->raw.tripcode is
 133  *    determined by the key "bar". p->raw.tripcode_len is appropriate.
 134  */
 135 int tripcodes_calculate(struct post_cmd *p)
 136 {
 137         int ret = -1;
 138         char *trip_phrase_start = 0;
 139         unsigned char out_buf[OUT_HASH_LEN];
 140
 141         /* do not initialize this - unknown if struct or scalar */
 142         crypto_generichash_state cg_state;
 143
 144         if (!p->raw.name_len) {
 145                 goto success;
 146         }
 147
 148         /* XXX: The string length operations could be tightened */
 149         trip_phrase_start = strchr(p->raw.name, '#');
 150
 151         if (!trip_phrase_start) {
 152                 goto success;
 153         }
 154
 155         *trip_phrase_start = '\0';
 156         p->raw.name_len = strlen(p->raw.name);
 157         trip_phrase_start++;
 158
 159         if (!*trip_phrase_start) {
 160                 goto success;
 161         }
 162
 163         if (crypto_generichash_init(&cg_state, 0, 0, OUT_HASH_LEN) < 0) {
 164                 PERROR_MESSAGE("crypto_generichash_init");
 165                 goto done;
 166         }
 167
 168         if (crypto_generichash_update(&cg_state, (const unsigned
 169                                                   char *) trip_phrase_start,
 170                                       strlen(trip_phrase_start)) < 0) {
 171                 LOG("Failed to update hash with \"%s\"", trip_phrase_start);
 172                 PERROR_MESSAGE("crypto_generichash_update");
 173                 goto done;
 174         }
 175
 176         if (crypto_generichash_update(&cg_state, (const unsigned
 177                                                   char *) conf->trip_salt,
 178                                       conf->trip_salt_len) < 0) {
 179                 LOG("Failed to update hash with \"%s\"", conf->trip_salt);
 180                 PERROR_MESSAGE("crypto_generichash_update");
 181                 goto done;
 182         }
 183
 184         if (crypto_generichash_final(&cg_state, out_buf, OUT_HASH_LEN) < 0) {
 185                 PERROR_MESSAGE("crypto_generichash_final");
 186                 goto done;
 187         }
 188
 189         if (base64_encode(out_buf, OUT_HASH_LEN, &p->raw.tripcode,
 190                           &p->raw.tripcode_len) < 0) {
 191                 goto done;
 192         }
 193
 194 success:
 195         ret = 0;
 196 done:
 197
 198         return ret;
 199 }
 200
 201 /*
 202  * Clean any memory from this file
 203  *
 204  * Postconditions (success):
 205  *
 206  *  - Valgrind won't report any memory leaks from this file.
 207  *
 208  *  - setup_tripcodes() can be safely called again.
 209  */
 210 int clean_tripcodes(void)
 211 {
 212         conf = 0;
 213
 214         return 0;
 215 }