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

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