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 /*
 746  * Convert ZLIB error code into an ASCII message
 747  */
 748 static const char *zlib_strerror(int stat)
 749 {
 750    if (stat >= 0) {
 751       return _("None");
 752    }
 753    switch (stat) {
 754    case Z_ERRNO:
 755       return _("Zlib errno");
 756    case Z_STREAM_ERROR:
 757       return _("Zlib stream error");
 758    case Z_DATA_ERROR:
 759       return _("Zlib data error");
 760    case Z_MEM_ERROR:
 761       return _("Zlib memory error");
 762    case Z_BUF_ERROR:
 763       return _("Zlib buffer error");
 764    case Z_VERSION_ERROR:
 765       return _("Zlib version error");
 766    default:
 767       return _("*none*");
 768    }
 769 }
 770
 771 static int do_file_digest(FF_PKT *ff_pkt, void *pkt, bool top_level)
 772 {
 773    JCR *jcr = (JCR *)pkt;
 774    return (digest_file(jcr, ff_pkt, jcr->digest));
 775 }
 776
 777 /*
 778  * Verify the signature for the last restored file
 779  * Return value is either true (signature correct)
 780  * or false (signature could not be verified).
 781  * TODO landonf: Implement without using find_one_file and
 782  * without re-reading the file.
 783  */
 784 int verify_signature(JCR *jcr, SIGNATURE *sig)
 785 {
 786    X509_KEYPAIR *keypair;
 787    DIGEST *digest = NULL;
 788    crypto_error_t err;
 789    uint64_t saved_bytes;
 790
 791    /* Iterate through the trusted signers */
 792    foreach_alist(keypair, jcr->pki_signers) {
 793       err = crypto_sign_get_digest(sig, jcr->pki_keypair, &digest);
 794
 795       switch (err) {
 796       case CRYPTO_ERROR_NONE:
 797          /* Signature found, digest allocated */
 798          jcr->digest = digest;
 799
 800          /* Checksum the entire file */
 801          /* Make sure we don't modify JobBytes by saving and restoring it */
 802          saved_bytes = jcr->JobBytes;
 803          if (find_one_file(jcr, jcr->ff, do_file_digest, jcr, jcr->last_fname, (dev_t)-1, 1) != 0) {
 804             Jmsg(jcr, M_ERROR, 0, _("Signature validation failed for %s: \n"), jcr->last_fname);
 805             jcr->JobBytes = saved_bytes;
 806             return false;
 807          }
 808          jcr->JobBytes = saved_bytes;
 809
 810          /* Verify the signature */
 811          if ((err = crypto_sign_verify(sig, keypair, digest)) != CRYPTO_ERROR_NONE) {
 812             Dmsg1(100, "Bad signature on %s\n", jcr->last_fname);
 813             Jmsg2(jcr, M_ERROR, 0, _("Signature validation failed for %s: %s\n"), jcr->last_fname, crypto_strerror(err));
 814             crypto_digest_free(digest);
 815             return false;
 816          }
 817
 818          /* Valid signature */
 819          Dmsg1(100, "Signature good on %s\n", jcr->last_fname);
 820          crypto_digest_free(digest);
 821          return true;
 822
 823       case CRYPTO_ERROR_NOSIGNER:
 824          /* Signature not found, try again */
 825          continue;
 826       default:
 827          /* Something strange happened (that shouldn't happen!)... */
 828          Qmsg2(jcr, M_ERROR, 0, _("Signature validation failed for %s: %s\n"), jcr->last_fname, crypto_strerror(err));
 829          if (digest) {
 830             crypto_digest_free(digest);
 831          }
 832          return false;
 833       }
 834    }
 835
 836    /* No signer */
 837    Dmsg1(100, "Could not find a valid public key for signature on %s\n", jcr->last_fname);
 838    crypto_digest_free(digest);
 839    return false;
 840 }
 841
 842 bool sparse_data(JCR *jcr, BFILE *bfd, uint64_t *addr, char **data, uint32_t *length)
 843 {
 844       unser_declare;
 845       uint64_t faddr;
 846       char ec1[50];
 847       unser_begin(*data, SPARSE_FADDR_SIZE);
 848       unser_uint64(faddr);
 849       if (*addr != faddr) {
 850          *addr = faddr;
 851          if (blseek(bfd, (boffset_t)*addr, SEEK_SET) < 0) {
 852             berrno be;
 853             Jmsg3(jcr, M_ERROR, 0, _("Seek to %s error on %s: ERR=%s\n"),
 854                   edit_uint64(*addr, ec1), jcr->last_fname,
 855                   be.strerror(bfd->berrno));
 856             return false;
 857          }
 858       }
 859       *data += SPARSE_FADDR_SIZE;
 860       *length -= SPARSE_FADDR_SIZE;
 861       return true;
 862 }
 863
 864 bool decompress_data(JCR *jcr, char **data, uint32_t *length)
 865 {
 866 #ifdef HAVE_LIBZ
 867    uLong compress_len;
 868    int stat;
 869    char ec1[50];                      /* Buffer printing huge values */
 870
 871    /*
 872     * NOTE! We only use uLong and Byte because they are
 873     *  needed by the zlib routines, they should not otherwise
 874     *  be used in Bacula.
 875     */
 876    compress_len = jcr->compress_buf_size;
 877    Dmsg2(100, "Comp_len=%d msglen=%d\n", compress_len, *length);
 878    if ((stat=uncompress((Byte *)jcr->compress_buf, &compress_len,
 879                (const Byte *)*data, (uLong)*length)) != Z_OK) {
 880       Qmsg(jcr, M_ERROR, 0, _("Uncompression error on file %s. ERR=%s\n"),
 881             jcr->last_fname, zlib_strerror(stat));
 882       return false;
 883    }
 884    *data = jcr->compress_buf;
 885    *length = compress_len;
 886    Dmsg2(100, "Write uncompressed %d bytes, total before write=%s\n", compress_len, edit_uint64(jcr->JobBytes, ec1));
 887    return true;
 888 #else
 889    Qmsg(jcr, M_ERROR, 0, _("GZIP data stream found, but GZIP not configured!\n"));
 890    return false;
 891 #endif
 892 }
 893
 894 static void unser_crypto_packet_len(RESTORE_CIPHER_CTX *ctx)
 895 {
 896    unser_declare;
 897    if (ctx->packet_len == 0 && ctx->buf_len >= CRYPTO_LEN_SIZE) {
 898       unser_begin(&ctx->buf[0], CRYPTO_LEN_SIZE);
 899       unser_uint32(ctx->packet_len);
 900       ctx->packet_len += CRYPTO_LEN_SIZE;
 901    }
 902 }
 903
 904 bool store_data(JCR *jcr, BFILE *bfd, char *data, const int32_t length, bool win32_decomp)
 905 {
 906    if (win32_decomp) {
 907       if (!processWin32BackupAPIBlock(bfd, data, length)) {
 908          berrno be;
 909          Jmsg2(jcr, M_ERROR, 0, _("Write error in Win32 Block Decomposition on %s: %s\n"),
 910                jcr->last_fname, be.strerror(bfd->berrno));
 911          return false;
 912       }
 913    } else if (bwrite(bfd, data, length) != (ssize_t)length) {
 914       berrno be;
 915       Jmsg2(jcr, M_ERROR, 0, _("Write error on %s: %s\n"),
 916             jcr->last_fname, be.strerror(bfd->berrno));
 917       return false;
 918    }
 919
 920    return true;
 921 }
 922
 923 /*
 924  * In the context of jcr, write data to bfd.
 925  * We write buflen bytes in buf at addr. addr is updated in place.
 926  * The flags specify whether to use sparse files or compression.
 927  * Return value is the number of bytes written, or -1 on errors.
 928  */
 929 int32_t extract_data(JCR *jcr, BFILE *bfd, POOLMEM *buf, int32_t buflen,
 930       uint64_t *addr, int flags, RESTORE_CIPHER_CTX *cipher_ctx)
 931 {
 932    char *wbuf;                        /* write buffer */
 933    uint32_t wsize;                    /* write size */
 934    uint32_t rsize;                    /* read size */
 935    uint32_t decrypted_len = 0;        /* Decryption output length */
 936    char ec1[50];                      /* Buffer printing huge values */
 937
 938    rsize = buflen;
 939    jcr->ReadBytes += rsize;
 940    wsize = rsize;
 941    wbuf = buf;
 942
 943    if (flags & FO_ENCRYPT) {
 944       ASSERT(cipher_ctx->cipher);
 945
 946       /* NOTE: We must implement block preserving semantics for the
 947        * non-streaming compression and sparse code. */
 948
 949       /*
 950        * Grow the crypto buffer, if necessary.
 951        * crypto_cipher_update() will process only whole blocks,
 952        * buffering the remaining input.
 953        */
 954       cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf,
 955                         cipher_ctx->buf_len + wsize + cipher_ctx->block_size);
 956
 957       /* Decrypt the input block */
 958       if (!crypto_cipher_update(cipher_ctx->cipher,
 959                                 (const u_int8_t *)wbuf,
 960                                 wsize,
 961                                 (u_int8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
 962                                 &decrypted_len)) {
 963          /* Decryption failed. Shouldn't happen. */
 964          Jmsg(jcr, M_FATAL, 0, _("Decryption error\n"));
 965          return -1;
 966       }
 967
 968       if (decrypted_len == 0) {
 969          /* No full block of encrypted data available, write more data */
 970          return 0;
 971       }
 972
 973       Dmsg2(100, "decrypted len=%d encrypted len=%d\n", decrypted_len, wsize);
 974
 975       cipher_ctx->buf_len += decrypted_len;
 976       wbuf = cipher_ctx->buf;
 977
 978       /* If one full preserved block is available, write it to disk,
 979        * and then buffer any remaining data. This should be effecient
 980        * as long as Bacula's block size is not significantly smaller than the
 981        * encryption block size (extremely unlikely!) */
 982       unser_crypto_packet_len(cipher_ctx);
 983       Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
 984
 985       if (cipher_ctx->packet_len == 0 || cipher_ctx->buf_len < cipher_ctx->packet_len) {
 986          /* No full preserved block is available. */
 987          return 0;
 988       }
 989
 990       /* We have one full block, set up the filter input buffers */
 991       wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
 992       wbuf = &wbuf[CRYPTO_LEN_SIZE]; /* Skip the block length header */
 993       cipher_ctx->buf_len -= cipher_ctx->packet_len;
 994       Dmsg2(30, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
 995    }
 996
 997    if (flags & FO_SPARSE) {
 998       if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
 999          return -1;
1000       }
1001    }
1002
1003    if (flags & FO_GZIP) {
1004       if (!decompress_data(jcr, &wbuf, &wsize)) {
1005          return -1;
1006       }
1007    } else {
1008       Dmsg2(30, "Write %u bytes, total before write=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1009    }
1010
1011    if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1012       return -1;
1013    }
1014
1015    jcr->JobBytes += wsize;
1016    *addr += wsize;
1017
1018    /* Clean up crypto buffers */
1019    if (flags & FO_ENCRYPT) {
1020       /* Move any remaining data to start of buffer */
1021       if (cipher_ctx->buf_len > 0) {
1022          Dmsg1(30, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1023          memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1024             cipher_ctx->buf_len);
1025       }
1026       /* The packet was successfully written, reset the length so that the next
1027        * packet length may be re-read by unser_crypto_packet_len() */
1028       cipher_ctx->packet_len = 0;
1029    }
1030
1031    return wsize;
1032 }
1033
1034 /*
1035  * In the context of jcr, flush any remaining data from the cipher context,
1036  * writing it to bfd.
1037  * Return value is true on success, false on failure.
1038  */
1039 bool flush_cipher(JCR *jcr, BFILE *bfd, uint64_t *addr, int flags,
1040                   RESTORE_CIPHER_CTX *cipher_ctx)
1041 {
1042    uint32_t decrypted_len;
1043    char *wbuf;                        /* write buffer */
1044    uint32_t wsize;                    /* write size */
1045    char ec1[50];                      /* Buffer printing huge values */
1046
1047    /* Write out the remaining block and free the cipher context */
1048    cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf, cipher_ctx->buf_len +
1049                      cipher_ctx->block_size);
1050
1051    if (!crypto_cipher_finalize(cipher_ctx->cipher, (uint8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
1052         &decrypted_len)) {
1053       /* Writing out the final, buffered block failed. Shouldn't happen. */
1054       Jmsg1(jcr, M_FATAL, 0, _("Decryption error for %s\n"), jcr->last_fname);
1055    }
1056
1057    /* If nothing new was decrypted, and our output buffer is empty, return */
1058    if (decrypted_len == 0 && cipher_ctx->buf_len == 0) {
1059       return true;
1060    }
1061
1062    cipher_ctx->buf_len += decrypted_len;
1063
1064    unser_crypto_packet_len(cipher_ctx);
1065    Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1066    wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1067    wbuf = &cipher_ctx->buf[CRYPTO_LEN_SIZE]; /* Decrypted, possibly decompressed output here. */
1068
1069    if (cipher_ctx->buf_len != cipher_ctx->packet_len) {
1070       Jmsg2(jcr, M_FATAL, 0,
1071             _("Unexpected number of bytes remaining at end of file, received %u, expected %u\n"),
1072             cipher_ctx->packet_len, cipher_ctx->buf_len);
1073       return false;
1074    }
1075
1076    cipher_ctx->buf_len = 0;
1077    cipher_ctx->packet_len = 0;
1078
1079    if (flags & FO_SPARSE) {
1080       if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1081          return false;
1082       }
1083    }
1084
1085    if (flags & FO_GZIP) {
1086       decompress_data(jcr, &wbuf, &wsize);
1087    } else {
1088       Dmsg2(30, "Write %u bytes, total before write=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1089    }
1090
1091    if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1092       return false;
1093    }
1094
1095    jcr->JobBytes += wsize;
1096
1097    return true;
1098 }