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

   1 /*
   2  *  Bacula File Daemon  restore.c Restorefiles.
   3  *
   4  *    Kern Sibbald, November MM
   5  *
   6  *   Version $Id$
   7  *
   8  */
   9 /*
  10    Bacula® - The Network Backup Solution
  11
  12    Copyright (C) 2000-2006 Free Software Foundation Europe e.V.
  13
  14    The main author of Bacula is Kern Sibbald, with contributions from
  15    many others, a complete list can be found in the file AUTHORS.
  16    This program is Free Software; you can redistribute it and/or
  17    modify it under the terms of version two of the GNU General Public
  18    License as published by the Free Software Foundation plus additions
  19    that are listed in the file LICENSE.
  20
  21    This program is distributed in the hope that it will be useful, but
  22    WITHOUT ANY WARRANTY; without even the implied warranty of
  23    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  24    General Public License for more details.
  25
  26    You should have received a copy of the GNU General Public License
  27    along with this program; if not, write to the Free Software
  28    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  29    02110-1301, USA.
  30
  31    Bacula® is a registered trademark of John Walker.
  32    The licensor of Bacula is the Free Software Foundation Europe
  33    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  34    Switzerland, email:ftf@fsfeurope.org.
  35 */
  36
  37 #include "bacula.h"
  38 #include "filed.h"
  39
  40 #ifdef HAVE_DARWIN_OS
  41 #include <sys/attr.h>
  42 #endif
  43
  44 #if defined(HAVE_CRYPTO)
  45 const bool have_crypto = true;
  46 #else
  47 const bool have_crypto = false;
  48 #endif
  49
  50 /* Data received from Storage Daemon */
  51 static char rec_header[] = "rechdr %ld %ld %ld %ld %ld";
  52
  53 /* Forward referenced functions */
  54 #if   defined(HAVE_LIBZ)
  55 static const char *zlib_strerror(int stat);
  56 const bool have_libz = true;
  57 #else
  58 const bool have_libz = false;
  59 #endif
  60
  61 int verify_signature(JCR *jcr, SIGNATURE *sig);
  62 int32_t extract_data(JCR *jcr, BFILE *bfd, POOLMEM *buf, int32_t buflen,
  63       uint64_t *addr, int flags, CIPHER_CONTEXT *cipher, uint32_t cipher_block_size);
  64 bool flush_cipher(JCR *jcr, BFILE *bfd, int flags, CIPHER_CONTEXT *cipher,
  65                   uint32_t cipher_block_size);
  66
  67 #define RETRY 10                      /* retry wait time */
  68
  69 /*
  70  * Close a bfd check that we are at the expected file offset.
  71  * Makes some code in set_attributes().
  72  */
  73 int bclose_chksize(JCR *jcr, BFILE *bfd, boffset_t osize)
  74 {
  75    char ec1[50], ec2[50];
  76    boffset_t fsize;
  77
  78    fsize = blseek(bfd, 0, SEEK_CUR);
  79    bclose(bfd);                              /* first close file */
  80    if (fsize > 0 && fsize != osize) {
  81       Qmsg3(jcr, M_ERROR, 0, _("Size of data or stream of %s not correct. Original %s, restored %s.\n"),
  82             jcr->last_fname, edit_uint64(osize, ec1),
  83             edit_uint64(fsize, ec2));
  84       return -1;
  85    }
  86    return 0;
  87 }
  88
  89 /*
  90  * Restore the requested files.
  91  *
  92  */
  93 void do_restore(JCR *jcr)
  94 {
  95    BSOCK *sd;
  96    int32_t stream = 0;
  97    int32_t prev_stream;
  98    uint32_t VolSessionId, VolSessionTime;
  99    bool extract = false;
 100    int32_t file_index;
 101    char ec1[50];                      /* Buffer printing huge values */
 102
 103    BFILE bfd;                         /* File content */
 104    uint64_t fileAddr = 0;             /* file write address */
 105    uint32_t size;                     /* Size of file */
 106    BFILE altbfd;                      /* Alternative data stream */
 107    uint64_t alt_addr = 0;             /* Write address for alternative stream */
 108    intmax_t alt_size = 0;             /* Size of alternate stream */
 109    SIGNATURE *sig = NULL;             /* Cryptographic signature (if any) for file */
 110    CRYPTO_SESSION *cs = NULL;         /* Cryptographic session data (if any) for file */
 111    CIPHER_CONTEXT *cipher_ctx = NULL; /* Cryptographic cipher context (if any) for file */
 112    uint32_t cipher_block_size = 0;    /* Cryptographic algorithm block size for file */
 113    int flags = 0;                     /* Options for extract_data() */
 114    int stat;
 115    ATTR *attr;
 116
 117    /* The following variables keep track of "known unknowns" */
 118    int non_support_data = 0;
 119    int non_support_attr = 0;
 120    int non_support_rsrc = 0;
 121    int non_support_finfo = 0;
 122    int non_support_acl = 0;
 123    int non_support_progname = 0;
 124
 125    /* Finally, set up for special configurations */
 126 #ifdef HAVE_DARWIN_OS
 127    intmax_t rsrc_len = 0;             /* Original length of resource fork */
 128    struct attrlist attrList;
 129
 130    memset(&attrList, 0, sizeof(attrList));
 131    attrList.bitmapcount = ATTR_BIT_MAP_COUNT;
 132    attrList.commonattr = ATTR_CMN_FNDRINFO;
 133 #endif
 134
 135    sd = jcr->store_bsock;
 136    set_jcr_job_status(jcr, JS_Running);
 137
 138    LockRes();
 139    CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);
 140    UnlockRes();
 141    uint32_t buf_size;
 142    if (client) {
 143       buf_size = client->max_network_buffer_size;
 144    } else {
 145       buf_size = 0;                   /* use default */
 146    }
 147    if (!bnet_set_buffer_size(sd, buf_size, BNET_SETBUF_WRITE)) {
 148       set_jcr_job_status(jcr, JS_ErrorTerminated);
 149       return;
 150    }
 151    jcr->buf_size = sd->msglen;
 152
 153 #ifdef stbernard_implemented
 154 /  #if defined(HAVE_WIN32)
 155    bool        bResumeOfmOnExit = FALSE;
 156    if (isOpenFileManagerRunning()) {
 157        if ( pauseOpenFileManager() ) {
 158           Jmsg(jcr, M_INFO, 0, _("Open File Manager paused\n") );
 159           bResumeOfmOnExit = TRUE;
 160        }
 161        else {
 162           Jmsg(jcr, M_ERROR, 0, _("FAILED to pause Open File Manager\n") );
 163        }
 164    }
 165    {
 166        char username[UNLEN+1];
 167        DWORD usize = sizeof(username);
 168        int privs = enable_backup_privileges(NULL, 1);
 169        if (GetUserName(username, &usize)) {
 170           Jmsg2(jcr, M_INFO, 0, _("Running as '%s'. Privmask=%#08x\n"), username,
 171        } else {
 172           Jmsg(jcr, M_WARNING, 0, _("Failed to retrieve current UserName\n"));
 173        }
 174    }
 175 #endif
 176
 177    if (have_libz) {
 178       uint32_t compress_buf_size = jcr->buf_size + 12 + ((jcr->buf_size+999) / 1000) + 100;
 179       jcr->compress_buf = (char *)bmalloc(compress_buf_size);
 180       jcr->compress_buf_size = compress_buf_size;
 181    }
 182
 183    if (have_crypto) {
 184       jcr->crypto_buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
 185    }
 186
 187    /*
 188     * Get a record from the Storage daemon. We are guaranteed to
 189     *   receive records in the following order:
 190     *   1. Stream record header
 191     *   2. Stream data
 192     *        a. Attributes (Unix or Win32)
 193     *        b. Possibly stream encryption session data (e.g., symmetric session key)
 194     *    or  c. File data for the file
 195     *    or  d. Alternate data stream (e.g. Resource Fork)
 196     *    or  e. Finder info
 197     *    or  f. ACLs
 198     *    or  g. Possibly a cryptographic signature
 199     *    or  h. Possibly MD5 or SHA1 record
 200     *   3. Repeat step 1
 201     *
 202     * NOTE: We keep track of two bacula file descriptors:
 203     *   1. bfd for file data.
 204     *      This fd is opened for non empty files when an attribute stream is
 205     *      encountered and closed when we find the next attribute stream.
 206     *   2. alt_bfd for alternate data streams
 207     *      This fd is opened every time we encounter a new alternate data
 208     *      stream for the current file. When we find any other stream, we
 209     *      close it again.
 210     *      The expected size of the stream, alt_len, should be set when
 211     *      opening the fd.
 212     */
 213    binit(&bfd);
 214    binit(&altbfd);
 215    attr = new_attr();
 216    jcr->acl_text = get_pool_memory(PM_MESSAGE);
 217
 218    while (bget_msg(sd) >= 0 && !job_canceled(jcr)) {
 219       /* Remember previous stream type */
 220       prev_stream = stream;
 221
 222       /* First we expect a Stream Record Header */
 223       if (sscanf(sd->msg, rec_header, &VolSessionId, &VolSessionTime, &file_index,
 224           &stream, &size) != 5) {
 225          Jmsg1(jcr, M_FATAL, 0, _("Record header scan error: %s\n"), sd->msg);
 226          goto bail_out;
 227       }
 228       Dmsg4(30, "Got hdr: Files=%d FilInx=%d Stream=%d, %s.\n",
 229             jcr->JobFiles, file_index, stream, stream_to_ascii(stream));
 230
 231       /* * Now we expect the Stream Data */
 232       if (bget_msg(sd) < 0) {
 233          Jmsg1(jcr, M_FATAL, 0, _("Data record error. ERR=%s\n"), bnet_strerror(sd));
 234          goto bail_out;
 235       }
 236       if (size != (uint32_t)sd->msglen) {
 237          Jmsg2(jcr, M_FATAL, 0, _("Actual data size %d not same as header %d\n"), sd->msglen, size);
 238          goto bail_out;
 239       }
 240       Dmsg3(30, "Got stream: %s len=%d extract=%d\n", stream_to_ascii(stream),
 241             sd->msglen, extract);
 242
 243       /* If we change streams, close and reset alternate data streams */
 244       if (prev_stream != stream) {
 245          if (is_bopen(&altbfd)) {
 246             bclose_chksize(jcr, &altbfd, alt_size);
 247          }
 248          alt_size = -1; /* Use an impossible value and set a proper one below */
 249          alt_addr = 0;
 250       }
 251
 252       /* File Attributes stream */
 253       switch (stream) {
 254       case STREAM_UNIX_ATTRIBUTES:
 255       case STREAM_UNIX_ATTRIBUTES_EX:
 256          /*
 257           * If extracting, it was from previous stream, so
 258           * close the output file and validate the signature.
 259           */
 260          if (extract) {
 261             if (size > 0 && !is_bopen(&bfd)) {
 262                Jmsg0(jcr, M_ERROR, 0, _("Logic error: output file should be open\n"));
 263             }
 264             /* Flush and deallocate previous stream's cipher context */
 265             if (cipher_ctx && prev_stream != STREAM_ENCRYPTED_SESSION_DATA) {
 266                flush_cipher(jcr, &bfd, flags, cipher_ctx, cipher_block_size);
 267                crypto_cipher_free(cipher_ctx);
 268                cipher_ctx = NULL;
 269             }
 270             set_attributes(jcr, attr, &bfd);
 271             extract = false;
 272
 273             /* Verify the cryptographic signature, if any */
 274             if (jcr->pki_sign) {
 275                if (sig) {
 276                   // Failure is reported in verify_signature() ...
 277                   verify_signature(jcr, sig);
 278                } else {
 279                   Jmsg1(jcr, M_ERROR, 0, _("Missing cryptographic signature for %s\n"), jcr->last_fname);
 280                }
 281             }
 282             /* Free Signature */
 283             if (sig) {
 284                crypto_sign_free(sig);
 285                sig = NULL;
 286             }
 287             if (cs) {
 288                crypto_session_free(cs);
 289                cs = NULL;
 290             }
 291             Dmsg0(30, "Stop extracting.\n");
 292          } else if (is_bopen(&bfd)) {
 293             Jmsg0(jcr, M_ERROR, 0, _("Logic error: output file should not be open\n"));
 294             bclose(&bfd);
 295          }
 296
 297          /*
 298           * Unpack and do sanity check fo attributes.
 299           */
 300          if (!unpack_attributes_record(jcr, stream, sd->msg, attr)) {
 301             goto bail_out;
 302          }
 303          if (file_index != attr->file_index) {
 304             Jmsg(jcr, M_FATAL, 0, _("Record header file index %ld not equal record index %ld\n"),
 305                  file_index, attr->file_index);
 306             Dmsg0(100, "File index error\n");
 307             goto bail_out;
 308          }
 309
 310          Dmsg3(200, "File %s\nattrib=%s\nattribsEx=%s\n", attr->fname,
 311                attr->attr, attr->attrEx);
 312
 313          attr->data_stream = decode_stat(attr->attr, &attr->statp, &attr->LinkFI);
 314
 315          if (!is_restore_stream_supported(attr->data_stream)) {
 316             if (!non_support_data++) {
 317                Jmsg(jcr, M_ERROR, 0, _("%s stream not supported on this Client.\n"),
 318                   stream_to_ascii(attr->data_stream));
 319             }
 320             continue;
 321          }
 322
 323          build_attr_output_fnames(jcr, attr);
 324
 325          /*
 326           * Now determine if we are extracting or not.
 327           */
 328          jcr->num_files_examined++;
 329          Dmsg1(30, "Outfile=%s\n", attr->ofname);
 330          extract = false;
 331          stat = create_file(jcr, attr, &bfd, jcr->replace);
 332          switch (stat) {
 333          case CF_ERROR:
 334          case CF_SKIP:
 335             break;
 336          case CF_EXTRACT:        /* File created and we expect file data */
 337             extract = true;
 338             /* FALLTHROUGH */
 339          case CF_CREATED:        /* File created, but there is no content */
 340             jcr->lock();
 341             pm_strcpy(jcr->last_fname, attr->ofname);
 342             jcr->last_type = attr->type;
 343             jcr->JobFiles++;
 344             jcr->unlock();
 345             fileAddr = 0;
 346             print_ls_output(jcr, attr);
 347 #ifdef HAVE_DARWIN_OS
 348             /* Only restore the resource fork for regular files */
 349             from_base64(&rsrc_len, attr->attrEx);
 350             if (attr->type == FT_REG && rsrc_len > 0) {
 351                extract = true;
 352             }
 353 #endif
 354             if (!extract) {
 355                /* set attributes now because file will not be extracted */
 356                set_attributes(jcr, attr, &bfd);
 357             }
 358             break;
 359          }
 360          break;
 361
 362       /* Data stream */
 363       case STREAM_ENCRYPTED_SESSION_DATA:
 364          crypto_error_t cryptoerr;
 365
 366          /* Do we have any keys at all? */
 367          if (!jcr->pki_recipients) {
 368             Jmsg(jcr, M_ERROR, 0, _("No private decryption keys have been defined to decrypt encrypted backup data.\n"));
 369             extract = false;
 370             bclose(&bfd);
 371             break;
 372          }
 373
 374          /* Decode and save session keys. */
 375          cryptoerr = crypto_session_decode((uint8_t *)sd->msg, (uint32_t)sd->msglen, jcr->pki_recipients, &cs);
 376          switch(cryptoerr) {
 377          case CRYPTO_ERROR_NONE:
 378             /* Success */
 379             break;
 380          case CRYPTO_ERROR_NORECIPIENT:
 381             Jmsg(jcr, M_ERROR, 0, _("Missing private key required to decrypt encrypted backup data.\n"));
 382             break;
 383          case CRYPTO_ERROR_DECRYPTION:
 384             Jmsg(jcr, M_ERROR, 0, _("Decrypt of the session key failed.\n"));
 385             break;
 386          default:
 387             /* Shouldn't happen */
 388             Jmsg1(jcr, M_ERROR, 0, _("An error occured while decoding encrypted session data stream: %s\n"), crypto_strerror(cryptoerr));
 389             break;
 390          }
 391
 392          if (cryptoerr != CRYPTO_ERROR_NONE) {
 393             extract = false;
 394             bclose(&bfd);
 395             continue;
 396          }
 397
 398          /* Set up a decryption context */
 399          if ((cipher_ctx = crypto_cipher_new(cs, false, &cipher_block_size)) == NULL) {
 400             Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
 401             crypto_session_free(cs);
 402             cs = NULL;
 403             extract = false;
 404             bclose(&bfd);
 405             continue;
 406          }
 407
 408          jcr->crypto_count = 0;
 409          jcr->crypto_size = 0;
 410          break;
 411
 412       case STREAM_FILE_DATA:
 413       case STREAM_SPARSE_DATA:
 414       case STREAM_WIN32_DATA:
 415       case STREAM_GZIP_DATA:
 416       case STREAM_SPARSE_GZIP_DATA:
 417       case STREAM_WIN32_GZIP_DATA:
 418       case STREAM_ENCRYPTED_FILE_DATA:
 419       case STREAM_ENCRYPTED_WIN32_DATA:
 420       case STREAM_ENCRYPTED_FILE_GZIP_DATA:
 421       case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
 422          /* Force an expected, consistent stream type here */
 423          if (extract && (prev_stream == stream || prev_stream == STREAM_UNIX_ATTRIBUTES
 424                   || prev_stream == STREAM_UNIX_ATTRIBUTES_EX
 425                   || prev_stream == STREAM_ENCRYPTED_SESSION_DATA)) {
 426             flags = 0;
 427
 428             if (stream == STREAM_SPARSE_DATA || stream == STREAM_SPARSE_GZIP_DATA) {
 429                flags |= FO_SPARSE;
 430             }
 431
 432             if (stream == STREAM_GZIP_DATA || stream == STREAM_SPARSE_GZIP_DATA
 433                   || stream == STREAM_WIN32_GZIP_DATA || stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
 434                   || stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
 435                flags |= FO_GZIP;
 436             }
 437
 438             if (stream == STREAM_ENCRYPTED_FILE_DATA
 439                   || stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
 440                   || stream == STREAM_ENCRYPTED_WIN32_DATA
 441                   || stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
 442                flags |= FO_ENCRYPT;
 443             }
 444
 445             if (is_win32_stream(stream) && !have_win32_api()) {
 446                set_portable_backup(&bfd);
 447                flags |= FO_WIN32DECOMP;    /* "decompose" BackupWrite data */
 448             }
 449
 450             if (extract_data(jcr, &bfd, sd->msg, sd->msglen, &fileAddr, flags,
 451                              cipher_ctx, cipher_block_size) < 0) {
 452                extract = false;
 453                bclose(&bfd);
 454                continue;
 455             }
 456          }
 457          break;
 458
 459       /* Resource fork stream - only recorded after a file to be restored */
 460       /* Silently ignore if we cannot write - we already reported that */
 461       case STREAM_ENCRYPTED_MACOS_FORK_DATA:
 462          flags |= FO_ENCRYPT;
 463       case STREAM_MACOS_FORK_DATA:
 464 #ifdef HAVE_DARWIN_OS
 465          if (extract) {
 466             if (prev_stream != stream) {
 467                if (bopen_rsrc(&altbfd, jcr->last_fname, O_WRONLY | O_TRUNC | O_BINARY, 0) < 0) {
 468                   Jmsg(jcr, M_ERROR, 0, _("     Cannot open resource fork for %s.\n"), jcr->last_fname);
 469                   extract = false;
 470                   continue;
 471                }
 472                alt_size = rsrc_len;
 473                Dmsg0(30, "Restoring resource fork\n");
 474             }
 475             flags = 0;
 476             if (extract_data(jcr, &altbfd, sd->msg, sd->msglen, &alt_addr, flags,
 477                              cipher_ctx, cipher_block_size) < 0) {
 478                extract = false;
 479                bclose(&altbfd);
 480                continue;
 481             }
 482          }
 483 #else
 484          non_support_rsrc++;
 485 #endif
 486          break;
 487
 488       case STREAM_HFSPLUS_ATTRIBUTES:
 489 #ifdef HAVE_DARWIN_OS
 490          Dmsg0(30, "Restoring Finder Info\n");
 491          if (sd->msglen != 32) {
 492             Jmsg(jcr, M_ERROR, 0, _("     Invalid length of Finder Info (got %d, not 32)\n"), sd->msglen);
 493             continue;
 494          }
 495          if (setattrlist(jcr->last_fname, &attrList, sd->msg, sd->msglen, 0) != 0) {
 496             Jmsg(jcr, M_ERROR, 0, _("     Could not set Finder Info on %s\n"), jcr->last_fname);
 497             continue;
 498          }
 499 #else
 500          non_support_finfo++;
 501 #endif
 502
 503       case STREAM_UNIX_ATTRIBUTES_ACCESS_ACL:
 504 #ifdef HAVE_ACL
 505          pm_strcpy(jcr->acl_text, sd->msg);
 506          Dmsg2(400, "Restoring ACL type 0x%2x <%s>\n", BACL_TYPE_ACCESS, jcr->acl_text);
 507          if (bacl_set(jcr, BACL_TYPE_ACCESS) != 0) {
 508                Qmsg1(jcr, M_WARNING, 0, _("Can't restore ACL of %s\n"), jcr->last_fname);
 509          }
 510 #else
 511          non_support_acl++;
 512 #endif
 513          break;
 514
 515       case STREAM_UNIX_ATTRIBUTES_DEFAULT_ACL:
 516 #ifdef HAVE_ACL
 517          pm_strcpy(jcr->acl_text, sd->msg);
 518          Dmsg2(400, "Restoring ACL type 0x%2x <%s>\n", BACL_TYPE_DEFAULT, jcr->acl_text);
 519          if (bacl_set(jcr, BACL_TYPE_DEFAULT) != 0) {
 520                Qmsg1(jcr, M_WARNING, 0, _("Can't restore default ACL of %s\n"), jcr->last_fname);
 521          }
 522 #else
 523          non_support_acl++;
 524 #endif
 525          break;
 526
 527       case STREAM_SIGNED_DIGEST:
 528          /* Save signature. */
 529          if (extract && (sig = crypto_sign_decode((uint8_t *)sd->msg, (uint32_t)sd->msglen)) == NULL) {
 530             Jmsg1(jcr, M_ERROR, 0, _("Failed to decode message signature for %s\n"), jcr->last_fname);
 531          }
 532          break;
 533
 534       case STREAM_MD5_DIGEST:
 535       case STREAM_SHA1_DIGEST:
 536       case STREAM_SHA256_DIGEST:
 537       case STREAM_SHA512_DIGEST:
 538          break;
 539
 540       case STREAM_PROGRAM_NAMES:
 541       case STREAM_PROGRAM_DATA:
 542          if (!non_support_progname) {
 543             Pmsg0(000, "Got Program Name or Data Stream. Ignored.\n");
 544             non_support_progname++;
 545          }
 546          break;
 547
 548       default:
 549          /* If extracting, wierd stream (not 1 or 2), close output file anyway */
 550          if (extract) {
 551             Dmsg1(30, "Found wierd stream %d\n", stream);
 552             if (size > 0 && !is_bopen(&bfd)) {
 553                Jmsg0(jcr, M_ERROR, 0, _("Logic error: output file should be open\n"));
 554             }
 555             /* Flush and deallocate cipher context */
 556             if (cipher_ctx) {
 557                flush_cipher(jcr, &bfd, flags, cipher_ctx, cipher_block_size);
 558                crypto_cipher_free(cipher_ctx);
 559                cipher_ctx = NULL;
 560             }
 561             set_attributes(jcr, attr, &bfd);
 562
 563             /* Verify the cryptographic signature if any */
 564             if (jcr->pki_sign) {
 565                if (sig) {
 566                   // Failure is reported in verify_signature() ...
 567                   verify_signature(jcr, sig);
 568                } else {
 569                   Jmsg1(jcr, M_ERROR, 0, _("Missing cryptographic signature for %s\n"), jcr->last_fname);
 570                }
 571             }
 572
 573             extract = false;
 574          } else if (is_bopen(&bfd)) {
 575             Jmsg0(jcr, M_ERROR, 0, _("Logic error: output file should not be open\n"));
 576             bclose(&bfd);
 577          }
 578          Jmsg(jcr, M_ERROR, 0, _("Unknown stream=%d ignored. This shouldn't happen!\n"), stream);
 579          Dmsg2(0, "None of above!!! stream=%d data=%s\n", stream,sd->msg);
 580          break;
 581       } /* end switch(stream) */
 582
 583    } /* end while get_msg() */
 584
 585    /* If output file is still open, it was the last one in the
 586     * archive since we just hit an end of file, so close the file.
 587     */
 588    if (is_bopen(&altbfd)) {
 589       bclose_chksize(jcr, &altbfd, alt_size);
 590    }
 591    if (extract) {
 592       /* Flush and deallocate cipher context */
 593       if (cipher_ctx) {
 594          flush_cipher(jcr, &bfd, flags, cipher_ctx, cipher_block_size);
 595          crypto_cipher_free(cipher_ctx);
 596          cipher_ctx = NULL;
 597       }
 598       set_attributes(jcr, attr, &bfd);
 599
 600       /* Verify the cryptographic signature on the last file, if any */
 601       if (jcr->pki_sign) {
 602          if (sig) {
 603             // Failure is reported in verify_signature() ...
 604             verify_signature(jcr, sig);
 605          } else {
 606             Jmsg1(jcr, M_ERROR, 0, _("Missing cryptographic signature for %s\n"), jcr->last_fname);
 607          }
 608       }
 609    }
 610
 611    if (is_bopen(&bfd)) {
 612       bclose(&bfd);
 613    }
 614
 615    set_jcr_job_status(jcr, JS_Terminated);
 616    goto ok_out;
 617
 618 bail_out:
 619    set_jcr_job_status(jcr, JS_ErrorTerminated);
 620 ok_out:
 621
 622    /* Free Signature & Crypto Data */
 623    if (sig) {
 624       crypto_sign_free(sig);
 625       sig = NULL;
 626    }
 627    if (cs) {
 628       crypto_session_free(cs);
 629       cs = NULL;
 630    }
 631    if (cipher_ctx) {
 632       crypto_cipher_free(cipher_ctx);
 633       cipher_ctx = NULL;
 634    }
 635    if (jcr->compress_buf) {
 636       free(jcr->compress_buf);
 637       jcr->compress_buf = NULL;
 638       jcr->compress_buf_size = 0;
 639    }
 640    if (jcr->crypto_buf) {
 641       free_pool_memory(jcr->crypto_buf);
 642       jcr->crypto_buf = NULL;
 643    }
 644    bclose(&altbfd);
 645    bclose(&bfd);
 646    free_attr(attr);
 647    free_pool_memory(jcr->acl_text);
 648    Dmsg2(10, "End Do Restore. Files=%d Bytes=%s\n", jcr->JobFiles,
 649       edit_uint64(jcr->JobBytes, ec1));
 650    if (non_support_data > 1 || non_support_attr > 1) {
 651       Jmsg(jcr, M_ERROR, 0, _("%d non-supported data streams and %d non-supported attrib streams ignored.\n"),
 652          non_support_data, non_support_attr);
 653    }
 654    if (non_support_rsrc) {
 655       Jmsg(jcr, M_INFO, 0, _("%d non-supported resource fork streams ignored.\n"), non_support_rsrc);
 656    }
 657    if (non_support_finfo) {
 658       Jmsg(jcr, M_INFO, 0, _("%d non-supported Finder Info streams ignored.\n"), non_support_rsrc);
 659    }
 660    if (non_support_acl) {
 661       Jmsg(jcr, M_INFO, 0, _("%d non-supported acl streams ignored.\n"), non_support_acl);
 662    }
 663
 664 }
 665
 666 /*
 667  * Convert ZLIB error code into an ASCII message
 668  */
 669 static const char *zlib_strerror(int stat)
 670 {
 671    if (stat >= 0) {
 672       return _("None");
 673    }
 674    switch (stat) {
 675    case Z_ERRNO:
 676       return _("Zlib errno");
 677    case Z_STREAM_ERROR:
 678       return _("Zlib stream error");
 679    case Z_DATA_ERROR:
 680       return _("Zlib data error");
 681    case Z_MEM_ERROR:
 682       return _("Zlib memory error");
 683    case Z_BUF_ERROR:
 684       return _("Zlib buffer error");
 685    case Z_VERSION_ERROR:
 686       return _("Zlib version error");
 687    default:
 688       return _("*none*");
 689    }
 690 }
 691
 692 static int do_file_digest(FF_PKT *ff_pkt, void *pkt, bool top_level)
 693 {
 694    JCR *jcr = (JCR *)pkt;
 695    return (digest_file(jcr, ff_pkt, jcr->digest));
 696 }
 697
 698 /*
 699  * Verify the signature for the last restored file
 700  * Return value is either true (signature correct)
 701  * or false (signature could not be verified).
 702  * TODO landonf: Better signature failure handling.
 703  */
 704 int verify_signature(JCR *jcr, SIGNATURE *sig)
 705 {
 706    X509_KEYPAIR *keypair;
 707    DIGEST *digest = NULL;
 708    crypto_error_t err;
 709
 710    /* Iterate through the trusted signers */
 711    foreach_alist(keypair, jcr->pki_signers) {
 712       err = crypto_sign_get_digest(sig, jcr->pki_keypair, &digest);
 713
 714       switch (err) {
 715       case CRYPTO_ERROR_NONE:
 716          /* Signature found, digest allocated */
 717          jcr->digest = digest;
 718
 719          /* Checksum the entire file */
 720          if (find_one_file(jcr, jcr->ff, do_file_digest, jcr, jcr->last_fname, (dev_t)-1, 1) != 0) {
 721             Qmsg(jcr, M_ERROR, 0, _("Signature validation failed for %s: \n"), jcr->last_fname);
 722             return false;
 723          }
 724
 725          /* Verify the signature */
 726          if ((err = crypto_sign_verify(sig, keypair, digest)) != CRYPTO_ERROR_NONE) {
 727             Dmsg1(100, "Bad signature on %s\n", jcr->last_fname);
 728             Qmsg2(jcr, M_ERROR, 0, _("Signature validation failed for %s: %s\n"), jcr->last_fname, crypto_strerror(err));
 729             crypto_digest_free(digest);
 730             return false;
 731          }
 732
 733          /* Valid signature */
 734          Dmsg1(100, "Signature good on %s\n", jcr->last_fname);
 735          crypto_digest_free(digest);
 736          return true;
 737
 738       case CRYPTO_ERROR_NOSIGNER:
 739          /* Signature not found, try again */
 740          continue;
 741       default:
 742          /* Something strange happened (that shouldn't happen!)... */
 743          Qmsg2(jcr, M_ERROR, 0, _("Signature validation failed for %s: %s\n"), jcr->last_fname, crypto_strerror(err));
 744          if (digest) {
 745             crypto_digest_free(digest);
 746          }
 747          return false;
 748       }
 749    }
 750
 751    /* No signer */
 752    Dmsg1(100, "Could not find a valid public key for signature on %s\n", jcr->last_fname);
 753    crypto_digest_free(digest);
 754    return false;
 755 }
 756
 757 bool decompress_data(JCR *jcr, char **data, uint32_t *length)
 758 {
 759 #ifdef HAVE_LIBZ
 760    uLong compress_len;
 761    int stat;
 762    char ec1[50];                      /* Buffer printing huge values */
 763
 764    /*
 765     * NOTE! We only use uLong and Byte because they are
 766     *  needed by the zlib routines, they should not otherwise
 767     *  be used in Bacula.
 768     */
 769    compress_len = jcr->compress_buf_size;
 770    Dmsg2(100, "Comp_len=%d msglen=%d\n", compress_len, *length);
 771    if ((stat=uncompress((Byte *)jcr->compress_buf, &compress_len,
 772                (const Byte *)*data, (uLong)*length)) != Z_OK) {
 773       Qmsg(jcr, M_ERROR, 0, _("Uncompression error on file %s. ERR=%s\n"),
 774             jcr->last_fname, zlib_strerror(stat));
 775       return false;
 776    }
 777    *data = jcr->compress_buf;
 778    *length = compress_len;
 779    Dmsg2(100, "Write uncompressed %d bytes, total before write=%s\n", compress_len, edit_uint64(jcr->JobBytes, ec1));
 780    return true;
 781 #else
 782    Qmsg(jcr, M_ERROR, 0, _("GZIP data stream found, but GZIP not configured!\n"));
 783    return false;
 784 #endif
 785 }
 786
 787 static void unser_crypto_size(JCR *jcr)
 788 {
 789    unser_declare;
 790    if (jcr->crypto_size == 0 && jcr->crypto_count >= CRYPTO_LEN_SIZE) {
 791       unser_begin(&jcr->crypto_buf[0], CRYPTO_LEN_SIZE);
 792       unser_uint32(jcr->crypto_size);
 793       jcr->crypto_size += CRYPTO_LEN_SIZE;
 794    }
 795 }
 796
 797 bool store_data(JCR *jcr, BFILE *bfd, char *data, const int32_t length, bool win32_decomp)
 798 {
 799    if (win32_decomp) {
 800       if (!processWin32BackupAPIBlock(bfd, data, length)) {
 801          berrno be;
 802          Jmsg2(jcr, M_ERROR, 0, _("Write error in Win32 Block Decomposition on %s: %s\n"),
 803                jcr->last_fname, be.strerror(bfd->berrno));
 804          return false;
 805       }
 806    } else if (bwrite(bfd, data, length) != (ssize_t)length) {
 807       berrno be;
 808       Jmsg2(jcr, M_ERROR, 0, _("Write error on %s: %s\n"),
 809             jcr->last_fname, be.strerror(bfd->berrno));
 810       return false;
 811    }
 812
 813    return true;
 814 }
 815
 816 /*
 817  * In the context of jcr, write data to bfd.
 818  * We write buflen bytes in buf at addr. addr is updated in place.
 819  * The flags specify whether to use sparse files or compression.
 820  * Return value is the number of bytes written, or -1 on errors.
 821  */
 822 int32_t extract_data(JCR *jcr, BFILE *bfd, POOLMEM *buf, int32_t buflen,
 823       uint64_t *addr, int flags, CIPHER_CONTEXT *cipher, uint32_t cipher_block_size)
 824 {
 825    char *wbuf;                        /* write buffer */
 826    uint32_t wsize;                    /* write size */
 827    uint32_t rsize;                    /* read size */
 828    uint32_t decrypted_len = 0;        /* Decryption output length */
 829    char ec1[50];                      /* Buffer printing huge values */
 830
 831    rsize = buflen;
 832    jcr->ReadBytes += rsize;
 833    wsize = rsize;
 834    wbuf = buf;
 835
 836    if (flags & FO_ENCRYPT) {
 837       ASSERT(cipher);
 838
 839       while (jcr->crypto_size > 0 && jcr->crypto_count > 0 && wsize > 0) {
 840          uint32_t chunk_size = 16;
 841
 842          if (chunk_size > wsize) {
 843             chunk_size = wsize;
 844          }
 845
 846          /*
 847           * Grow the crypto buffer, if necessary.
 848           * crypto_cipher_update() will process only whole blocks,
 849           * buffering the remaining input.
 850           */
 851          jcr->crypto_buf = check_pool_memory_size(jcr->crypto_buf,
 852                            jcr->crypto_count + chunk_size + cipher_block_size);
 853
 854          /* Decrypt the input block */
 855          if (!crypto_cipher_update(cipher,
 856                                    (const u_int8_t *)wbuf,
 857                                    chunk_size,
 858                                    (u_int8_t *)&jcr->crypto_buf[jcr->crypto_count],
 859                                    &decrypted_len)) {
 860             /* Decryption failed. Shouldn't happen. */
 861             Jmsg(jcr, M_FATAL, 0, _("Decryption error\n"));
 862             return -1;
 863          }
 864
 865          jcr->crypto_count += decrypted_len;
 866          wbuf += chunk_size;
 867          wsize -= chunk_size;
 868
 869          if (jcr->crypto_count >= jcr->crypto_size) {
 870             char *packet = &jcr->crypto_buf[CRYPTO_LEN_SIZE]; /* Decrypted, possibly decompressed output here. */
 871             uint32_t packet_size = jcr->crypto_size - CRYPTO_LEN_SIZE;
 872
 873             if (flags & FO_GZIP) {
 874                if (!decompress_data(jcr, &packet, &packet_size)) {
 875                   return -1;
 876                }
 877             } else {
 878                Dmsg2(30, "Write %u bytes, total before write=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
 879             }
 880
 881             if (!store_data(jcr, bfd, packet, packet_size, (flags & FO_WIN32DECOMP) != 0)) {
 882                return -1;
 883             }
 884
 885             jcr->JobBytes += packet_size;
 886             *addr += packet_size;
 887
 888             memmove(&jcr->crypto_buf[0], &jcr->crypto_buf[jcr->crypto_size],
 889                     jcr->crypto_count - jcr->crypto_size);
 890             jcr->crypto_count -= jcr->crypto_size;
 891             jcr->crypto_size = 0;
 892          }
 893       }
 894
 895       /*
 896        * Grow the crypto buffer, if necessary.
 897        * crypto_cipher_update() will process only whole blocks,
 898        * buffering the remaining input.
 899        */
 900       jcr->crypto_buf = check_pool_memory_size(jcr->crypto_buf,
 901                         jcr->crypto_count + wsize + cipher_block_size);
 902
 903       /* Decrypt the input block */
 904       if (!crypto_cipher_update(cipher,
 905                                 (const u_int8_t *)wbuf,
 906                                 wsize,
 907                                 (u_int8_t *)&jcr->crypto_buf[jcr->crypto_count],
 908                                 &decrypted_len)) {
 909          /* Decryption failed. Shouldn't happen. */
 910          Jmsg(jcr, M_FATAL, 0, _("Decryption error\n"));
 911          return -1;
 912       }
 913
 914       Dmsg2(100, "decrypted len=%d encrypted len=%d\n", decrypted_len, wsize);
 915
 916       if (decrypted_len == 0) {
 917          /* No full block of data available, write more data */
 918          return 0;
 919       }
 920
 921       jcr->crypto_count += decrypted_len;
 922
 923       unser_crypto_size(jcr);
 924       wsize = jcr->crypto_size - CRYPTO_LEN_SIZE;
 925       Dmsg1(10, "Decrypt size=%d\n", wsize);
 926       wbuf = &jcr->crypto_buf[CRYPTO_LEN_SIZE]; /* Decrypted, possibly decompressed output here. */
 927
 928       if (jcr->crypto_size == 0 || jcr->crypto_count < jcr->crypto_size) {
 929          return 0;
 930       }
 931
 932    }
 933
 934    if (flags & FO_SPARSE) {
 935       unser_declare;
 936       uint64_t faddr;
 937       char ec1[50];
 938       unser_begin(wbuf, SPARSE_FADDR_SIZE);
 939       unser_uint64(faddr);
 940       if (*addr != faddr) {
 941          *addr = faddr;
 942          if (blseek(bfd, (boffset_t)*addr, SEEK_SET) < 0) {
 943             berrno be;
 944             Jmsg3(jcr, M_ERROR, 0, _("Seek to %s error on %s: ERR=%s\n"),
 945                   edit_uint64(*addr, ec1), jcr->last_fname,
 946                   be.strerror(bfd->berrno));
 947             return -1;
 948          }
 949       }
 950       wbuf += SPARSE_FADDR_SIZE;
 951       wsize -= SPARSE_FADDR_SIZE;
 952    }
 953
 954    if (flags & FO_GZIP) {
 955       if (!decompress_data(jcr, &wbuf, &wsize)) {
 956          return -1;
 957       }
 958    } else {
 959       Dmsg2(30, "Write %u bytes, total before write=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
 960    }
 961
 962    if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
 963       return -1;
 964    }
 965
 966    jcr->JobBytes += wsize;
 967    *addr += wsize;
 968
 969    return wsize;
 970 }
 971
 972 /*
 973  * In the context of jcr, flush any remaining data from the cipher context,
 974  * writing it to bfd.
 975  * Return value is true on success, false on failure.
 976  */
 977 bool flush_cipher(JCR *jcr, BFILE *bfd, int flags, CIPHER_CONTEXT *cipher,
 978                   uint32_t cipher_block_size)
 979 {
 980    uint32_t decrypted_len;
 981    char *wbuf;                        /* write buffer */
 982    uint32_t wsize;                    /* write size */
 983    char ec1[50];                      /* Buffer printing huge values */
 984
 985    /* Write out the remaining block and free the cipher context */
 986    jcr->crypto_buf = check_pool_memory_size(jcr->crypto_buf, jcr->crypto_count +
 987                      cipher_block_size);
 988
 989    if (!crypto_cipher_finalize(cipher, (uint8_t *)&jcr->crypto_buf[jcr->crypto_count],
 990         &decrypted_len)) {
 991       /* Writing out the final, buffered block failed. Shouldn't happen. */
 992       Jmsg1(jcr, M_FATAL, 0, _("Decryption error for %s\n"), jcr->last_fname);
 993    }
 994
 995    /* If nothing new was decrypted, and our output buffer is empty, return */
 996    if (decrypted_len == 0 && jcr->crypto_count == 0) {
 997       return true;
 998    }
 999
1000    jcr->crypto_count += decrypted_len;
1001
1002    unser_crypto_size(jcr);
1003    wsize = jcr->crypto_size - CRYPTO_LEN_SIZE;
1004    Dmsg1(10, "Unser size=%d\n", wsize);
1005    wbuf = &jcr->crypto_buf[CRYPTO_LEN_SIZE]; /* Decrypted, possibly decompressed output here. */
1006
1007    ASSERT(jcr->crypto_count == jcr->crypto_size);
1008
1009    if (flags & FO_GZIP) {
1010       decompress_data(jcr, &wbuf, &wsize);
1011    } else {
1012       Dmsg2(30, "Write %u bytes, total before write=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1013    }
1014
1015    if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1016       return false;
1017    }
1018
1019    jcr->JobBytes += wsize;
1020
1021    return true;
1022 }