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(BIO_ASN1_BUF_CTX));
 150     if (!ctx)
 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)
 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     if (ctx->buf)
 187         OPENSSL_free(ctx->buf);
 188     OPENSSL_free(ctx);
 189     b->init = 0;
 190     b->ptr = NULL;
 191     b->flags = 0;
 192     return 1;
 193 }
 194
 195 static int asn1_bio_write(BIO *b, const char *in, int inl)
 196 {
 197     BIO_ASN1_BUF_CTX *ctx;
 198     int wrmax, wrlen, ret;
 199     unsigned char *p;
 200     if (!in || (inl < 0) || (b->next_bio == NULL))
 201         return 0;
 202     ctx = (BIO_ASN1_BUF_CTX *)b->ptr;
 203     if (ctx == NULL)
 204         return 0;
 205
 206     wrlen = 0;
 207     ret = -1;
 208
 209     for (;;) {
 210         switch (ctx->state) {
 211
 212             /* Setup prefix data, call it */
 213         case ASN1_STATE_START:
 214             if (!asn1_bio_setup_ex(b, ctx, ctx->prefix,
 215                                    ASN1_STATE_PRE_COPY, ASN1_STATE_HEADER))
 216                 return 0;
 217             break;
 218
 219             /* Copy any pre data first */
 220         case ASN1_STATE_PRE_COPY:
 221
 222             ret = asn1_bio_flush_ex(b, ctx, ctx->prefix_free,
 223                                     ASN1_STATE_HEADER);
 224
 225             if (ret <= 0)
 226                 goto done;
 227
 228             break;
 229
 230         case ASN1_STATE_HEADER:
 231             ctx->buflen = ASN1_object_size(0, inl, ctx->asn1_tag) - inl;
 232             OPENSSL_assert(ctx->buflen <= ctx->bufsize);
 233             p = ctx->buf;
 234             ASN1_put_object(&p, 0, inl, ctx->asn1_tag, ctx->asn1_class);
 235             ctx->copylen = inl;
 236             ctx->state = ASN1_STATE_HEADER_COPY;
 237
 238             break;
 239
 240         case ASN1_STATE_HEADER_COPY:
 241             ret = BIO_write(b->next_bio, ctx->buf + ctx->bufpos, ctx->buflen);
 242             if (ret <= 0)
 243                 goto done;
 244
 245             ctx->buflen -= ret;
 246             if (ctx->buflen)
 247                 ctx->bufpos += ret;
 248             else {
 249                 ctx->bufpos = 0;
 250                 ctx->state = ASN1_STATE_DATA_COPY;
 251             }
 252
 253             break;
 254
 255         case ASN1_STATE_DATA_COPY:
 256
 257             if (inl > ctx->copylen)
 258                 wrmax = ctx->copylen;
 259             else
 260                 wrmax = inl;
 261             ret = BIO_write(b->next_bio, in, wrmax);
 262             if (ret <= 0)
 263                 break;
 264             wrlen += ret;
 265             ctx->copylen -= ret;
 266             in += ret;
 267             inl -= ret;
 268
 269             if (ctx->copylen == 0)
 270                 ctx->state = ASN1_STATE_HEADER;
 271
 272             if (inl == 0)
 273                 goto done;
 274
 275             break;
 276
 277         default:
 278             BIO_clear_retry_flags(b);
 279             return 0;
 280
 281         }
 282
 283     }
 284
 285  done:
 286     BIO_clear_retry_flags(b);
 287     BIO_copy_next_retry(b);
 288
 289     return (wrlen > 0) ? wrlen : ret;
 290
 291 }
 292
 293 static int asn1_bio_flush_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
 294                              asn1_ps_func *cleanup, asn1_bio_state_t next)
 295 {
 296     int ret;
 297     if (ctx->ex_len <= 0)
 298         return 1;
 299     for (;;) {
 300         ret = BIO_write(b->next_bio, ctx->ex_buf + ctx->ex_pos, ctx->ex_len);
 301         if (ret <= 0)
 302             break;
 303         ctx->ex_len -= ret;
 304         if (ctx->ex_len > 0)
 305             ctx->ex_pos += ret;
 306         else {
 307             if (cleanup)
 308                 cleanup(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg);
 309             ctx->state = next;
 310             ctx->ex_pos = 0;
 311             break;
 312         }
 313     }
 314     return ret;
 315 }
 316
 317 static int asn1_bio_setup_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
 318                              asn1_ps_func *setup,
 319                              asn1_bio_state_t ex_state,
 320                              asn1_bio_state_t other_state)
 321 {
 322     if (setup && !setup(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg)) {
 323         BIO_clear_retry_flags(b);
 324         return 0;
 325     }
 326     if (ctx->ex_len > 0)
 327         ctx->state = ex_state;
 328     else
 329         ctx->state = other_state;
 330     return 1;
 331 }
 332
 333 static int asn1_bio_read(BIO *b, char *in, int inl)
 334 {
 335     if (!b->next_bio)
 336         return 0;
 337     return BIO_read(b->next_bio, in, inl);
 338 }
 339
 340 static int asn1_bio_puts(BIO *b, const char *str)
 341 {
 342     return asn1_bio_write(b, str, strlen(str));
 343 }
 344
 345 static int asn1_bio_gets(BIO *b, char *str, int size)
 346 {
 347     if (!b->next_bio)
 348         return 0;
 349     return BIO_gets(b->next_bio, str, size);
 350 }
 351
 352 static long asn1_bio_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
 353 {
 354     if (b->next_bio == NULL)
 355         return (0);
 356     return BIO_callback_ctrl(b->next_bio, cmd, fp);
 357 }
 358
 359 static long asn1_bio_ctrl(BIO *b, int cmd, long arg1, void *arg2)
 360 {
 361     BIO_ASN1_BUF_CTX *ctx;
 362     BIO_ASN1_EX_FUNCS *ex_func;
 363     long ret = 1;
 364     ctx = (BIO_ASN1_BUF_CTX *)b->ptr;
 365     if (ctx == NULL)
 366         return 0;
 367     switch (cmd) {
 368
 369     case BIO_C_SET_PREFIX:
 370         ex_func = arg2;
 371         ctx->prefix = ex_func->ex_func;
 372         ctx->prefix_free = ex_func->ex_free_func;
 373         break;
 374
 375     case BIO_C_GET_PREFIX:
 376         ex_func = arg2;
 377         ex_func->ex_func = ctx->prefix;
 378         ex_func->ex_free_func = ctx->prefix_free;
 379         break;
 380
 381     case BIO_C_SET_SUFFIX:
 382         ex_func = arg2;
 383         ctx->suffix = ex_func->ex_func;
 384         ctx->suffix_free = ex_func->ex_free_func;
 385         break;
 386
 387     case BIO_C_GET_SUFFIX:
 388         ex_func = arg2;
 389         ex_func->ex_func = ctx->suffix;
 390         ex_func->ex_free_func = ctx->suffix_free;
 391         break;
 392
 393     case BIO_C_SET_EX_ARG:
 394         ctx->ex_arg = arg2;
 395         break;
 396
 397     case BIO_C_GET_EX_ARG:
 398         *(void **)arg2 = ctx->ex_arg;
 399         break;
 400
 401     case BIO_CTRL_FLUSH:
 402         if (!b->next_bio)
 403             return 0;
 404
 405         /* Call post function if possible */
 406         if (ctx->state == ASN1_STATE_HEADER) {
 407             if (!asn1_bio_setup_ex(b, ctx, ctx->suffix,
 408                                    ASN1_STATE_POST_COPY, ASN1_STATE_DONE))
 409                 return 0;
 410         }
 411
 412         if (ctx->state == ASN1_STATE_POST_COPY) {
 413             ret = asn1_bio_flush_ex(b, ctx, ctx->suffix_free,
 414                                     ASN1_STATE_DONE);
 415             if (ret <= 0)
 416                 return ret;
 417         }
 418
 419         if (ctx->state == ASN1_STATE_DONE)
 420             return BIO_ctrl(b->next_bio, cmd, arg1, arg2);
 421         else {
 422             BIO_clear_retry_flags(b);
 423             return 0;
 424         }
 425
 426     default:
 427         if (!b->next_bio)
 428             return 0;
 429         return BIO_ctrl(b->next_bio, cmd, arg1, arg2);
 430
 431     }
 432
 433     return ret;
 434 }
 435
 436 static int asn1_bio_set_ex(BIO *b, int cmd,
 437                            asn1_ps_func *ex_func, asn1_ps_func *ex_free_func)
 438 {
 439     BIO_ASN1_EX_FUNCS extmp;
 440     extmp.ex_func = ex_func;
 441     extmp.ex_free_func = ex_free_func;
 442     return BIO_ctrl(b, cmd, 0, &extmp);
 443 }
 444
 445 static int asn1_bio_get_ex(BIO *b, int cmd,
 446                            asn1_ps_func **ex_func,
 447                            asn1_ps_func **ex_free_func)
 448 {
 449     BIO_ASN1_EX_FUNCS extmp;
 450     int ret;
 451     ret = BIO_ctrl(b, cmd, 0, &extmp);
 452     if (ret > 0) {
 453         *ex_func = extmp.ex_func;
 454         *ex_free_func = extmp.ex_free_func;
 455     }
 456     return ret;
 457 }
 458
 459 int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
 460                         asn1_ps_func *prefix_free)
 461 {
 462     return asn1_bio_set_ex(b, BIO_C_SET_PREFIX, prefix, prefix_free);
 463 }
 464
 465 int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
 466                         asn1_ps_func **pprefix_free)
 467 {
 468     return asn1_bio_get_ex(b, BIO_C_GET_PREFIX, pprefix, pprefix_free);
 469 }
 470
 471 int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
 472                         asn1_ps_func *suffix_free)
 473 {
 474     return asn1_bio_set_ex(b, BIO_C_SET_SUFFIX, suffix, suffix_free);
 475 }
 476
 477 int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
 478                         asn1_ps_func **psuffix_free)
 479 {
 480     return asn1_bio_get_ex(b, BIO_C_GET_SUFFIX, psuffix, psuffix_free);
 481 }