pd.if.org Git - zpackage/blob - crypto/buffer.c

   1 #define _POSIX_C_SOURCE 200809L
   2
   3 #include <string.h>
   4 #include <errno.h>
   5
   6 #include "tlse.h"
   7 #include "buffer.h"
   8
   9 void tls_buffer_init(struct tls_buffer *buffer, size_t initial) {
  10         buffer->buffer = 0;
  11         buffer->len = 0;
  12         buffer->size = 0;
  13         buffer->error = 0;
  14         if (initial) {
  15                 errno = 0;
  16                 buffer->buffer = malloc(initial);
  17                 if (buffer->buffer) {
  18                         memset(buffer->buffer, 0, initial);
  19                         buffer->size = initial;
  20                 } else {
  21                         buffer->error = errno;
  22                 }
  23         }
  24 }
  25
  26 void tls_buffer_compact(struct tls_buffer *b) {
  27         void *new;
  28
  29         if (b->error || b->size == b->len) {
  30                 return;
  31         }
  32
  33         errno = 0;
  34         new = realloc(b->buffer, b->len);
  35
  36         if (new == NULL) {
  37                 b->error = errno;
  38                 return;
  39         }
  40
  41         b->buffer = new;
  42         return;
  43 }
  44
  45 /* makes sure there's at least need bytes free */
  46 void tls_buffer_expand(struct tls_buffer *buf, size_t need) {
  47         size_t want;
  48
  49         if (buf->error) {
  50                 return;
  51         }
  52
  53         want = buf->len + need;
  54
  55         if (want <= buf->size) {
  56                 return;
  57         }
  58
  59         errno = 0;
  60         char *new = realloc(buf->buffer, want);
  61         if (new) {
  62                 buf->buffer = new;
  63                 buf->size = want;
  64                 memset(buf->buffer + buf->len, 0, buf->size - buf->len);
  65         } else {
  66                 buf->error = errno;
  67         }
  68 }
  69
  70 void tls_buffer_free(struct tls_buffer *buffer) {
  71         /* TODO only zero out memory if it's "secure" buffer */
  72         if (buffer->buffer && buffer->len) {
  73                 memset(buffer->buffer, 0, buffer->len);
  74         }
  75         free(buffer->buffer);
  76         tls_buffer_init(buffer, 0);
  77 }
  78
  79 void tls_buffer_set(struct tls_buffer *buffer, int ch) {
  80         /* TODO only zero out memory if it's "secure" buffer */
  81         if (buffer->buffer && buffer->size) {
  82                 memset(buffer->buffer, ch, buffer->size);
  83         }
  84 }
  85
  86 void tls_buffer_append(struct tls_buffer *buffer, const unsigned char *bytes, size_t n) {
  87         tls_buffer_expand(buffer, n);
  88
  89         if (buffer->error || !bytes) {
  90                 return;
  91         }
  92
  93         memcpy(buffer->buffer + buffer->len, bytes, n);
  94         buffer->len += n;
  95 }
  96
  97 void tls_buffer_append_str(struct tls_buffer *buf, const unsigned char *s) {
  98         tls_buffer_append(buf, s, strlen(s));
  99 }
 100
 101 void tls_buffer_append16(struct tls_buffer *buffer, uint16_t n) {
 102         tls_buffer_expand(buffer, 2);
 103
 104         if (buffer->error) {
 105                 return;
 106         }
 107
 108         buffer->buffer[buffer->len++] = (n >> 8) & 0xff;
 109         buffer->buffer[buffer->len++] = n & 0xff;
 110 }
 111
 112 void tls_buffer_append24(struct tls_buffer *buffer, uint32_t n) {
 113         tls_buffer_expand(buffer, 3);
 114
 115         if (buffer->error) {
 116                 return;
 117         }
 118
 119         buffer->buffer[buffer->len++] = (n >> 16) & 0xff;
 120         buffer->buffer[buffer->len++] = (n >> 8) & 0xff;
 121         buffer->buffer[buffer->len++] = n & 0xff;
 122 }
 123
 124 void tls_buffer_append_byte(struct tls_buffer *buffer, uint8_t n) {
 125         tls_buffer_expand(buffer, 1);
 126
 127         if (buffer->error) {
 128                 return;
 129         }
 130
 131         buffer->buffer[buffer->len++] = n & 0xff;
 132 }
 133
 134 void tls_buffer_write16(struct tls_buffer *buffer, uint16_t n, size_t at) {
 135         if (at+2 > buffer->size) {
 136                 tls_buffer_expand(buffer, at+2 - buffer->size);
 137         }
 138
 139         if (buffer->error) {
 140                 return;
 141         }
 142
 143         buffer->buffer[at] = (n >> 8) & 0xff;
 144         buffer->buffer[at+1] = n & 0xff;
 145
 146         if (at+2 > buffer->len) {
 147                 buffer->len = at + 2;
 148         }
 149 }
 150
 151 uint16_t tls_buffer_read16(struct tls_buffer *buffer, size_t at) {
 152         uint16_t res = 0;
 153
 154         if (buffer->error || at+2 < buffer->len) {
 155                 return 0;
 156         }
 157
 158         res = (buffer->buffer[at] << 8) + buffer->buffer[at+1];
 159         return res;
 160 }
 161
 162 uint64_t tls_buffer_readbe(struct tls_buffer *buffer, int bytes, size_t at) {
 163         uint16_t res = 0;
 164         int i;
 165
 166         if (buffer->error || at+bytes < buffer->len) {
 167                 return 0;
 168         }
 169
 170         for (i=0; i<bytes; i++) {
 171                 res <<= 8;
 172                 res += buffer->buffer[at+i];
 173         }
 174
 175         return res;
 176 }
 177
 178 void tls_buffer_writebe(struct tls_buffer *buffer, int bytes, size_t at, uint64_t val) {
 179         int i;
 180         if (at+bytes > buffer->size) {
 181                 tls_buffer_expand(buffer, at+bytes - buffer->size);
 182         }
 183
 184         if (buffer->error) {
 185                 return;
 186         }
 187
 188         for (i=bytes-1; i>=0; i--) {
 189                 buffer->buffer[at+i] = val & 0xff;
 190                 val >>= 8;
 191         }
 192
 193         return;
 194 }
 195
 196
 197 void tls_buffer_shift(struct tls_buffer *buffer, size_t n) {
 198         if (buffer->error) {
 199                 return;
 200         }
 201
 202         if (buffer->len < n) {
 203                 n = buffer->len;
 204         }
 205
 206         if (n) {
 207                 memmove(buffer->buffer, buffer->buffer + n, buffer->len - n);
 208                 memset(buffer->buffer + buffer->len - n, 0, n);
 209 #if 0
 210                 fprintf(stderr, "memmove(%p, %p, %zu)\n", buffer->buffer,
 211                                 buffer->buffer+n, buffer->len - n);
 212                 fprintf(stderr, "memset(%p, %d, %zu)\n", buffer->buffer+n,
 213                                 0, n);
 214 #endif
 215
 216                 buffer->len -= n;
 217         }
 218 }
 219
 220 /* make room at the beginning */
 221 void tls_buffer_unshift(struct tls_buffer *buffer, size_t n) {
 222         tls_buffer_expand(buffer, n);
 223
 224         if (buffer->error) {
 225                 return;
 226         }
 227
 228         memmove(buffer->buffer + n, buffer->buffer, n);
 229         memset(buffer->buffer, 0, n);
 230 }
 231
 232 #if 0
 233 uint32_t tls_buffer_next3(struct tls_buffer_reader *rb) {
 234         uint32_t r;
 235
 236         r = tls_buffer_readbe(rb, 3, rb->cursor);
 237         rb->cursor += 3;
 238         return r;
 239 }
 240
 241 uint16_t tls_buffer_next2(struct tls_buffer_reader *rb) {
 242         uint16_t r;
 243
 244         r = tls_buffer_readbe(rb, 2, rb->cursor);
 245         rb->cursor += 2;
 246         return r;
 247 }
 248
 249 uint8_t tls_buffer_next(struct tls_buffer_reader *rb) {
 250         uint16_t r;
 251
 252         r = tls_buffer_readbe(rb, 2, rb->cursor);
 253         rb->cursor += 2;
 254
 255 }
 256
 257 void tls_buffer_nextn(struct tls_buffer_reader *rb, unsigned char *b, size_t n) {
 258         tls_buffer_read(rb, b, n, rb->cursor);
 259         rb->cursor += n;
 260 }
 261 #endif