git.sur5r.net Git - bacula/bacula/blob - bacula/src/filed/restore.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2010 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version three of the GNU Affero General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU Affero General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  *  Bacula File Daemon  restore.c Restorefiles.
  30  *
  31  *    Kern Sibbald, November MM
  32  *
  33  */
  34
  35 #include "bacula.h"
  36 #include "filed.h"
  37 #include "restore.h"
  38
  39 #ifdef HAVE_DARWIN_OS
  40 #include <sys/attr.h>
  41 const bool have_darwin_os = true;
  42 #else
  43 const bool have_darwin_os = false;
  44 #endif
  45
  46 #if defined(HAVE_CRYPTO)
  47 const bool have_crypto = true;
  48 #else
  49 const bool have_crypto = false;
  50 #endif
  51
  52 #if defined(HAVE_ACL)
  53 const bool have_acl = true;
  54 #else
  55 const bool have_acl = false;
  56 #endif
  57
  58 #ifdef HAVE_SHA2
  59 const bool have_sha2 = true;
  60 #else
  61 const bool have_sha2 = false;
  62 #endif
  63
  64 #if defined(HAVE_XATTR)
  65 const bool have_xattr = true;
  66 #else
  67 const bool have_xattr = false;
  68 #endif
  69
  70 /*
  71  * Data received from Storage Daemon
  72  */
  73 static char rec_header[] = "rechdr %ld %ld %ld %ld %ld";
  74
  75 /*
  76  * Forward referenced functions
  77  */
  78 #if   defined(HAVE_LIBZ)
  79 static const char *zlib_strerror(int stat);
  80 const bool have_libz = true;
  81 #else
  82 const bool have_libz = false;
  83 #endif
  84
  85 static void deallocate_cipher(r_ctx &rctx);
  86 static void deallocate_fork_cipher(r_ctx &rctx);
  87 static void free_signature(r_ctx &rctx);
  88 static void free_session(r_ctx &rctx);
  89 static void close_previous_stream(r_ctx &rctx);
  90
  91 static bool verify_signature(JCR *jcr, r_ctx &rctx);
  92 int32_t extract_data(JCR *jcr, BFILE *bfd, POOLMEM *buf, int32_t buflen,
  93                      uint64_t *addr, int flags, RESTORE_CIPHER_CTX *cipher_ctx);
  94 bool flush_cipher(JCR *jcr, BFILE *bfd, uint64_t *addr, int flags,
  95                   RESTORE_CIPHER_CTX *cipher_ctx);
  96
  97 /*
  98  * Close a bfd check that we are at the expected file offset.
  99  * Makes use of some code from set_attributes().
 100  */
 101 static int bclose_chksize(JCR *jcr, BFILE *bfd, boffset_t osize)
 102 {
 103    char ec1[50], ec2[50];
 104    boffset_t fsize;
 105
 106    fsize = blseek(bfd, 0, SEEK_CUR);
 107    bclose(bfd);
 108    if (fsize > 0 && fsize != osize) {
 109       Qmsg3(jcr, M_ERROR, 0, _("Size of data or stream of %s not correct. Original %s, restored %s.\n"),
 110             jcr->last_fname, edit_uint64(osize, ec1),
 111             edit_uint64(fsize, ec2));
 112       return -1;
 113    }
 114    return 0;
 115 }
 116
 117 #ifdef HAVE_DARWIN_OS
 118 bool restore_finderinfo(JCR *jcr, POOLMEM *buf, int32_t buflen)
 119 {
 120    struct attrlist attrList;
 121
 122    memset(&attrList, 0, sizeof(attrList));
 123    attrList.bitmapcount = ATTR_BIT_MAP_COUNT;
 124    attrList.commonattr = ATTR_CMN_FNDRINFO;
 125
 126    Dmsg0(130, "Restoring Finder Info\n");
 127    jcr->ff->flags |= FO_HFSPLUS;
 128    if (buflen != 32) {
 129       Jmsg(jcr, M_ERROR, 0, _("Invalid length of Finder Info (got %d, not 32)\n"), buflen);
 130       return false;
 131    }
 132
 133    if (setattrlist(jcr->last_fname, &attrList, buf, buflen, 0) != 0) {
 134       Jmsg(jcr, M_ERROR, 0, _("Could not set Finder Info on %s\n"), jcr->last_fname);
 135       return false;
 136    }
 137
 138    return true;
 139 }
 140 #else
 141 bool restore_finderinfo(JCR *jcr, POOLMEM *buf, int32_t buflen)
 142 {
 143    return true;
 144 }
 145 #endif
 146
 147 /*
 148  * Restore the requested files.
 149  */
 150 void do_restore(JCR *jcr)
 151 {
 152    BSOCK *sd;
 153    uint32_t VolSessionId, VolSessionTime;
 154    int32_t file_index;
 155    char ec1[50];                      /* Buffer printing huge values */
 156    uint32_t buf_size;                 /* client buffer size */
 157    int stat;
 158    intmax_t rsrc_len = 0;             /* Original length of resource fork */
 159    r_ctx rctx;
 160    ATTR *attr;
 161    /* ***FIXME*** make configurable */
 162    crypto_digest_t signing_algorithm = have_sha2 ?
 163                                        CRYPTO_DIGEST_SHA256 : CRYPTO_DIGEST_SHA1;
 164    memset(&rctx, 0, sizeof(rctx));
 165    rctx.jcr = jcr;
 166
 167    /*
 168     * The following variables keep track of "known unknowns"
 169     */
 170    int non_support_data = 0;
 171    int non_support_attr = 0;
 172    int non_support_rsrc = 0;
 173    int non_support_finfo = 0;
 174    int non_support_acl = 0;
 175    int non_support_progname = 0;
 176    int non_support_crypto = 0;
 177    int non_support_xattr = 0;
 178
 179    sd = jcr->store_bsock;
 180    set_jcr_job_status(jcr, JS_Running);
 181
 182    LockRes();
 183    CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);
 184    UnlockRes();
 185    if (client) {
 186       buf_size = client->max_network_buffer_size;
 187    } else {
 188       buf_size = 0;                   /* use default */
 189    }
 190    if (!bnet_set_buffer_size(sd, buf_size, BNET_SETBUF_WRITE)) {
 191       set_jcr_job_status(jcr, JS_ErrorTerminated);
 192       return;
 193    }
 194    jcr->buf_size = sd->msglen;
 195
 196    /*
 197     * St Bernard code goes here if implemented -- see end of file
 198     */
 199
 200    if (have_libz) {
 201       uint32_t compress_buf_size = jcr->buf_size + 12 + ((jcr->buf_size+999) / 1000) + 100;
 202       jcr->compress_buf = get_memory(compress_buf_size);
 203       jcr->compress_buf_size = compress_buf_size;
 204    }
 205
 206    if (have_crypto) {
 207       rctx.cipher_ctx.buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
 208       if (have_darwin_os) {
 209          rctx.fork_cipher_ctx.buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
 210       }
 211    }
 212
 213    /*
 214     * Get a record from the Storage daemon. We are guaranteed to
 215     *   receive records in the following order:
 216     *   1. Stream record header
 217     *   2. Stream data (one or more of the following in the order given)
 218     *        a. Attributes (Unix or Win32)
 219     *        b. Possibly stream encryption session data (e.g., symmetric session key)
 220     *        c. File data for the file
 221     *        d. Alternate data stream (e.g. Resource Fork)
 222     *        e. Finder info
 223     *        f. ACLs
 224     *        g. XATTRs
 225     *        h. Possibly a cryptographic signature
 226     *        i. Possibly MD5 or SHA1 record
 227     *   3. Repeat step 1
 228     *
 229     * NOTE: We keep track of two bacula file descriptors:
 230     *   1. bfd for file data.
 231     *      This fd is opened for non empty files when an attribute stream is
 232     *      encountered and closed when we find the next attribute stream.
 233     *   2. fork_bfd for alternate data streams
 234     *      This fd is opened every time we encounter a new alternate data
 235     *      stream for the current file. When we find any other stream, we
 236     *      close it again.
 237     *      The expected size of the stream, fork_len, should be set when
 238     *      opening the fd.
 239     *   3. Not all the stream data records are required -- e.g. if there
 240     *      is no fork, there is no alternate data stream, no ACL, ...
 241     */
 242    binit(&rctx.bfd);
 243    binit(&rctx.forkbfd);
 244    attr = rctx.attr = new_attr(jcr);
 245    if (have_acl) {
 246       jcr->acl_data = (acl_data_t *)malloc(sizeof(acl_data_t));
 247       memset((caddr_t)jcr->acl_data, 0, sizeof(acl_data_t));
 248       jcr->acl_data->content = get_pool_memory(PM_MESSAGE);
 249    }
 250    if (have_xattr) {
 251       jcr->xattr_data = (xattr_data_t *)malloc(sizeof(xattr_data_t));
 252       memset((caddr_t)jcr->xattr_data, 0, sizeof(xattr_data_t));
 253       jcr->xattr_data->content = get_pool_memory(PM_MESSAGE);
 254    }
 255
 256    while (bget_msg(sd) >= 0 && !job_canceled(jcr)) {
 257       /*
 258        * Remember previous stream type
 259        */
 260       rctx.prev_stream = rctx.stream;
 261
 262       /*
 263        * First we expect a Stream Record Header
 264        */
 265       if (sscanf(sd->msg, rec_header, &VolSessionId, &VolSessionTime, &file_index,
 266           &rctx.full_stream, &rctx.size) != 5) {
 267          Jmsg1(jcr, M_FATAL, 0, _("Record header scan error: %s\n"), sd->msg);
 268          goto bail_out;
 269       }
 270       /* Strip off new stream high bits */
 271       rctx.stream = rctx.full_stream & STREAMMASK_TYPE;
 272       Dmsg5(150, "Got hdr: Files=%d FilInx=%d size=%d Stream=%d, %s.\n",
 273             jcr->JobFiles, file_index, rctx.size, rctx.stream, stream_to_ascii(rctx.stream));
 274
 275       /*
 276        * Now we expect the Stream Data
 277        */
 278       if (bget_msg(sd) < 0) {
 279          Jmsg1(jcr, M_FATAL, 0, _("Data record error. ERR=%s\n"), sd->bstrerror());
 280          goto bail_out;
 281       }
 282       if (rctx.size != (uint32_t)sd->msglen) {
 283          Jmsg2(jcr, M_FATAL, 0, _("Actual data size %d not same as header %d\n"),
 284                sd->msglen, rctx.size);
 285          Dmsg2(50, "Actual data size %d not same as header %d\n",
 286                sd->msglen, rctx.size);
 287          goto bail_out;
 288       }
 289       Dmsg3(130, "Got stream: %s len=%d extract=%d\n", stream_to_ascii(rctx.stream),
 290             sd->msglen, rctx.extract);
 291
 292       /*
 293        * If we change streams, close and reset alternate data streams
 294        */
 295       if (rctx.prev_stream != rctx.stream) {
 296          if (is_bopen(&rctx.forkbfd)) {
 297             deallocate_fork_cipher(rctx);
 298             bclose_chksize(jcr, &rctx.forkbfd, rctx.fork_size);
 299          }
 300          /*
 301           * Use an impossible value and set a proper one below
 302           */
 303          rctx.fork_size = -1;
 304          rctx.fork_addr = 0;
 305       }
 306
 307       /*
 308        * File Attributes stream
 309        */
 310       switch (rctx.stream) {
 311       case STREAM_UNIX_ATTRIBUTES:
 312       case STREAM_UNIX_ATTRIBUTES_EX:
 313          /*
 314           * if any previous stream open, close it
 315           */
 316          close_previous_stream(rctx);
 317
 318          /*
 319           * TODO: manage deleted files
 320           */
 321          if (rctx.type == FT_DELETED) { /* deleted file */
 322             continue;
 323          }
 324          /*
 325           * Restore objects should be ignored here -- they are
 326           * returned at the beginning of the restore.
 327           */
 328          if (rctx.type == FT_RESTORE_FIRST) {
 329             continue;
 330          }
 331
 332          /*
 333           * Unpack attributes and do sanity check them
 334           */
 335          if (!unpack_attributes_record(jcr, rctx.stream, sd->msg, sd->msglen, attr)) {
 336             goto bail_out;
 337          }
 338
 339          Dmsg3(100, "File %s\nattrib=%s\nattribsEx=%s\n", attr->fname,
 340                attr->attr, attr->attrEx);
 341          Dmsg3(100, "=== msglen=%d attrExlen=%d msg=%s\n", sd->msglen,
 342                strlen(attr->attrEx), sd->msg);
 343
 344          attr->data_stream = decode_stat(attr->attr, &attr->statp, &attr->LinkFI);
 345
 346          if (!is_restore_stream_supported(attr->data_stream)) {
 347             if (!non_support_data++) {
 348                Jmsg(jcr, M_ERROR, 0, _("%s stream not supported on this Client.\n"),
 349                   stream_to_ascii(attr->data_stream));
 350             }
 351             continue;
 352          }
 353
 354          build_attr_output_fnames(jcr, attr);
 355
 356          /*
 357           * Try to actually create the file, which returns a status telling
 358           * us if we need to extract or not.
 359           */
 360          jcr->num_files_examined++;
 361          rctx.extract = false;
 362          if (jcr->plugin) {
 363             stat = plugin_create_file(jcr, attr, &rctx.bfd, jcr->replace);
 364          } else {
 365             stat = create_file(jcr, attr, &rctx.bfd, jcr->replace);
 366          }
 367          jcr->lock();
 368          pm_strcpy(jcr->last_fname, attr->ofname);
 369          jcr->last_type = attr->type;
 370          jcr->unlock();
 371          Dmsg2(130, "Outfile=%s create_file stat=%d\n", attr->ofname, stat);
 372          switch (stat) {
 373          case CF_ERROR:
 374          case CF_SKIP:
 375             pm_strcpy(jcr->last_fname, attr->ofname);
 376             jcr->last_type = attr->type;
 377             break;
 378          case CF_EXTRACT:
 379             /*
 380              * File created and we expect file data
 381              */
 382             rctx.extract = true;
 383             /*
 384              * FALLTHROUGH
 385              */
 386          case CF_CREATED:
 387             /*
 388              * File created, but there is no content
 389              */
 390             rctx.fileAddr = 0;
 391             print_ls_output(jcr, attr);
 392
 393             if (have_darwin_os) {
 394                /*
 395                 * Only restore the resource fork for regular files
 396                 */
 397                from_base64(&rsrc_len, attr->attrEx);
 398                if (attr->type == FT_REG && rsrc_len > 0) {
 399                   rctx.extract = true;
 400                }
 401
 402                /*
 403                 * Count the resource forks not as regular files being restored.
 404                 */
 405                if (rsrc_len == 0) {
 406                   jcr->JobFiles++;
 407                }
 408             } else {
 409                jcr->JobFiles++;
 410             }
 411
 412             if (!rctx.extract) {
 413                /*
 414                 * set attributes now because file will not be extracted
 415                 */
 416                if (jcr->plugin) {
 417                   plugin_set_attributes(jcr, attr, &rctx.bfd);
 418                } else {
 419                   set_attributes(jcr, attr, &rctx.bfd);
 420                }
 421             }
 422             break;
 423          }
 424          break;
 425
 426       /*
 427        * Data stream
 428        */
 429       case STREAM_ENCRYPTED_SESSION_DATA:
 430          crypto_error_t cryptoerr;
 431
 432          /*
 433           * Is this an unexpected session data entry?
 434           */
 435          if (rctx.cs) {
 436             Jmsg0(jcr, M_ERROR, 0, _("Unexpected cryptographic session data stream.\n"));
 437             rctx.extract = false;
 438             bclose(&rctx.bfd);
 439             continue;
 440          }
 441
 442          /*
 443           * Do we have any keys at all?
 444           */
 445          if (!jcr->crypto.pki_recipients) {
 446             Jmsg(jcr, M_ERROR, 0, _("No private decryption keys have been defined to decrypt encrypted backup data.\n"));
 447             rctx.extract = false;
 448             bclose(&rctx.bfd);
 449             break;
 450          }
 451
 452          if (jcr->crypto.digest) {
 453             crypto_digest_free(jcr->crypto.digest);
 454          }
 455          jcr->crypto.digest = crypto_digest_new(jcr, signing_algorithm);
 456          if (!jcr->crypto.digest) {
 457             Jmsg0(jcr, M_FATAL, 0, _("Could not create digest.\n"));
 458             rctx.extract = false;
 459             bclose(&rctx.bfd);
 460             break;
 461          }
 462
 463          /*
 464           * Decode and save session keys.
 465           */
 466          cryptoerr = crypto_session_decode((uint8_t *)sd->msg, (uint32_t)sd->msglen,
 467                         jcr->crypto.pki_recipients, &rctx.cs);
 468          switch(cryptoerr) {
 469          case CRYPTO_ERROR_NONE:
 470             /*
 471              * Success
 472              */
 473             break;
 474          case CRYPTO_ERROR_NORECIPIENT:
 475             Jmsg(jcr, M_ERROR, 0, _("Missing private key required to decrypt encrypted backup data.\n"));
 476             break;
 477          case CRYPTO_ERROR_DECRYPTION:
 478             Jmsg(jcr, M_ERROR, 0, _("Decrypt of the session key failed.\n"));
 479             break;
 480          default:
 481             /*
 482              * Shouldn't happen
 483              */
 484             Jmsg1(jcr, M_ERROR, 0, _("An error occurred while decoding encrypted session data stream: %s\n"), crypto_strerror(cryptoerr));
 485             break;
 486          }
 487
 488          if (cryptoerr != CRYPTO_ERROR_NONE) {
 489             rctx.extract = false;
 490             bclose(&rctx.bfd);
 491             continue;
 492          }
 493
 494          break;
 495
 496       case STREAM_FILE_DATA:
 497       case STREAM_SPARSE_DATA:
 498       case STREAM_WIN32_DATA:
 499       case STREAM_GZIP_DATA:
 500       case STREAM_SPARSE_GZIP_DATA:
 501       case STREAM_WIN32_GZIP_DATA:
 502       case STREAM_ENCRYPTED_FILE_DATA:
 503       case STREAM_ENCRYPTED_WIN32_DATA:
 504       case STREAM_ENCRYPTED_FILE_GZIP_DATA:
 505       case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
 506          /*
 507           * Force an expected, consistent stream type here
 508           */
 509          if (rctx.extract && (rctx.prev_stream == rctx.stream
 510                          || rctx.prev_stream == STREAM_UNIX_ATTRIBUTES
 511                          || rctx.prev_stream == STREAM_UNIX_ATTRIBUTES_EX
 512                          || rctx.prev_stream == STREAM_ENCRYPTED_SESSION_DATA)) {
 513             rctx.flags = 0;
 514
 515             if (rctx.stream == STREAM_SPARSE_DATA ||
 516                 rctx.stream == STREAM_SPARSE_GZIP_DATA) {
 517                rctx.flags |= FO_SPARSE;
 518             }
 519
 520             if (rctx.stream == STREAM_GZIP_DATA
 521                   || rctx.stream == STREAM_SPARSE_GZIP_DATA
 522                   || rctx.stream == STREAM_WIN32_GZIP_DATA
 523                   || rctx.stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
 524                   || rctx.stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
 525                rctx.flags |= FO_GZIP;
 526             }
 527
 528             if (rctx.stream == STREAM_ENCRYPTED_FILE_DATA
 529                   || rctx.stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
 530                   || rctx.stream == STREAM_ENCRYPTED_WIN32_DATA
 531                   || rctx.stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
 532                /*
 533                 * Set up a decryption context
 534                 */
 535                if (!rctx.cipher_ctx.cipher) {
 536                   if (!rctx.cs) {
 537                      Jmsg1(jcr, M_ERROR, 0, _("Missing encryption session data stream for %s\n"), jcr->last_fname);
 538                      rctx.extract = false;
 539                      bclose(&rctx.bfd);
 540                      continue;
 541                   }
 542
 543                   if ((rctx.cipher_ctx.cipher = crypto_cipher_new(rctx.cs, false,
 544                            &rctx.cipher_ctx.block_size)) == NULL) {
 545                      Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
 546                      free_session(rctx);
 547                      rctx.extract = false;
 548                      bclose(&rctx.bfd);
 549                      continue;
 550                   }
 551                }
 552                rctx.flags |= FO_ENCRYPT;
 553             }
 554
 555             if (is_win32_stream(rctx.stream) && !have_win32_api()) {
 556                set_portable_backup(&rctx.bfd);
 557                /*
 558                 * "decompose" BackupWrite data
 559                 */
 560                rctx.flags |= FO_WIN32DECOMP;
 561             }
 562
 563             if (extract_data(jcr, &rctx.bfd, sd->msg, sd->msglen, &rctx.fileAddr,
 564                              rctx.flags, &rctx.cipher_ctx) < 0) {
 565                rctx.extract = false;
 566                bclose(&rctx.bfd);
 567                continue;
 568             }
 569          }
 570          break;
 571
 572       /*
 573        * Resource fork stream - only recorded after a file to be restored
 574        * Silently ignore if we cannot write - we already reported that
 575        */
 576       case STREAM_ENCRYPTED_MACOS_FORK_DATA:
 577       case STREAM_MACOS_FORK_DATA:
 578          if (have_darwin_os) {
 579             rctx.fork_flags = 0;
 580             jcr->ff->flags |= FO_HFSPLUS;
 581
 582             if (rctx.stream == STREAM_ENCRYPTED_MACOS_FORK_DATA) {
 583                rctx.fork_flags |= FO_ENCRYPT;
 584
 585                /*
 586                 * Set up a decryption context
 587                 */
 588                if (rctx.extract && !rctx.fork_cipher_ctx.cipher) {
 589                   if (!rctx.cs) {
 590                      Jmsg1(jcr, M_ERROR, 0, _("Missing encryption session data stream for %s\n"), jcr->last_fname);
 591                      rctx.extract = false;
 592                      bclose(&rctx.bfd);
 593                      continue;
 594                   }
 595
 596                   if ((rctx.fork_cipher_ctx.cipher = crypto_cipher_new(rctx.cs, false, &rctx.fork_cipher_ctx.block_size)) == NULL) {
 597                      Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
 598                      free_session(rctx);
 599                      rctx.extract = false;
 600                      bclose(&rctx.bfd);
 601                      continue;
 602                   }
 603                }
 604             }
 605
 606             if (rctx.extract) {
 607                if (rctx.prev_stream != rctx.stream) {
 608                   if (bopen_rsrc(&rctx.forkbfd, jcr->last_fname, O_WRONLY | O_TRUNC | O_BINARY, 0) < 0) {
 609                      Jmsg(jcr, M_ERROR, 0, _("Cannot open resource fork for %s.\n"), jcr->last_fname);
 610                      rctx.extract = false;
 611                      continue;
 612                   }
 613
 614                   rctx.fork_size = rsrc_len;
 615                   Dmsg0(130, "Restoring resource fork\n");
 616                }
 617
 618                if (extract_data(jcr, &rctx.forkbfd, sd->msg, sd->msglen, &rctx.fork_addr, rctx.fork_flags,
 619                                 &rctx.fork_cipher_ctx) < 0) {
 620                   rctx.extract = false;
 621                   bclose(&rctx.forkbfd);
 622                   continue;
 623                }
 624             }
 625          } else {
 626             non_support_rsrc++;
 627          }
 628          break;
 629
 630       case STREAM_HFSPLUS_ATTRIBUTES:
 631          if (have_darwin_os) {
 632             if (!restore_finderinfo(jcr, sd->msg, sd->msglen)) {
 633                continue;
 634             }
 635          } else {
 636             non_support_finfo++;
 637          }
 638          break;
 639
 640       case STREAM_UNIX_ACCESS_ACL:
 641       case STREAM_UNIX_DEFAULT_ACL:
 642       case STREAM_ACL_AIX_TEXT:
 643       case STREAM_ACL_DARWIN_ACCESS_ACL:
 644       case STREAM_ACL_FREEBSD_DEFAULT_ACL:
 645       case STREAM_ACL_FREEBSD_ACCESS_ACL:
 646       case STREAM_ACL_HPUX_ACL_ENTRY:
 647       case STREAM_ACL_IRIX_DEFAULT_ACL:
 648       case STREAM_ACL_IRIX_ACCESS_ACL:
 649       case STREAM_ACL_LINUX_DEFAULT_ACL:
 650       case STREAM_ACL_LINUX_ACCESS_ACL:
 651       case STREAM_ACL_TRU64_DEFAULT_ACL:
 652       case STREAM_ACL_TRU64_DEFAULT_DIR_ACL:
 653       case STREAM_ACL_TRU64_ACCESS_ACL:
 654       case STREAM_ACL_SOLARIS_ACLENT:
 655       case STREAM_ACL_SOLARIS_ACE:
 656       case STREAM_ACL_AFS_TEXT:
 657       case STREAM_ACL_AIX_AIXC:
 658       case STREAM_ACL_AIX_NFS4:
 659       case STREAM_ACL_FREEBSD_NFS4_ACL:
 660          /*
 661           * Do not restore ACLs when
 662           * a) The current file is not extracted
 663           * b)     and it is not a directory (they are never "extracted")
 664           * c) or the file name is empty
 665           */
 666          if ((!rctx.extract && jcr->last_type != FT_DIREND) || (*jcr->last_fname == 0)) {
 667             break;
 668          }
 669          if (have_acl) {
 670             pm_memcpy(jcr->acl_data->content, sd->msg, sd->msglen);
 671             jcr->acl_data->content_length = sd->msglen;
 672             switch (parse_acl_streams(jcr, rctx.stream)) {
 673             case bacl_exit_fatal:
 674                goto bail_out;
 675             case bacl_exit_error:
 676                /*
 677                 * Non-fatal errors, count them and when the number is under ACL_REPORT_ERR_MAX_PER_JOB
 678                 * print the error message set by the lower level routine in jcr->errmsg.
 679                 */
 680                if (jcr->acl_data->nr_errors < ACL_REPORT_ERR_MAX_PER_JOB) {
 681                   Jmsg(jcr, M_WARNING, 0, "%s", jcr->errmsg);
 682                }
 683                jcr->acl_data->nr_errors++;
 684                break;
 685             case bacl_exit_ok:
 686                break;
 687             }
 688          } else {
 689             non_support_acl++;
 690          }
 691          break;
 692
 693       case STREAM_XATTR_IRIX:
 694       case STREAM_XATTR_TRU64:
 695       case STREAM_XATTR_AIX:
 696       case STREAM_XATTR_OPENBSD:
 697       case STREAM_XATTR_SOLARIS_SYS:
 698       case STREAM_XATTR_SOLARIS:
 699       case STREAM_XATTR_DARWIN:
 700       case STREAM_XATTR_FREEBSD:
 701       case STREAM_XATTR_LINUX:
 702       case STREAM_XATTR_NETBSD:
 703          /*
 704           * Do not restore Extended Attributes when
 705           * a) The current file is not extracted
 706           * b)     and it is not a directory (they are never "extracted")
 707           * c) or the file name is empty
 708           */
 709          if ((!rctx.extract && jcr->last_type != FT_DIREND) || (*jcr->last_fname == 0)) {
 710             break;
 711          }
 712          if (have_xattr) {
 713             pm_memcpy(jcr->xattr_data->content, sd->msg, sd->msglen);
 714             jcr->xattr_data->content_length = sd->msglen;
 715             switch (parse_xattr_streams(jcr, rctx.stream)) {
 716             case bxattr_exit_fatal:
 717                goto bail_out;
 718             case bxattr_exit_error:
 719                /*
 720                 * Non-fatal errors, count them and when the number is under XATTR_REPORT_ERR_MAX_PER_JOB
 721                 * print the error message set by the lower level routine in jcr->errmsg.
 722                 */
 723                if (jcr->xattr_data->nr_errors < XATTR_REPORT_ERR_MAX_PER_JOB) {
 724                   Jmsg(jcr, M_WARNING, 0, "%s", jcr->errmsg);
 725                }
 726                jcr->xattr_data->nr_errors++;
 727                break;
 728             case bxattr_exit_ok:
 729                break;
 730             }
 731          } else {
 732             non_support_xattr++;
 733          }
 734          break;
 735
 736       case STREAM_SIGNED_DIGEST:
 737          /*
 738           * Is this an unexpected signature?
 739           */
 740          if (rctx.sig) {
 741             Jmsg0(jcr, M_ERROR, 0, _("Unexpected cryptographic signature data stream.\n"));
 742             free_signature(rctx);
 743             continue;
 744          }
 745          /*
 746           * Save signature.
 747           */
 748          if (rctx.extract && (rctx.sig = crypto_sign_decode(jcr, (uint8_t *)sd->msg, (uint32_t)sd->msglen)) == NULL) {
 749             Jmsg1(jcr, M_ERROR, 0, _("Failed to decode message signature for %s\n"), jcr->last_fname);
 750          }
 751          break;
 752
 753       case STREAM_MD5_DIGEST:
 754       case STREAM_SHA1_DIGEST:
 755       case STREAM_SHA256_DIGEST:
 756       case STREAM_SHA512_DIGEST:
 757          break;
 758
 759       case STREAM_PROGRAM_NAMES:
 760       case STREAM_PROGRAM_DATA:
 761          if (!non_support_progname) {
 762             Pmsg0(000, "Got Program Name or Data Stream. Ignored.\n");
 763             non_support_progname++;
 764          }
 765          break;
 766
 767       case STREAM_PLUGIN_NAME:
 768          close_previous_stream(rctx);
 769          Dmsg1(50, "restore stream_plugin_name=%s\n", sd->msg);
 770          plugin_name_stream(jcr, sd->msg);
 771          break;
 772
 773       case STREAM_RESTORE_OBJECT:
 774          break;                    /* these are sent by Director */
 775
 776       default:
 777          close_previous_stream(rctx);
 778          Jmsg(jcr, M_ERROR, 0, _("Unknown stream=%d ignored. This shouldn't happen!\n"),
 779               rctx.stream);
 780          Dmsg2(0, "Unknown stream=%d data=%s\n", rctx.stream, sd->msg);
 781          break;
 782       } /* end switch(stream) */
 783    } /* end while get_msg() */
 784
 785    /*
 786     * If output file is still open, it was the last one in the
 787     * archive since we just hit an end of file, so close the file.
 788     */
 789    if (is_bopen(&rctx.forkbfd)) {
 790       bclose_chksize(jcr, &rctx.forkbfd, rctx.fork_size);
 791    }
 792
 793    close_previous_stream(rctx);
 794    set_jcr_job_status(jcr, JS_Terminated);
 795    goto ok_out;
 796
 797 bail_out:
 798    set_jcr_job_status(jcr, JS_ErrorTerminated);
 799
 800 ok_out:
 801    /*
 802     * First output the statistics.
 803     */
 804    Dmsg2(10, "End Do Restore. Files=%d Bytes=%s\n", jcr->JobFiles,
 805       edit_uint64(jcr->JobBytes, ec1));
 806    if (have_acl && jcr->acl_data->nr_errors > 0) {
 807       Jmsg(jcr, M_ERROR, 0, _("Encountered %ld acl errors while doing restore\n"),
 808            jcr->acl_data->nr_errors);
 809    }
 810    if (have_xattr && jcr->xattr_data->nr_errors > 0) {
 811       Jmsg(jcr, M_ERROR, 0, _("Encountered %ld xattr errors while doing restore\n"),
 812            jcr->xattr_data->nr_errors);
 813    }
 814    if (non_support_data > 1 || non_support_attr > 1) {
 815       Jmsg(jcr, M_ERROR, 0, _("%d non-supported data streams and %d non-supported attrib streams ignored.\n"),
 816          non_support_data, non_support_attr);
 817    }
 818    if (non_support_rsrc) {
 819       Jmsg(jcr, M_INFO, 0, _("%d non-supported resource fork streams ignored.\n"), non_support_rsrc);
 820    }
 821    if (non_support_finfo) {
 822       Jmsg(jcr, M_INFO, 0, _("%d non-supported Finder Info streams ignored.\n"), non_support_rsrc);
 823    }
 824    if (non_support_acl) {
 825       Jmsg(jcr, M_INFO, 0, _("%d non-supported acl streams ignored.\n"), non_support_acl);
 826    }
 827    if (non_support_crypto) {
 828       Jmsg(jcr, M_INFO, 0, _("%d non-supported crypto streams ignored.\n"), non_support_acl);
 829    }
 830    if (non_support_xattr) {
 831       Jmsg(jcr, M_INFO, 0, _("%d non-supported xattr streams ignored.\n"), non_support_xattr);
 832    }
 833
 834    /*
 835     * Free Signature & Crypto Data
 836     */
 837    free_signature(rctx);
 838    free_session(rctx);
 839    if (jcr->crypto.digest) {
 840       crypto_digest_free(jcr->crypto.digest);
 841       jcr->crypto.digest = NULL;
 842    }
 843
 844    /*
 845     * Free file cipher restore context
 846     */
 847    if (rctx.cipher_ctx.cipher) {
 848       crypto_cipher_free(rctx.cipher_ctx.cipher);
 849       rctx.cipher_ctx.cipher = NULL;
 850    }
 851
 852    if (rctx.cipher_ctx.buf) {
 853       free_pool_memory(rctx.cipher_ctx.buf);
 854       rctx.cipher_ctx.buf = NULL;
 855    }
 856
 857    /*
 858     * Free alternate stream cipher restore context
 859     */
 860    if (rctx.fork_cipher_ctx.cipher) {
 861       crypto_cipher_free(rctx.fork_cipher_ctx.cipher);
 862       rctx.fork_cipher_ctx.cipher = NULL;
 863    }
 864    if (rctx.fork_cipher_ctx.buf) {
 865       free_pool_memory(rctx.fork_cipher_ctx.buf);
 866       rctx.fork_cipher_ctx.buf = NULL;
 867    }
 868
 869    if (jcr->compress_buf) {
 870       free_pool_memory(jcr->compress_buf);
 871       jcr->compress_buf = NULL;
 872       jcr->compress_buf_size = 0;
 873    }
 874
 875    if (have_acl && jcr->acl_data) {
 876       free_pool_memory(jcr->acl_data->content);
 877       free(jcr->acl_data);
 878       jcr->acl_data = NULL;
 879    }
 880
 881    if (have_xattr && jcr->xattr_data) {
 882       free_pool_memory(jcr->xattr_data->content);
 883       free(jcr->xattr_data);
 884       jcr->xattr_data = NULL;
 885    }
 886
 887    bclose(&rctx.forkbfd);
 888    bclose(&rctx.bfd);
 889    free_attr(rctx.attr);
 890 }
 891
 892 #ifdef HAVE_LIBZ
 893 /*
 894  * Convert ZLIB error code into an ASCII message
 895  */
 896 static const char *zlib_strerror(int stat)
 897 {
 898    if (stat >= 0) {
 899       return _("None");
 900    }
 901    switch (stat) {
 902    case Z_ERRNO:
 903       return _("Zlib errno");
 904    case Z_STREAM_ERROR:
 905       return _("Zlib stream error");
 906    case Z_DATA_ERROR:
 907       return _("Zlib data error");
 908    case Z_MEM_ERROR:
 909       return _("Zlib memory error");
 910    case Z_BUF_ERROR:
 911       return _("Zlib buffer error");
 912    case Z_VERSION_ERROR:
 913       return _("Zlib version error");
 914    default:
 915       return _("*none*");
 916    }
 917 }
 918 #endif
 919
 920 static int do_file_digest(JCR *jcr, FF_PKT *ff_pkt, bool top_level)
 921 {
 922    Dmsg1(50, "do_file_digest jcr=%p\n", jcr);
 923    return (digest_file(jcr, ff_pkt, jcr->crypto.digest));
 924 }
 925
 926 /*
 927  * Verify the signature for the last restored file
 928  * Return value is either true (signature correct)
 929  * or false (signature could not be verified).
 930  * TODO landonf: Implement without using find_one_file and
 931  * without re-reading the file.
 932  */
 933 static bool verify_signature(JCR *jcr, r_ctx &rctx)
 934 {
 935    X509_KEYPAIR *keypair;
 936    DIGEST *digest = NULL;
 937    crypto_error_t err;
 938    uint64_t saved_bytes;
 939    crypto_digest_t signing_algorithm = have_sha2 ?
 940                                        CRYPTO_DIGEST_SHA256 : CRYPTO_DIGEST_SHA1;
 941    crypto_digest_t algorithm;
 942    SIGNATURE *sig = rctx.sig;
 943
 944
 945    if (!jcr->crypto.pki_sign) {
 946       /*
 947        * no signature OK
 948        */
 949       return true;
 950    }
 951    if (!sig) {
 952       if (rctx.type == FT_REGE || rctx.type == FT_REG || rctx.type == FT_RAW) {
 953          Jmsg1(jcr, M_ERROR, 0, _("Missing cryptographic signature for %s\n"),
 954                jcr->last_fname);
 955          goto bail_out;
 956       }
 957       return true;
 958    }
 959
 960    /*
 961     * Iterate through the trusted signers
 962     */
 963    foreach_alist(keypair, jcr->crypto.pki_signers) {
 964       err = crypto_sign_get_digest(sig, jcr->crypto.pki_keypair, algorithm, &digest);
 965       switch (err) {
 966       case CRYPTO_ERROR_NONE:
 967          Dmsg0(50, "== Got digest\n");
 968          /*
 969           * We computed jcr->crypto.digest using signing_algorithm while writing
 970           * the file. If it is not the same as the algorithm used for
 971           * this file, punt by releasing the computed algorithm and
 972           * computing by re-reading the file.
 973           */
 974          if (algorithm != signing_algorithm) {
 975             if (jcr->crypto.digest) {
 976                crypto_digest_free(jcr->crypto.digest);
 977                jcr->crypto.digest = NULL;
 978             }
 979          }
 980          if (jcr->crypto.digest) {
 981              /*
 982               * Use digest computed while writing the file to verify the signature
 983               */
 984             if ((err = crypto_sign_verify(sig, keypair, jcr->crypto.digest)) != CRYPTO_ERROR_NONE) {
 985                Dmsg1(50, "Bad signature on %s\n", jcr->last_fname);
 986                Jmsg2(jcr, M_ERROR, 0, _("Signature validation failed for file %s: ERR=%s\n"),
 987                      jcr->last_fname, crypto_strerror(err));
 988                goto bail_out;
 989             }
 990          } else {
 991             /*
 992              * Signature found, digest allocated.  Old method,
 993              * re-read the file and compute the digest
 994              */
 995             jcr->crypto.digest = digest;
 996
 997             /*
 998              * Checksum the entire file
 999              * Make sure we don't modify JobBytes by saving and restoring it
1000              */
1001             saved_bytes = jcr->JobBytes;
1002             if (find_one_file(jcr, jcr->ff, do_file_digest, jcr->last_fname, (dev_t)-1, 1) != 0) {
1003                Jmsg(jcr, M_ERROR, 0, _("Digest one file failed for file: %s\n"),
1004                     jcr->last_fname);
1005                jcr->JobBytes = saved_bytes;
1006                goto bail_out;
1007             }
1008             jcr->JobBytes = saved_bytes;
1009
1010             /*
1011              * Verify the signature
1012              */
1013             if ((err = crypto_sign_verify(sig, keypair, digest)) != CRYPTO_ERROR_NONE) {
1014                Dmsg1(50, "Bad signature on %s\n", jcr->last_fname);
1015                Jmsg2(jcr, M_ERROR, 0, _("Signature validation failed for file %s: ERR=%s\n"),
1016                      jcr->last_fname, crypto_strerror(err));
1017                goto bail_out;
1018             }
1019             jcr->crypto.digest = NULL;
1020          }
1021
1022          /*
1023           * Valid signature
1024           */
1025          Dmsg1(50, "Signature good on %s\n", jcr->last_fname);
1026          crypto_digest_free(digest);
1027          return true;
1028
1029       case CRYPTO_ERROR_NOSIGNER:
1030          /*
1031           * Signature not found, try again
1032           */
1033          if (digest) {
1034             crypto_digest_free(digest);
1035             digest = NULL;
1036          }
1037          continue;
1038       default:
1039          /*
1040           * Something strange happened (that shouldn't happen!)...
1041           */
1042          Qmsg2(jcr, M_ERROR, 0, _("Signature validation failed for %s: %s\n"), jcr->last_fname, crypto_strerror(err));
1043          goto bail_out;
1044       }
1045    }
1046
1047    /*
1048     * No signer
1049     */
1050    Dmsg1(50, "Could not find a valid public key for signature on %s\n", jcr->last_fname);
1051
1052 bail_out:
1053    if (digest) {
1054       crypto_digest_free(digest);
1055    }
1056    return false;
1057 }
1058
1059 bool sparse_data(JCR *jcr, BFILE *bfd, uint64_t *addr, char **data, uint32_t *length)
1060 {
1061       unser_declare;
1062       uint64_t faddr;
1063       char ec1[50];
1064       unser_begin(*data, OFFSET_FADDR_SIZE);
1065       unser_uint64(faddr);
1066       if (*addr != faddr) {
1067          *addr = faddr;
1068          if (blseek(bfd, (boffset_t)*addr, SEEK_SET) < 0) {
1069             berrno be;
1070             Jmsg3(jcr, M_ERROR, 0, _("Seek to %s error on %s: ERR=%s\n"),
1071                   edit_uint64(*addr, ec1), jcr->last_fname,
1072                   be.bstrerror(bfd->berrno));
1073             return false;
1074          }
1075       }
1076       *data += OFFSET_FADDR_SIZE;
1077       *length -= OFFSET_FADDR_SIZE;
1078       return true;
1079 }
1080
1081 bool decompress_data(JCR *jcr, char **data, uint32_t *length)
1082 {
1083 #ifdef HAVE_LIBZ
1084    uLong compress_len;
1085    int stat;
1086    char ec1[50]; /* Buffer printing huge values */
1087
1088    /*
1089     * NOTE! We only use uLong and Byte because they are
1090     * needed by the zlib routines, they should not otherwise
1091     * be used in Bacula.
1092     */
1093    compress_len = jcr->compress_buf_size;
1094    Dmsg2(200, "Comp_len=%d msglen=%d\n", compress_len, *length);
1095    while ((stat=uncompress((Byte *)jcr->compress_buf, &compress_len,
1096                            (const Byte *)*data, (uLong)*length)) == Z_BUF_ERROR)
1097    {
1098       /*
1099        * The buffer size is too small, try with a bigger one
1100        */
1101       compress_len = jcr->compress_buf_size = jcr->compress_buf_size + (jcr->compress_buf_size >> 1);
1102       Dmsg2(200, "Comp_len=%d msglen=%d\n", compress_len, *length);
1103       jcr->compress_buf = check_pool_memory_size(jcr->compress_buf,
1104                                                  compress_len);
1105    }
1106    if (stat != Z_OK) {
1107       Qmsg(jcr, M_ERROR, 0, _("Uncompression error on file %s. ERR=%s\n"),
1108            jcr->last_fname, zlib_strerror(stat));
1109       return false;
1110    }
1111    *data = jcr->compress_buf;
1112    *length = compress_len;
1113    Dmsg2(200, "Write uncompressed %d bytes, total before write=%s\n", compress_len, edit_uint64(jcr->JobBytes, ec1));
1114    return true;
1115 #else
1116    Qmsg(jcr, M_ERROR, 0, _("GZIP data stream found, but GZIP not configured!\n"));
1117    return false;
1118 #endif
1119 }
1120
1121 static void unser_crypto_packet_len(RESTORE_CIPHER_CTX *ctx)
1122 {
1123    unser_declare;
1124    if (ctx->packet_len == 0 && ctx->buf_len >= CRYPTO_LEN_SIZE) {
1125       unser_begin(&ctx->buf[0], CRYPTO_LEN_SIZE);
1126       unser_uint32(ctx->packet_len);
1127       ctx->packet_len += CRYPTO_LEN_SIZE;
1128    }
1129 }
1130
1131 bool store_data(JCR *jcr, BFILE *bfd, char *data, const int32_t length, bool win32_decomp)
1132 {
1133    if (jcr->crypto.digest) {
1134       crypto_digest_update(jcr->crypto.digest, (uint8_t *)data, length);
1135    }
1136    if (win32_decomp) {
1137       if (!processWin32BackupAPIBlock(bfd, data, length)) {
1138          berrno be;
1139          Jmsg2(jcr, M_ERROR, 0, _("Write error in Win32 Block Decomposition on %s: %s\n"),
1140                jcr->last_fname, be.bstrerror(bfd->berrno));
1141          return false;
1142       }
1143    } else if (bwrite(bfd, data, length) != (ssize_t)length) {
1144       berrno be;
1145       Jmsg2(jcr, M_ERROR, 0, _("Write error on %s: %s\n"),
1146             jcr->last_fname, be.bstrerror(bfd->berrno));
1147       return false;
1148    }
1149
1150    return true;
1151 }
1152
1153 /*
1154  * In the context of jcr, write data to bfd.
1155  * We write buflen bytes in buf at addr. addr is updated in place.
1156  * The flags specify whether to use sparse files or compression.
1157  * Return value is the number of bytes written, or -1 on errors.
1158  */
1159 int32_t extract_data(JCR *jcr, BFILE *bfd, POOLMEM *buf, int32_t buflen,
1160                      uint64_t *addr, int flags, RESTORE_CIPHER_CTX *cipher_ctx)
1161 {
1162    char *wbuf;                 /* write buffer */
1163    uint32_t wsize;             /* write size */
1164    uint32_t rsize;             /* read size */
1165    uint32_t decrypted_len = 0; /* Decryption output length */
1166    char ec1[50];               /* Buffer printing huge values */
1167
1168    rsize = buflen;
1169    jcr->ReadBytes += rsize;
1170    wsize = rsize;
1171    wbuf = buf;
1172
1173    if (flags & FO_ENCRYPT) {
1174       ASSERT(cipher_ctx->cipher);
1175
1176       /*
1177        * NOTE: We must implement block preserving semantics for the
1178        * non-streaming compression and sparse code.
1179        *
1180        * Grow the crypto buffer, if necessary.
1181        * crypto_cipher_update() will process only whole blocks,
1182        * buffering the remaining input.
1183        */
1184       cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf,
1185                         cipher_ctx->buf_len + wsize + cipher_ctx->block_size);
1186
1187       /*
1188        * Decrypt the input block
1189        */
1190       if (!crypto_cipher_update(cipher_ctx->cipher,
1191                                 (const u_int8_t *)wbuf,
1192                                 wsize,
1193                                 (u_int8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
1194                                 &decrypted_len)) {
1195          /*
1196           * Decryption failed. Shouldn't happen.
1197           */
1198          Jmsg(jcr, M_FATAL, 0, _("Decryption error\n"));
1199          goto bail_out;
1200       }
1201
1202       if (decrypted_len == 0) {
1203          /*
1204           * No full block of encrypted data available, write more data
1205           */
1206          return 0;
1207       }
1208
1209       Dmsg2(200, "decrypted len=%d encrypted len=%d\n", decrypted_len, wsize);
1210
1211       cipher_ctx->buf_len += decrypted_len;
1212       wbuf = cipher_ctx->buf;
1213
1214       /*
1215        * If one full preserved block is available, write it to disk,
1216        * and then buffer any remaining data. This should be effecient
1217        * as long as Bacula's block size is not significantly smaller than the
1218        * encryption block size (extremely unlikely!)
1219        */
1220       unser_crypto_packet_len(cipher_ctx);
1221       Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1222
1223       if (cipher_ctx->packet_len == 0 || cipher_ctx->buf_len < cipher_ctx->packet_len) {
1224          /*
1225           * No full preserved block is available.
1226           */
1227          return 0;
1228       }
1229
1230       /*
1231        * We have one full block, set up the filter input buffers
1232        */
1233       wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1234       wbuf = &wbuf[CRYPTO_LEN_SIZE]; /* Skip the block length header */
1235       cipher_ctx->buf_len -= cipher_ctx->packet_len;
1236       Dmsg2(130, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
1237    }
1238
1239    if ((flags & FO_SPARSE) || (flags & FO_OFFSETS)) {
1240       if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1241          goto bail_out;
1242       }
1243    }
1244
1245    if (flags & FO_GZIP) {
1246       if (!decompress_data(jcr, &wbuf, &wsize)) {
1247          goto bail_out;
1248       }
1249    }
1250
1251    if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1252       goto bail_out;
1253    }
1254    jcr->JobBytes += wsize;
1255    *addr += wsize;
1256    Dmsg2(130, "Write %u bytes, JobBytes=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1257
1258    /*
1259     * Clean up crypto buffers
1260     */
1261    if (flags & FO_ENCRYPT) {
1262       /* Move any remaining data to start of buffer */
1263       if (cipher_ctx->buf_len > 0) {
1264          Dmsg1(130, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1265          memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1266             cipher_ctx->buf_len);
1267       }
1268       /*
1269        * The packet was successfully written, reset the length so that the next
1270        * packet length may be re-read by unser_crypto_packet_len()
1271        */
1272       cipher_ctx->packet_len = 0;
1273    }
1274    return wsize;
1275
1276 bail_out:
1277    return -1;
1278 }
1279
1280
1281 /*
1282  * If extracting, close any previous stream
1283  */
1284 static void close_previous_stream(r_ctx &rctx)
1285 {
1286    /*
1287     * If extracting, it was from previous stream, so
1288     * close the output file and validate the signature.
1289     */
1290    if (rctx.extract) {
1291       if (rctx.size > 0 && !is_bopen(&rctx.bfd)) {
1292          Jmsg0(rctx.jcr, M_ERROR, 0, _("Logic error: output file should be open\n"));
1293          Dmsg2(000, "=== logic error size=%d bopen=%d\n", rctx.size,
1294             is_bopen(&rctx.bfd));
1295       }
1296
1297       if (rctx.prev_stream != STREAM_ENCRYPTED_SESSION_DATA) {
1298          deallocate_cipher(rctx);
1299          deallocate_fork_cipher(rctx);
1300       }
1301
1302       if (rctx.jcr->plugin) {
1303          plugin_set_attributes(rctx.jcr, rctx.attr, &rctx.bfd);
1304       } else {
1305          set_attributes(rctx.jcr, rctx.attr, &rctx.bfd);
1306       }
1307       rctx.extract = false;
1308
1309       /*
1310        * Verify the cryptographic signature, if any
1311        */
1312       rctx.type = rctx.attr->type;
1313       verify_signature(rctx.jcr, rctx);
1314
1315       /*
1316        * Free Signature
1317        */
1318       free_signature(rctx);
1319       free_session(rctx);
1320       rctx.jcr->ff->flags = 0;
1321       Dmsg0(130, "Stop extracting.\n");
1322    } else if (is_bopen(&rctx.bfd)) {
1323       Jmsg0(rctx.jcr, M_ERROR, 0, _("Logic error: output file should not be open\n"));
1324       Dmsg0(000, "=== logic error !open\n");
1325       bclose(&rctx.bfd);
1326    }
1327 }
1328
1329
1330 /*
1331  * In the context of jcr, flush any remaining data from the cipher context,
1332  * writing it to bfd.
1333  * Return value is true on success, false on failure.
1334  */
1335 bool flush_cipher(JCR *jcr, BFILE *bfd, uint64_t *addr, int flags,
1336                   RESTORE_CIPHER_CTX *cipher_ctx)
1337 {
1338    uint32_t decrypted_len = 0;
1339    char *wbuf;                        /* write buffer */
1340    uint32_t wsize;                    /* write size */
1341    char ec1[50];                      /* Buffer printing huge values */
1342    bool second_pass = false;
1343
1344 again:
1345    /*
1346     * Write out the remaining block and free the cipher context
1347     */
1348    cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf, cipher_ctx->buf_len +
1349                                             cipher_ctx->block_size);
1350
1351    if (!crypto_cipher_finalize(cipher_ctx->cipher, (uint8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
1352         &decrypted_len)) {
1353       /*
1354        * Writing out the final, buffered block failed. Shouldn't happen.
1355        */
1356       Jmsg3(jcr, M_ERROR, 0, _("Decryption error. buf_len=%d decrypt_len=%d on file %s\n"),
1357             cipher_ctx->buf_len, decrypted_len, jcr->last_fname);
1358    }
1359
1360    Dmsg2(130, "Flush decrypt len=%d buf_len=%d\n", decrypted_len, cipher_ctx->buf_len);
1361    /*
1362     * If nothing new was decrypted, and our output buffer is empty, return
1363     */
1364    if (decrypted_len == 0 && cipher_ctx->buf_len == 0) {
1365       return true;
1366    }
1367
1368    cipher_ctx->buf_len += decrypted_len;
1369
1370    unser_crypto_packet_len(cipher_ctx);
1371    Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1372    wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1373    /*
1374     * Decrypted, possibly decompressed output here.
1375     */
1376    wbuf = &cipher_ctx->buf[CRYPTO_LEN_SIZE];
1377    cipher_ctx->buf_len -= cipher_ctx->packet_len;
1378    Dmsg2(130, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
1379
1380    if ((flags & FO_SPARSE) || (flags & FO_OFFSETS)) {
1381       if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1382          return false;
1383       }
1384    }
1385
1386    if (flags & FO_GZIP) {
1387       if (!decompress_data(jcr, &wbuf, &wsize)) {
1388          return false;
1389       }
1390    }
1391
1392    Dmsg0(130, "Call store_data\n");
1393    if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1394       return false;
1395    }
1396    jcr->JobBytes += wsize;
1397    Dmsg2(130, "Flush write %u bytes, JobBytes=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1398
1399    /*
1400     * Move any remaining data to start of buffer
1401     */
1402    if (cipher_ctx->buf_len > 0) {
1403       Dmsg1(130, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1404       memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1405          cipher_ctx->buf_len);
1406    }
1407    /*
1408     * The packet was successfully written, reset the length so that the next
1409     * packet length may be re-read by unser_crypto_packet_len()
1410     */
1411    cipher_ctx->packet_len = 0;
1412
1413    if (cipher_ctx->buf_len >0 && !second_pass) {
1414       second_pass = true;
1415       goto again;
1416    }
1417
1418    /*
1419     * Stop decryption
1420     */
1421    cipher_ctx->buf_len = 0;
1422    cipher_ctx->packet_len = 0;
1423
1424    return true;
1425 }
1426
1427 static void deallocate_cipher(r_ctx &rctx)
1428 {
1429    /*
1430     * Flush and deallocate previous stream's cipher context
1431     */
1432    if (rctx.cipher_ctx.cipher) {
1433       flush_cipher(rctx.jcr, &rctx.bfd, &rctx.fileAddr, rctx.flags, &rctx.cipher_ctx);
1434       crypto_cipher_free(rctx.cipher_ctx.cipher);
1435       rctx.cipher_ctx.cipher = NULL;
1436    }
1437 }
1438
1439 static void deallocate_fork_cipher(r_ctx &rctx)
1440 {
1441
1442    /*
1443     * Flush and deallocate previous stream's fork cipher context
1444     */
1445    if (rctx.fork_cipher_ctx.cipher) {
1446       flush_cipher(rctx.jcr, &rctx.forkbfd, &rctx.fork_addr, rctx.fork_flags, &rctx.fork_cipher_ctx);
1447       crypto_cipher_free(rctx.fork_cipher_ctx.cipher);
1448       rctx.fork_cipher_ctx.cipher = NULL;
1449    }
1450 }
1451
1452 static void free_signature(r_ctx &rctx)
1453 {
1454    if (rctx.sig) {
1455       crypto_sign_free(rctx.sig);
1456       rctx.sig = NULL;
1457    }
1458 }
1459
1460 static void free_session(r_ctx &rctx)
1461 {
1462    if (rctx.cs) {
1463       crypto_session_free(rctx.cs);
1464       rctx.cs = NULL;
1465    }
1466 }
1467
1468
1469 /*
1470  * This code if implemented goes above
1471  */
1472 #ifdef stbernard_implemented
1473 /  #if defined(HAVE_WIN32)
1474    bool        bResumeOfmOnExit = FALSE;
1475    if (isOpenFileManagerRunning()) {
1476        if ( pauseOpenFileManager() ) {
1477           Jmsg(jcr, M_INFO, 0, _("Open File Manager paused\n") );
1478           bResumeOfmOnExit = TRUE;
1479        }
1480        else {
1481           Jmsg(jcr, M_ERROR, 0, _("FAILED to pause Open File Manager\n") );
1482        }
1483    }
1484    {
1485        char username[UNLEN+1];
1486        DWORD usize = sizeof(username);
1487        int privs = enable_backup_privileges(NULL, 1);
1488        if (GetUserName(username, &usize)) {
1489           Jmsg2(jcr, M_INFO, 0, _("Running as '%s'. Privmask=%#08x\n"), username,
1490        } else {
1491           Jmsg(jcr, M_WARNING, 0, _("Failed to retrieve current UserName\n"));
1492        }
1493    }
1494 #endif