crypto/asn1/bio_asn1.c

   1 /* bio_asn1.c */
   2 /*
   3  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
   4  * project.
   5  */
   6 /* ====================================================================
   7  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  *
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  *
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in
  18  *    the documentation and/or other materials provided with the
  19  *    distribution.
  20  *
  21  * 3. All advertising materials mentioning features or use of this
  22  *    software must display the following acknowledgment:
  23  *    "This product includes software developed by the OpenSSL Project
  24  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  25  *
  26  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  27  *    endorse or promote products derived from this software without
  28  *    prior written permission. For written permission, please contact
  29  *    licensing@OpenSSL.org.
  30  *
  31  * 5. Products derived from this software may not be called "OpenSSL"
  32  *    nor may "OpenSSL" appear in their names without prior written
  33  *    permission of the OpenSSL Project.
  34  *
  35  * 6. Redistributions of any form whatsoever must retain the following
  36  *    acknowledgment:
  37  *    "This product includes software developed by the OpenSSL Project
  38  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  41  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  43  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  44  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  46  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  47  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  49  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  50  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  51  * OF THE POSSIBILITY OF SUCH DAMAGE.
  52  * ====================================================================
  53  *
  54  * This product includes cryptographic software written by Eric Young
  55  * (eay@cryptsoft.com).  This product includes software written by Tim
  56  * Hudson (tjh@cryptsoft.com).
  57  *
  58  */
  59
  60 /*
  61  * Experimental ASN1 BIO. When written through the data is converted to an
  62  * ASN1 string type: default is OCTET STRING. Additional functions can be
  63  * provided to add prefix and suffix data.
  64  */
  65
  66 #include <string.h>
  67 #include <openssl/bio.h>
  68 #include <openssl/asn1.h>
  69
  70 /* Must be large enough for biggest tag+length */
  71 #define DEFAULT_ASN1_BUF_SIZE 20
  72
  73 typedef enum {
  74     ASN1_STATE_START,
  75     ASN1_STATE_PRE_COPY,
  76     ASN1_STATE_HEADER,
  77     ASN1_STATE_HEADER_COPY,
  78     ASN1_STATE_DATA_COPY,
  79     ASN1_STATE_POST_COPY,
  80     ASN1_STATE_DONE
  81 } asn1_bio_state_t;
  82
  83 typedef struct BIO_ASN1_EX_FUNCS_st {
  84     asn1_ps_func *ex_func;
  85     asn1_ps_func *ex_free_func;
  86 } BIO_ASN1_EX_FUNCS;
  87
  88 typedef struct BIO_ASN1_BUF_CTX_t {
  89     /* Internal state */
  90     asn1_bio_state_t state;
  91     /* Internal buffer */
  92     unsigned char *buf;
  93     /* Size of buffer */
  94     int bufsize;
  95     /* Current position in buffer */
  96     int bufpos;
  97     /* Current buffer length */
  98     int buflen;
  99     /* Amount of data to copy */
 100     int copylen;
 101     /* Class and tag to use */
 102     int asn1_class, asn1_tag;
 103     asn1_ps_func *prefix, *prefix_free, *suffix, *suffix_free;
 104     /* Extra buffer for prefix and suffix data */
 105     unsigned char *ex_buf;
 106     int ex_len;
 107     int ex_pos;
 108     void *ex_arg;
 109 } BIO_ASN1_BUF_CTX;
 110
 111 static int asn1_bio_write(BIO *h, const char *buf, int num);
 112 static int asn1_bio_read(BIO *h, char *buf, int size);
 113 static int asn1_bio_puts(BIO *h, const char *str);
 114 static int asn1_bio_gets(BIO *h, char *str, int size);
 115 static long asn1_bio_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 116 static int asn1_bio_new(BIO *h);
 117 static int asn1_bio_free(BIO *data);
 118 static long asn1_bio_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp);
 119
 120 static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size);
 121 static int asn1_bio_flush_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
 122                              asn1_ps_func *cleanup, asn1_bio_state_t next);
 123 static int asn1_bio_setup_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
 124                              asn1_ps_func *setup,
 125                              asn1_bio_state_t ex_state,
 126                              asn1_bio_state_t other_state);
 127
 128 static BIO_METHOD methods_asn1 = {
 129     BIO_TYPE_ASN1,
 130     "asn1",
 131     asn1_bio_write,
 132     asn1_bio_read,
 133     asn1_bio_puts,
 134     asn1_bio_gets,
 135     asn1_bio_ctrl,
 136     asn1_bio_new,
 137     asn1_bio_free,
 138     asn1_bio_callback_ctrl,
 139 };
 140
 141 BIO_METHOD *BIO_f_asn1(void)
 142 {
 143     return (&methods_asn1);
 144 }
 145
 146 static int asn1_bio_new(BIO *b)
 147 {
 148     BIO_ASN1_BUF_CTX *ctx;
 149     ctx = OPENSSL_malloc(sizeof(*ctx));
 150     if (ctx == NULL)
 151         return 0;
 152     if (!asn1_bio_init(ctx, DEFAULT_ASN1_BUF_SIZE)) {
 153         OPENSSL_free(ctx);
 154         return 0;
 155     }
 156     b->init = 1;
 157     b->ptr = (char *)ctx;
 158     b->flags = 0;
 159     return 1;
 160 }
 161
 162 static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size)
 163 {
 164     ctx->buf = OPENSSL_malloc(size);
 165     if (ctx->buf == NULL)
 166         return 0;
 167     ctx->bufsize = size;
 168     ctx->bufpos = 0;
 169     ctx->buflen = 0;
 170     ctx->copylen = 0;
 171     ctx->asn1_class = V_ASN1_UNIVERSAL;
 172     ctx->asn1_tag = V_ASN1_OCTET_STRING;
 173     ctx->ex_buf = 0;
 174     ctx->ex_pos = 0;
 175     ctx->ex_len = 0;
 176     ctx->state = ASN1_STATE_START;
 177     return 1;
 178 }
 179
 180 static int asn1_bio_free(BIO *b)
 181 {
 182     BIO_ASN1_BUF_CTX *ctx = (BIO_ASN1_BUF_CTX *)b->ptr;
 183
 184     if (ctx == NULL)
 185         return 0;
 186     OPENSSL_free(ctx->buf);
 187     OPENSSL_free(ctx);
 188     b->init = 0;
 189     b->ptr = NULL;
 190     b->flags = 0;
 191     return 1;
 192 }
 193
 194 static int asn1_bio_write(BIO *b, const char *in, int inl)
 195 {
 196     BIO_ASN1_BUF_CTX *ctx;
 197     int wrmax, wrlen, ret;
 198     unsigned char *p;
 199     if (!in || (inl < 0) || (b->next_bio == NULL))
 200         return 0;
 201     ctx = (BIO_ASN1_BUF_CTX *)b->ptr;
 202     if (ctx == NULL)
 203         return 0;
 204
 205     wrlen = 0;
 206     ret = -1;
 207
 208     for (;;) {
 209         switch (ctx->state) {
 210
 211             /* Setup prefix data, call it */
 212         case ASN1_STATE_START:
 213             if (!asn1_bio_setup_ex(b, ctx, ctx->prefix,
 214                                    ASN1_STATE_PRE_COPY, ASN1_STATE_HEADER))
 215                 return 0;
 216             break;
 217
 218             /* Copy any pre data first */
 219         case ASN1_STATE_PRE_COPY:
 220
 221             ret = asn1_bio_flush_ex(b, ctx, ctx->prefix_free,
 222                                     ASN1_STATE_HEADER);
 223
 224             if (ret <= 0)
 225                 goto done;
 226
 227             break;
 228
 229         case ASN1_STATE_HEADER:
 230             ctx->buflen = ASN1_object_size(0, inl, ctx->asn1_tag) - inl;
 231             OPENSSL_assert(ctx->buflen <= ctx->bufsize);
 232             p = ctx->buf;
 233             ASN1_put_object(&p, 0, inl, ctx->asn1_tag, ctx->asn1_class);
 234             ctx->copylen = inl;
 235             ctx->state = ASN1_STATE_HEADER_COPY;
 236
 237             break;
 238
 239         case ASN1_STATE_HEADER_COPY:
 240             ret = BIO_write(b->next_bio, ctx->buf + ctx->bufpos, ctx->buflen);
 241             if (ret <= 0)
 242                 goto done;
 243
 244             ctx->buflen -= ret;
 245             if (ctx->buflen)
 246                 ctx->bufpos += ret;
 247             else {
 248                 ctx->bufpos = 0;
 249                 ctx->state = ASN1_STATE_DATA_COPY;
 250             }
 251
 252             break;
 253
 254         case ASN1_STATE_DATA_COPY:
 255
 256             if (inl > ctx->copylen)
 257                 wrmax = ctx->copylen;
 258             else
 259                 wrmax = inl;
 260             ret = BIO_write(b->next_bio, in, wrmax);
 261             if (ret <= 0)
 262                 break;
 263             wrlen += ret;
 264             ctx->copylen -= ret;
 265             in += ret;
 266             inl -= ret;
 267
 268             if (ctx->copylen == 0)
 269                 ctx->state = ASN1_STATE_HEADER;
 270
 271             if (inl == 0)
 272                 goto done;
 273
 274             break;
 275
 276         default:
 277             BIO_clear_retry_flags(b);
 278             return 0;
 279
 280         }
 281
 282     }
 283
 284  done:
 285     BIO_clear_retry_flags(b);
 286     BIO_copy_next_retry(b);
 287
 288     return (wrlen > 0) ? wrlen : ret;
 289
 290 }
 291
 292 static int asn1_bio_flush_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
 293                              asn1_ps_func *cleanup, asn1_bio_state_t next)
 294 {
 295     int ret;
 296     if (ctx->ex_len <= 0)
 297         return 1;
 298     for (;;) {
 299         ret = BIO_write(b->next_bio, ctx->ex_buf + ctx->ex_pos, ctx->ex_len);
 300         if (ret <= 0)
 301             break;
 302         ctx->ex_len -= ret;
 303         if (ctx->ex_len > 0)
 304             ctx->ex_pos += ret;
 305         else {
 306             if (cleanup)
 307                 cleanup(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg);
 308             ctx->state = next;
 309             ctx->ex_pos = 0;
 310             break;
 311         }
 312     }
 313     return ret;
 314 }
 315
 316 static int asn1_bio_setup_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
 317                              asn1_ps_func *setup,
 318                              asn1_bio_state_t ex_state,
 319                              asn1_bio_state_t other_state)
 320 {
 321     if (setup && !setup(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg)) {
 322         BIO_clear_retry_flags(b);
 323         return 0;
 324     }
 325     if (ctx->ex_len > 0)
 326         ctx->state = ex_state;
 327     else
 328         ctx->state = other_state;
 329     return 1;
 330 }
 331
 332 static int asn1_bio_read(BIO *b, char *in, int inl)
 333 {
 334     if (!b->next_bio)
 335         return 0;
 336     return BIO_read(b->next_bio, in, inl);
 337 }
 338
 339 static int asn1_bio_puts(BIO *b, const char *str)
 340 {
 341     return asn1_bio_write(b, str, strlen(str));
 342 }
 343
 344 static int asn1_bio_gets(BIO *b, char *str, int size)
 345 {
 346     if (!b->next_bio)
 347         return 0;
 348     return BIO_gets(b->next_bio, str, size);
 349 }
 350
 351 static long asn1_bio_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
 352 {
 353     if (b->next_bio == NULL)
 354         return (0);
 355     return BIO_callback_ctrl(b->next_bio, cmd, fp);
 356 }
 357
 358 static long asn1_bio_ctrl(BIO *b, int cmd, long arg1, void *arg2)
 359 {
 360     BIO_ASN1_BUF_CTX *ctx;
 361     BIO_ASN1_EX_FUNCS *ex_func;
 362     long ret = 1;
 363     ctx = (BIO_ASN1_BUF_CTX *)b->ptr;
 364     if (ctx == NULL)
 365         return 0;
 366     switch (cmd) {
 367
 368     case BIO_C_SET_PREFIX:
 369         ex_func = arg2;
 370         ctx->prefix = ex_func->ex_func;
 371         ctx->prefix_free = ex_func->ex_free_func;
 372         break;
 373
 374     case BIO_C_GET_PREFIX:
 375         ex_func = arg2;
 376         ex_func->ex_func = ctx->prefix;
 377         ex_func->ex_free_func = ctx->prefix_free;
 378         break;
 379
 380     case BIO_C_SET_SUFFIX:
 381         ex_func = arg2;
 382         ctx->suffix = ex_func->ex_func;
 383         ctx->suffix_free = ex_func->ex_free_func;
 384         break;
 385
 386     case BIO_C_GET_SUFFIX:
 387         ex_func = arg2;
 388         ex_func->ex_func = ctx->suffix;
 389         ex_func->ex_free_func = ctx->suffix_free;
 390         break;
 391
 392     case BIO_C_SET_EX_ARG:
 393         ctx->ex_arg = arg2;
 394         break;
 395
 396     case BIO_C_GET_EX_ARG:
 397         *(void **)arg2 = ctx->ex_arg;
 398         break;
 399
 400     case BIO_CTRL_FLUSH:
 401         if (!b->next_bio)
 402             return 0;
 403
 404         /* Call post function if possible */
 405         if (ctx->state == ASN1_STATE_HEADER) {
 406             if (!asn1_bio_setup_ex(b, ctx, ctx->suffix,
 407                                    ASN1_STATE_POST_COPY, ASN1_STATE_DONE))
 408                 return 0;
 409         }
 410
 411         if (ctx->state == ASN1_STATE_POST_COPY) {
 412             ret = asn1_bio_flush_ex(b, ctx, ctx->suffix_free,
 413                                     ASN1_STATE_DONE);
 414             if (ret <= 0)
 415                 return ret;
 416         }
 417
 418         if (ctx->state == ASN1_STATE_DONE)
 419             return BIO_ctrl(b->next_bio, cmd, arg1, arg2);
 420         else {
 421             BIO_clear_retry_flags(b);
 422             return 0;
 423         }
 424
 425     default:
 426         if (!b->next_bio)
 427             return 0;
 428         return BIO_ctrl(b->next_bio, cmd, arg1, arg2);
 429
 430     }
 431
 432     return ret;
 433 }
 434
 435 static int asn1_bio_set_ex(BIO *b, int cmd,
 436                            asn1_ps_func *ex_func, asn1_ps_func *ex_free_func)
 437 {
 438     BIO_ASN1_EX_FUNCS extmp;
 439     extmp.ex_func = ex_func;
 440     extmp.ex_free_func = ex_free_func;
 441     return BIO_ctrl(b, cmd, 0, &extmp);
 442 }
 443
 444 static int asn1_bio_get_ex(BIO *b, int cmd,
 445                            asn1_ps_func **ex_func,
 446                            asn1_ps_func **ex_free_func)
 447 {
 448     BIO_ASN1_EX_FUNCS extmp;
 449     int ret;
 450     ret = BIO_ctrl(b, cmd, 0, &extmp);
 451     if (ret > 0) {
 452         *ex_func = extmp.ex_func;
 453         *ex_free_func = extmp.ex_free_func;
 454     }
 455     return ret;
 456 }
 457
 458 int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
 459                         asn1_ps_func *prefix_free)
 460 {
 461     return asn1_bio_set_ex(b, BIO_C_SET_PREFIX, prefix, prefix_free);
 462 }
 463
 464 int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
 465                         asn1_ps_func **pprefix_free)
 466 {
 467     return asn1_bio_get_ex(b, BIO_C_GET_PREFIX, pprefix, pprefix_free);
 468 }
 469
 470 int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
 471                         asn1_ps_func *suffix_free)
 472 {
 473     return asn1_bio_set_ex(b, BIO_C_SET_SUFFIX, suffix, suffix_free);
 474 }
 475
 476 int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
 477                         asn1_ps_func **psuffix_free)
 478 {
 479     return asn1_bio_get_ex(b, BIO_C_GET_SUFFIX, psuffix, psuffix_free);
 480 }