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