crypto/encode_decode/encoder_lib.c

   1 /*
   2  * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include "internal/e_os.h"                /* strcasecmp on Windows */
  11 #include <openssl/core_names.h>
  12 #include <openssl/bio.h>
  13 #include <openssl/encoder.h>
  14 #include <openssl/buffer.h>
  15 #include <openssl/params.h>
  16 #include <openssl/provider.h>
  17 #include <openssl/trace.h>
  18 #include "internal/bio.h"
  19 #include "internal/provider.h"
  20 #include "encoder_local.h"
  21
  22 struct encoder_process_data_st {
  23     OSSL_ENCODER_CTX *ctx;
  24
  25     /* Current BIO */
  26     BIO *bio;
  27
  28     /* Index of the current encoder instance to be processed */
  29     int current_encoder_inst_index;
  30
  31     /* Processing data passed down through recursion */
  32     int level;                   /* Recursion level */
  33     OSSL_ENCODER_INSTANCE *next_encoder_inst;
  34     int count_output_structure;
  35
  36     /* Processing data passed up through recursion */
  37     OSSL_ENCODER_INSTANCE *prev_encoder_inst;
  38     unsigned char *running_output;
  39     size_t running_output_length;
  40     /* Data type = the name of the first succeeding encoder implementation */
  41     const char *data_type;
  42 };
  43
  44 static int encoder_process(struct encoder_process_data_st *data);
  45
  46 int OSSL_ENCODER_to_bio(OSSL_ENCODER_CTX *ctx, BIO *out)
  47 {
  48     struct encoder_process_data_st data;
  49
  50     memset(&data, 0, sizeof(data));
  51     data.ctx = ctx;
  52     data.bio = out;
  53     data.current_encoder_inst_index = OSSL_ENCODER_CTX_get_num_encoders(ctx);
  54
  55     if (data.current_encoder_inst_index == 0) {
  56         ERR_raise_data(ERR_LIB_OSSL_ENCODER, OSSL_ENCODER_R_ENCODER_NOT_FOUND,
  57                        "No encoders were found. For standard encoders you need "
  58                        "at least one of the default or base providers "
  59                        "available. Did you forget to load them?");
  60         return 0;
  61     }
  62
  63     return encoder_process(&data) > 0;
  64 }
  65
  66 #ifndef OPENSSL_NO_STDIO
  67 static BIO *bio_from_file(FILE *fp)
  68 {
  69     BIO *b;
  70
  71     if ((b = BIO_new(BIO_s_file())) == NULL) {
  72         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_BUF_LIB);
  73         return NULL;
  74     }
  75     BIO_set_fp(b, fp, BIO_NOCLOSE);
  76     return b;
  77 }
  78
  79 int OSSL_ENCODER_to_fp(OSSL_ENCODER_CTX *ctx, FILE *fp)
  80 {
  81     BIO *b = bio_from_file(fp);
  82     int ret = 0;
  83
  84     if (b != NULL)
  85         ret = OSSL_ENCODER_to_bio(ctx, b);
  86
  87     BIO_free(b);
  88     return ret;
  89 }
  90 #endif
  91
  92 int OSSL_ENCODER_to_data(OSSL_ENCODER_CTX *ctx, unsigned char **pdata,
  93                          size_t *pdata_len)
  94 {
  95     BIO *out;
  96     BUF_MEM *buf = NULL;
  97     int ret = 0;
  98
  99     if (pdata_len == NULL) {
 100         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
 101         return 0;
 102     }
 103
 104     out = BIO_new(BIO_s_mem());
 105
 106     if (out != NULL
 107         && OSSL_ENCODER_to_bio(ctx, out)
 108         && BIO_get_mem_ptr(out, &buf) > 0) {
 109         ret = 1; /* Hope for the best. A too small buffer will clear this */
 110
 111         if (pdata != NULL && *pdata != NULL) {
 112             if (*pdata_len < buf->length)
 113                 /*
 114                  * It's tempting to do |*pdata_len = (size_t)buf->length|
 115                  * However, it's believed to be confusing more than helpful,
 116                  * so we don't.
 117                  */
 118                 ret = 0;
 119             else
 120                 *pdata_len -= buf->length;
 121         } else {
 122             /* The buffer with the right size is already allocated for us */
 123             *pdata_len = (size_t)buf->length;
 124         }
 125
 126         if (ret) {
 127             if (pdata != NULL) {
 128                 if (*pdata != NULL) {
 129                     memcpy(*pdata, buf->data, buf->length);
 130                     *pdata += buf->length;
 131                 } else {
 132                     /* In this case, we steal the data from BIO_s_mem() */
 133                     *pdata = (unsigned char *)buf->data;
 134                     buf->data = NULL;
 135                 }
 136             }
 137         }
 138     }
 139     BIO_free(out);
 140     return ret;
 141 }
 142
 143 int OSSL_ENCODER_CTX_set_selection(OSSL_ENCODER_CTX *ctx, int selection)
 144 {
 145     if (!ossl_assert(ctx != NULL)) {
 146         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
 147         return 0;
 148     }
 149
 150     if (!ossl_assert(selection != 0)) {
 151         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_INVALID_ARGUMENT);
 152         return 0;
 153     }
 154
 155     ctx->selection = selection;
 156     return 1;
 157 }
 158
 159 int OSSL_ENCODER_CTX_set_output_type(OSSL_ENCODER_CTX *ctx,
 160                                      const char *output_type)
 161 {
 162     if (!ossl_assert(ctx != NULL) || !ossl_assert(output_type != NULL)) {
 163         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
 164         return 0;
 165     }
 166
 167     ctx->output_type = output_type;
 168     return 1;
 169 }
 170
 171 int OSSL_ENCODER_CTX_set_output_structure(OSSL_ENCODER_CTX *ctx,
 172                                           const char *output_structure)
 173 {
 174     if (!ossl_assert(ctx != NULL) || !ossl_assert(output_structure != NULL)) {
 175         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
 176         return 0;
 177     }
 178
 179     ctx->output_structure = output_structure;
 180     return 1;
 181 }
 182
 183 static OSSL_ENCODER_INSTANCE *ossl_encoder_instance_new(OSSL_ENCODER *encoder,
 184                                                         void *encoderctx)
 185 {
 186     OSSL_ENCODER_INSTANCE *encoder_inst = NULL;
 187     const OSSL_PROVIDER *prov;
 188     OSSL_LIB_CTX *libctx;
 189     const OSSL_PROPERTY_LIST *props;
 190     const OSSL_PROPERTY_DEFINITION *prop;
 191
 192     if (!ossl_assert(encoder != NULL)) {
 193         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
 194         return 0;
 195     }
 196
 197     if ((encoder_inst = OPENSSL_zalloc(sizeof(*encoder_inst))) == NULL) {
 198         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);
 199         return 0;
 200     }
 201
 202     if (!OSSL_ENCODER_up_ref(encoder)) {
 203         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_INTERNAL_ERROR);
 204         goto err;
 205     }
 206
 207     prov = OSSL_ENCODER_get0_provider(encoder);
 208     libctx = ossl_provider_libctx(prov);
 209     props = ossl_encoder_parsed_properties(encoder);
 210     if (props == NULL) {
 211         ERR_raise_data(ERR_LIB_OSSL_DECODER, ERR_R_INVALID_PROPERTY_DEFINITION,
 212                        "there are no property definitions with encoder %s",
 213                        OSSL_ENCODER_get0_name(encoder));
 214         goto err;
 215     }
 216
 217     /* The "output" property is mandatory */
 218     prop = ossl_property_find_property(props, libctx, "output");
 219     encoder_inst->output_type = ossl_property_get_string_value(libctx, prop);
 220     if (encoder_inst->output_type == NULL) {
 221         ERR_raise_data(ERR_LIB_OSSL_DECODER, ERR_R_INVALID_PROPERTY_DEFINITION,
 222                        "the mandatory 'output' property is missing "
 223                        "for encoder %s (properties: %s)",
 224                        OSSL_ENCODER_get0_name(encoder),
 225                        OSSL_ENCODER_get0_properties(encoder));
 226         goto err;
 227     }
 228
 229     /* The "structure" property is optional */
 230     prop = ossl_property_find_property(props, libctx, "structure");
 231     if (prop != NULL)
 232         encoder_inst->output_structure
 233             = ossl_property_get_string_value(libctx, prop);
 234
 235     encoder_inst->encoder = encoder;
 236     encoder_inst->encoderctx = encoderctx;
 237     return encoder_inst;
 238  err:
 239     ossl_encoder_instance_free(encoder_inst);
 240     return NULL;
 241 }
 242
 243 void ossl_encoder_instance_free(OSSL_ENCODER_INSTANCE *encoder_inst)
 244 {
 245     if (encoder_inst != NULL) {
 246         if (encoder_inst->encoder != NULL)
 247             encoder_inst->encoder->freectx(encoder_inst->encoderctx);
 248         encoder_inst->encoderctx = NULL;
 249         OSSL_ENCODER_free(encoder_inst->encoder);
 250         encoder_inst->encoder = NULL;
 251         OPENSSL_free(encoder_inst);
 252     }
 253 }
 254
 255 static int ossl_encoder_ctx_add_encoder_inst(OSSL_ENCODER_CTX *ctx,
 256                                              OSSL_ENCODER_INSTANCE *ei)
 257 {
 258     int ok;
 259
 260     if (ctx->encoder_insts == NULL
 261         && (ctx->encoder_insts =
 262             sk_OSSL_ENCODER_INSTANCE_new_null()) == NULL) {
 263         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);
 264         return 0;
 265     }
 266
 267     ok = (sk_OSSL_ENCODER_INSTANCE_push(ctx->encoder_insts, ei) > 0);
 268     if (ok) {
 269         OSSL_TRACE_BEGIN(ENCODER) {
 270             BIO_printf(trc_out,
 271                        "(ctx %p) Added encoder instance %p (encoder %p):\n"
 272                        "    %s with %s\n",
 273                        (void *)ctx, (void *)ei, (void *)ei->encoder,
 274                        OSSL_ENCODER_get0_name(ei->encoder),
 275                        OSSL_ENCODER_get0_properties(ei->encoder));
 276         } OSSL_TRACE_END(ENCODER);
 277     }
 278     return ok;
 279 }
 280
 281 int OSSL_ENCODER_CTX_add_encoder(OSSL_ENCODER_CTX *ctx, OSSL_ENCODER *encoder)
 282 {
 283     OSSL_ENCODER_INSTANCE *encoder_inst = NULL;
 284     const OSSL_PROVIDER *prov = NULL;
 285     void *encoderctx = NULL;
 286     void *provctx = NULL;
 287
 288     if (!ossl_assert(ctx != NULL) || !ossl_assert(encoder != NULL)) {
 289         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
 290         return 0;
 291     }
 292
 293     prov = OSSL_ENCODER_get0_provider(encoder);
 294     provctx = OSSL_PROVIDER_get0_provider_ctx(prov);
 295
 296     if ((encoderctx = encoder->newctx(provctx)) == NULL
 297         || (encoder_inst =
 298             ossl_encoder_instance_new(encoder, encoderctx)) == NULL)
 299         goto err;
 300     /* Avoid double free of encoderctx on further errors */
 301     encoderctx = NULL;
 302
 303     if (!ossl_encoder_ctx_add_encoder_inst(ctx, encoder_inst))
 304         goto err;
 305
 306     return 1;
 307  err:
 308     ossl_encoder_instance_free(encoder_inst);
 309     if (encoderctx != NULL)
 310         encoder->freectx(encoderctx);
 311     return 0;
 312 }
 313
 314 int OSSL_ENCODER_CTX_add_extra(OSSL_ENCODER_CTX *ctx,
 315                                OSSL_LIB_CTX *libctx, const char *propq)
 316 {
 317     return 1;
 318 }
 319
 320 int OSSL_ENCODER_CTX_get_num_encoders(OSSL_ENCODER_CTX *ctx)
 321 {
 322     if (ctx == NULL || ctx->encoder_insts == NULL)
 323         return 0;
 324     return sk_OSSL_ENCODER_INSTANCE_num(ctx->encoder_insts);
 325 }
 326
 327 int OSSL_ENCODER_CTX_set_construct(OSSL_ENCODER_CTX *ctx,
 328                                    OSSL_ENCODER_CONSTRUCT *construct)
 329 {
 330     if (!ossl_assert(ctx != NULL)) {
 331         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
 332         return 0;
 333     }
 334     ctx->construct = construct;
 335     return 1;
 336 }
 337
 338 int OSSL_ENCODER_CTX_set_construct_data(OSSL_ENCODER_CTX *ctx,
 339                                         void *construct_data)
 340 {
 341     if (!ossl_assert(ctx != NULL)) {
 342         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
 343         return 0;
 344     }
 345     ctx->construct_data = construct_data;
 346     return 1;
 347 }
 348
 349 int OSSL_ENCODER_CTX_set_cleanup(OSSL_ENCODER_CTX *ctx,
 350                                  OSSL_ENCODER_CLEANUP *cleanup)
 351 {
 352     if (!ossl_assert(ctx != NULL)) {
 353         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
 354         return 0;
 355     }
 356     ctx->cleanup = cleanup;
 357     return 1;
 358 }
 359
 360 OSSL_ENCODER *
 361 OSSL_ENCODER_INSTANCE_get_encoder(OSSL_ENCODER_INSTANCE *encoder_inst)
 362 {
 363     if (encoder_inst == NULL)
 364         return NULL;
 365     return encoder_inst->encoder;
 366 }
 367
 368 void *
 369 OSSL_ENCODER_INSTANCE_get_encoder_ctx(OSSL_ENCODER_INSTANCE *encoder_inst)
 370 {
 371     if (encoder_inst == NULL)
 372         return NULL;
 373     return encoder_inst->encoderctx;
 374 }
 375
 376 const char *
 377 OSSL_ENCODER_INSTANCE_get_output_type(OSSL_ENCODER_INSTANCE *encoder_inst)
 378 {
 379     if (encoder_inst == NULL)
 380         return NULL;
 381     return encoder_inst->output_type;
 382 }
 383
 384 const char *
 385 OSSL_ENCODER_INSTANCE_get_output_structure(OSSL_ENCODER_INSTANCE *encoder_inst)
 386 {
 387     if (encoder_inst == NULL)
 388         return NULL;
 389     return encoder_inst->output_structure;
 390 }
 391
 392 static int encoder_process(struct encoder_process_data_st *data)
 393 {
 394     OSSL_ENCODER_INSTANCE *current_encoder_inst = NULL;
 395     OSSL_ENCODER *current_encoder = NULL;
 396     OSSL_ENCODER_CTX *current_encoder_ctx = NULL;
 397     BIO *allocated_out = NULL;
 398     const void *original_data = NULL;
 399     OSSL_PARAM abstract[10];
 400     const OSSL_PARAM *current_abstract = NULL;
 401     int i;
 402     int ok = -1;  /* -1 signifies that the lookup loop gave nothing */
 403     int top = 0;
 404
 405     if (data->next_encoder_inst == NULL) {
 406         /* First iteration, where we prepare for what is to come */
 407
 408         data->count_output_structure =
 409             data->ctx->output_structure == NULL ? -1 : 0;
 410         top = 1;
 411     }
 412
 413     for (i = data->current_encoder_inst_index; i-- > 0;) {
 414         OSSL_ENCODER *next_encoder = NULL;
 415         const char *current_output_type;
 416         const char *current_output_structure;
 417         struct encoder_process_data_st new_data;
 418
 419         if (!top)
 420             next_encoder =
 421                 OSSL_ENCODER_INSTANCE_get_encoder(data->next_encoder_inst);
 422
 423         current_encoder_inst =
 424             sk_OSSL_ENCODER_INSTANCE_value(data->ctx->encoder_insts, i);
 425         current_encoder =
 426             OSSL_ENCODER_INSTANCE_get_encoder(current_encoder_inst);
 427         current_encoder_ctx =
 428             OSSL_ENCODER_INSTANCE_get_encoder_ctx(current_encoder_inst);
 429         current_output_type =
 430             OSSL_ENCODER_INSTANCE_get_output_type(current_encoder_inst);
 431         current_output_structure =
 432             OSSL_ENCODER_INSTANCE_get_output_structure(current_encoder_inst);
 433         memset(&new_data, 0, sizeof(new_data));
 434         new_data.ctx = data->ctx;
 435         new_data.current_encoder_inst_index = i;
 436         new_data.next_encoder_inst = current_encoder_inst;
 437         new_data.count_output_structure = data->count_output_structure;
 438         new_data.level = data->level + 1;
 439
 440         OSSL_TRACE_BEGIN(ENCODER) {
 441             BIO_printf(trc_out,
 442                        "[%d] (ctx %p) Considering encoder instance %p (encoder %p)\n",
 443                        data->level, (void *)data->ctx,
 444                        (void *)current_encoder_inst, (void *)current_encoder);
 445         } OSSL_TRACE_END(ENCODER);
 446
 447         /*
 448          * If this is the top call, we check if the output type of the current
 449          * encoder matches the desired output type.
 450          * If this isn't the top call, i.e. this is deeper in the recursion,
 451          * we instead check if the output type of the current encoder matches
 452          * the name of the next encoder (the one found by the parent call).
 453          */
 454         if (top) {
 455             if (data->ctx->output_type != NULL
 456                 && strcasecmp(current_output_type,
 457                               data->ctx->output_type) != 0) {
 458                 OSSL_TRACE_BEGIN(ENCODER) {
 459                     BIO_printf(trc_out,
 460                                "[%d]    Skipping because current encoder output type (%s) != desired output type (%s)\n",
 461                                data->level,
 462                                current_output_type, data->ctx->output_type);
 463                 } OSSL_TRACE_END(ENCODER);
 464                 continue;
 465             }
 466         } else {
 467             if (!OSSL_ENCODER_is_a(next_encoder, current_output_type)) {
 468                 OSSL_TRACE_BEGIN(ENCODER) {
 469                     BIO_printf(trc_out,
 470                                "[%d]    Skipping because current encoder output type (%s) != name of encoder %p\n",
 471                                data->level,
 472                                current_output_type, (void *)next_encoder);
 473                 } OSSL_TRACE_END(ENCODER);
 474                 continue;
 475             }
 476         }
 477
 478         /*
 479          * If the caller and the current encoder specify an output structure,
 480          * Check if they match.  If they do, count the match, otherwise skip
 481          * the current encoder.
 482          */
 483         if (data->ctx->output_structure != NULL
 484             && current_output_structure != NULL) {
 485             if (strcasecmp(data->ctx->output_structure,
 486                            current_output_structure) != 0) {
 487                 OSSL_TRACE_BEGIN(ENCODER) {
 488                     BIO_printf(trc_out,
 489                                "[%d]    Skipping because current encoder output structure (%s) != ctx output structure (%s)\n",
 490                                data->level,
 491                                current_output_structure,
 492                                data->ctx->output_structure);
 493                 } OSSL_TRACE_END(ENCODER);
 494                 continue;
 495             }
 496
 497             data->count_output_structure++;
 498         }
 499
 500         /*
 501          * Recurse to process the encoder implementations before the current
 502          * one.
 503          */
 504         ok = encoder_process(&new_data);
 505
 506         data->prev_encoder_inst = new_data.prev_encoder_inst;
 507         data->running_output = new_data.running_output;
 508         data->running_output_length = new_data.running_output_length;
 509
 510         /*
 511          * ok == -1     means that the recursion call above gave no further
 512          *              encoders, and that the one we're currently at should
 513          *              be tried.
 514          * ok == 0      means that something failed in the recursion call
 515          *              above, making the result unsuitable for a chain.
 516          *              In this case, we simply continue to try finding a
 517          *              suitable encoder at this recursion level.
 518          * ok == 1      means that the recursion call was successful, and we
 519          *              try to use the result at this recursion level.
 520          */
 521         if (ok != 0)
 522             break;
 523
 524         OSSL_TRACE_BEGIN(ENCODER) {
 525             BIO_printf(trc_out,
 526                        "[%d]    Skipping because recursion level %d failed\n",
 527                        data->level, new_data.level);
 528         } OSSL_TRACE_END(ENCODER);
 529     }
 530
 531     /*
 532      * If |i < 0|, we didn't find any useful encoder in this recursion, so
 533      * we do the rest of the process only if |i >= 0|.
 534      */
 535     if (i < 0) {
 536         ok = -1;
 537
 538         OSSL_TRACE_BEGIN(ENCODER) {
 539             BIO_printf(trc_out,
 540                        "[%d] (ctx %p) No suitable encoder found\n",
 541                        data->level, (void *)data->ctx);
 542         } OSSL_TRACE_END(ENCODER);
 543     } else {
 544         /* Preparations */
 545
 546         switch (ok) {
 547         case 0:
 548             break;
 549         case -1:
 550             /*
 551              * We have reached the beginning of the encoder instance sequence,
 552              * so we prepare the object to be encoded.
 553              */
 554
 555             /*
 556              * |data->count_output_structure| is one of these values:
 557              *
 558              * -1       There is no desired output structure
 559              *  0       There is a desired output structure, and it wasn't
 560              *          matched by any of the encoder instances that were
 561              *          considered
 562              * >0       There is a desired output structure, and at least one
 563              *          of the encoder instances matched it
 564              */
 565             if (data->count_output_structure == 0)
 566                 return 0;
 567
 568             original_data =
 569                 data->ctx->construct(current_encoder_inst,
 570                                      data->ctx->construct_data);
 571
 572             /* Also set the data type, using the encoder implementation name */
 573             data->data_type = OSSL_ENCODER_get0_name(current_encoder);
 574
 575             /* Assume that the constructor recorded an error */
 576             if (original_data != NULL)
 577                 ok = 1;
 578             else
 579                 ok = 0;
 580             break;
 581         case 1:
 582             if (!ossl_assert(data->running_output != NULL)) {
 583                 ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_INTERNAL_ERROR);
 584                 ok = 0;
 585                 break;
 586             }
 587
 588             {
 589                 /*
 590                  * Create an object abstraction from the latest output, which
 591                  * was stolen from the previous round.
 592                  */
 593
 594                 OSSL_PARAM *abstract_p = abstract;
 595                 const char *prev_output_structure =
 596                     OSSL_ENCODER_INSTANCE_get_output_structure(data->prev_encoder_inst);
 597
 598                 *abstract_p++ =
 599                     OSSL_PARAM_construct_utf8_string(OSSL_OBJECT_PARAM_DATA_TYPE,
 600                                                      (char *)data->data_type, 0);
 601                 if (prev_output_structure != NULL)
 602                     *abstract_p++ =
 603                         OSSL_PARAM_construct_utf8_string(OSSL_OBJECT_PARAM_DATA_STRUCTURE,
 604                                                          (char *)prev_output_structure,
 605                                                          0);
 606                 *abstract_p++ =
 607                     OSSL_PARAM_construct_octet_string(OSSL_OBJECT_PARAM_DATA,
 608                                                       data->running_output,
 609                                                       data->running_output_length);
 610                 *abstract_p = OSSL_PARAM_construct_end();
 611                 current_abstract = abstract;
 612             }
 613             break;
 614         }
 615
 616         /* Calling the encoder implementation */
 617
 618         if (ok) {
 619             OSSL_CORE_BIO *cbio = NULL;
 620             BIO *current_out = NULL;
 621
 622             /*
 623              * If we're at the last encoder instance to use, we're setting up
 624              * final output.  Otherwise, set up an intermediary memory output.
 625              */
 626             if (top)
 627                 current_out = data->bio;
 628             else if ((current_out = allocated_out = BIO_new(BIO_s_mem()))
 629                      == NULL)
 630                 ok = 0;     /* Assume BIO_new() recorded an error */
 631
 632             if (ok)
 633                 ok = (cbio = ossl_core_bio_new_from_bio(current_out)) != NULL;
 634             if (ok) {
 635                 ok = current_encoder->encode(current_encoder_ctx, cbio,
 636                                              original_data, current_abstract,
 637                                              data->ctx->selection,
 638                                              ossl_pw_passphrase_callback_enc,
 639                                              &data->ctx->pwdata);
 640                 OSSL_TRACE_BEGIN(ENCODER) {
 641                     BIO_printf(trc_out,
 642                                "[%d] (ctx %p) Running encoder instance %p => %d\n",
 643                                data->level, (void *)data->ctx,
 644                                (void *)current_encoder_inst, ok);
 645                 } OSSL_TRACE_END(ENCODER);
 646             }
 647
 648             ossl_core_bio_free(cbio);
 649             data->prev_encoder_inst = current_encoder_inst;
 650         }
 651     }
 652
 653     /* Cleanup and collecting the result */
 654
 655     OPENSSL_free(data->running_output);
 656     data->running_output = NULL;
 657
 658     /*
 659      * Steal the output from the BIO_s_mem, if we did allocate one.
 660      * That'll be the data for an object abstraction in the next round.
 661      */
 662     if (allocated_out != NULL) {
 663         BUF_MEM *buf;
 664
 665         BIO_get_mem_ptr(allocated_out, &buf);
 666         data->running_output = (unsigned char *)buf->data;
 667         data->running_output_length = buf->length;
 668         memset(buf, 0, sizeof(*buf));
 669     }
 670
 671     BIO_free(allocated_out);
 672     if (original_data != NULL)
 673         data->ctx->cleanup(data->ctx->construct_data);
 674     return ok;
 675 }