crypto/asn1/bio_asn1.c

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