2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of Kern Sibbald.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
29 * Bacula File Daemon restore.c Restorefiles.
31 * Kern Sibbald, November MM
42 const bool have_darwin_os = true;
44 const bool have_darwin_os = false;
47 #if defined(HAVE_CRYPTO)
48 const bool have_crypto = true;
50 const bool have_crypto = false;
54 const bool have_acl = true;
56 const bool have_acl = false;
60 const bool have_sha2 = true;
62 const bool have_sha2 = false;
65 #if defined(HAVE_XATTR)
66 const bool have_xattr = true;
68 const bool have_xattr = false;
71 /* Data received from Storage Daemon */
72 static char rec_header[] = "rechdr %ld %ld %ld %ld %ld";
74 typedef struct restore_cipher_ctx {
75 CIPHER_CONTEXT *cipher;
78 POOLMEM *buf; /* Pointer to descryption buffer */
79 int32_t buf_len; /* Count of bytes currently in buf */
80 int32_t packet_len; /* Total bytes in packet */
87 BFILE bfd; /* File content */
88 uint64_t fileAddr; /* file write address */
89 uint32_t size; /* Size of file */
90 int flags; /* Options for extract_data() */
91 BFILE forkbfd; /* Alternative data stream */
92 uint64_t fork_addr; /* Write address for alternative stream */
93 intmax_t fork_size; /* Size of alternate stream */
94 int fork_flags; /* Options for extract_data() */
95 int32_t type; /* file type FT_ */
96 ATTR *attr; /* Pointer to attributes */
97 bool extract; /* set when extracting */
99 SIGNATURE *sig; /* Cryptographic signature (if any) for file */
100 CRYPTO_SESSION *cs; /* Cryptographic session data (if any) for file */
101 RESTORE_CIPHER_CTX cipher_ctx; /* Cryptographic restore context (if any) for file */
102 RESTORE_CIPHER_CTX fork_cipher_ctx; /* Cryptographic restore context (if any) for alternative stream */
106 /* Forward referenced functions */
107 #if defined(HAVE_LIBZ)
108 static const char *zlib_strerror(int stat);
109 const bool have_libz = true;
111 const bool have_libz = false;
114 static void deallocate_cipher(r_ctx &rctx);
115 static void deallocate_fork_cipher(r_ctx &rctx);
116 static void free_signature(r_ctx &rctx);
117 static void free_session(r_ctx &rctx);
118 static void close_previous_stream(r_ctx &rctx);
122 static bool verify_signature(JCR *jcr, r_ctx &rctx);
123 int32_t extract_data(JCR *jcr, r_ctx &rctx, POOLMEM *buf, int32_t buflen,
124 uint64_t *addr, int flags, RESTORE_CIPHER_CTX *cipher_ctx);
125 bool flush_cipher(JCR *jcr, BFILE *bfd, uint64_t *addr, int flags,
126 RESTORE_CIPHER_CTX *cipher_ctx);
130 * Close a bfd check that we are at the expected file offset.
131 * Makes use of some code from set_attributes().
133 static int bclose_chksize(JCR *jcr, BFILE *bfd, boffset_t osize)
135 char ec1[50], ec2[50];
138 fsize = blseek(bfd, 0, SEEK_CUR);
139 bclose(bfd); /* first close file */
140 if (fsize > 0 && fsize != osize) {
141 Qmsg3(jcr, M_ERROR, 0, _("Size of data or stream of %s not correct. Original %s, restored %s.\n"),
142 jcr->last_fname, edit_uint64(osize, ec1),
143 edit_uint64(fsize, ec2));
151 * Restore the requested files.
154 void do_restore(JCR *jcr)
157 uint32_t VolSessionId, VolSessionTime;
159 char ec1[50]; /* Buffer printing huge values */
160 uint32_t buf_size; /* client buffer size */
162 intmax_t rsrc_len = 0; /* Original length of resource fork */
165 /* ***FIXME*** make configurable */
166 crypto_digest_t signing_algorithm = have_sha2 ?
167 CRYPTO_DIGEST_SHA256 : CRYPTO_DIGEST_SHA1;
168 memset(&rctx, 0, sizeof(rctx));
171 /* The following variables keep track of "known unknowns" */
172 int non_support_data = 0;
173 int non_support_attr = 0;
174 int non_support_rsrc = 0;
175 int non_support_finfo = 0;
176 int non_support_acl = 0;
177 int non_support_progname = 0;
178 int non_support_crypto = 0;
179 int non_support_xattr = 0;
181 #ifdef HAVE_DARWIN_OS
182 struct attrlist attrList;
183 memset(&attrList, 0, sizeof(attrList));
184 attrList.bitmapcount = ATTR_BIT_MAP_COUNT;
185 attrList.commonattr = ATTR_CMN_FNDRINFO;
189 sd = jcr->store_bsock;
190 set_jcr_job_status(jcr, JS_Running);
193 CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);
196 buf_size = client->max_network_buffer_size;
198 buf_size = 0; /* use default */
200 if (!bnet_set_buffer_size(sd, buf_size, BNET_SETBUF_WRITE)) {
201 set_jcr_job_status(jcr, JS_ErrorTerminated);
204 jcr->buf_size = sd->msglen;
206 /* St Bernard code goes here if implemented -- see end of file */
209 uint32_t compress_buf_size = jcr->buf_size + 12 + ((jcr->buf_size+999) / 1000) + 100;
210 jcr->compress_buf = (char *)bmalloc(compress_buf_size);
211 jcr->compress_buf_size = compress_buf_size;
215 rctx.cipher_ctx.buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
216 if (have_darwin_os) {
217 rctx.fork_cipher_ctx.buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
222 * Get a record from the Storage daemon. We are guaranteed to
223 * receive records in the following order:
224 * 1. Stream record header
225 * 2. Stream data (one or more of the following in the order given)
226 * a. Attributes (Unix or Win32)
227 * b. Possibly stream encryption session data (e.g., symmetric session key)
228 * c. File data for the file
229 * d. Alternate data stream (e.g. Resource Fork)
233 * h. Possibly a cryptographic signature
234 * i. Possibly MD5 or SHA1 record
237 * NOTE: We keep track of two bacula file descriptors:
238 * 1. bfd for file data.
239 * This fd is opened for non empty files when an attribute stream is
240 * encountered and closed when we find the next attribute stream.
241 * 2. fork_bfd for alternate data streams
242 * This fd is opened every time we encounter a new alternate data
243 * stream for the current file. When we find any other stream, we
245 * The expected size of the stream, fork_len, should be set when
247 * 3. Not all the stream data records are required -- e.g. if there
248 * is no fork, there is no alternate data stream, no ACL, ...
251 binit(&rctx.forkbfd);
252 attr = rctx.attr = new_attr(jcr);
254 jcr->acl_data = (acl_data_t *)malloc(sizeof(acl_data_t));
255 memset((caddr_t)jcr->acl_data, 0, sizeof(acl_data_t));
256 jcr->acl_data->content = get_pool_memory(PM_MESSAGE);
259 jcr->xattr_data = (xattr_data_t *)malloc(sizeof(xattr_data_t));
260 memset((caddr_t)jcr->xattr_data, 0, sizeof(xattr_data_t));
261 jcr->xattr_data->content = get_pool_memory(PM_MESSAGE);
264 while (bget_msg(sd) >= 0 && !job_canceled(jcr)) {
265 /* Remember previous stream type */
266 rctx.prev_stream = rctx.stream;
268 /* First we expect a Stream Record Header */
269 if (sscanf(sd->msg, rec_header, &VolSessionId, &VolSessionTime, &file_index,
270 &rctx.stream, &rctx.size) != 5) {
271 Jmsg1(jcr, M_FATAL, 0, _("Record header scan error: %s\n"), sd->msg);
274 Dmsg5(50, "Got hdr: Files=%d FilInx=%d size=%d Stream=%d, %s.\n",
275 jcr->JobFiles, file_index, rctx.size, rctx.stream, stream_to_ascii(rctx.stream));
277 /* * Now we expect the Stream Data */
278 if (bget_msg(sd) < 0) {
279 Jmsg1(jcr, M_FATAL, 0, _("Data record error. ERR=%s\n"), sd->bstrerror());
282 if (rctx.size != (uint32_t)sd->msglen) {
283 Jmsg2(jcr, M_FATAL, 0, _("Actual data size %d not same as header %d\n"),
284 sd->msglen, rctx.size);
285 Dmsg2(50, "Actual data size %d not same as header %d\n",
286 sd->msglen, rctx.size);
289 Dmsg3(130, "Got stream: %s len=%d extract=%d\n", stream_to_ascii(rctx.stream),
290 sd->msglen, rctx.extract);
292 /* If we change streams, close and reset alternate data streams */
293 if (rctx.prev_stream != rctx.stream) {
294 if (is_bopen(&rctx.forkbfd)) {
295 deallocate_fork_cipher(rctx);
296 bclose_chksize(jcr, &rctx.forkbfd, rctx.fork_size);
298 rctx.fork_size = -1; /* Use an impossible value and set a proper one below */
302 /* File Attributes stream */
303 switch (rctx.stream) {
304 case STREAM_UNIX_ATTRIBUTES:
305 case STREAM_UNIX_ATTRIBUTES_EX:
306 close_previous_stream(rctx); /* if any previous stream open, close it */
309 /* TODO: manage deleted files */
310 if (rctx.type == FT_DELETED) { /* deleted file */
315 * Unpack attributes and do sanity check them
317 if (!unpack_attributes_record(jcr, rctx.stream, sd->msg, attr)) {
321 if (file_index != attr->file_index) {
322 Jmsg(jcr, M_FATAL, 0, _("Record header file index %ld not equal record index %ld\n"),
323 file_index, attr->file_index);
324 Dmsg0(200, "File index error\n");
329 Dmsg3(200, "File %s\nattrib=%s\nattribsEx=%s\n", attr->fname,
330 attr->attr, attr->attrEx);
332 attr->data_stream = decode_stat(attr->attr, &attr->statp, &attr->LinkFI);
334 if (!is_restore_stream_supported(attr->data_stream)) {
335 if (!non_support_data++) {
336 Jmsg(jcr, M_ERROR, 0, _("%s stream not supported on this Client.\n"),
337 stream_to_ascii(attr->data_stream));
342 build_attr_output_fnames(jcr, attr);
345 * Try to actually create the file, which returns a status telling
346 * us if we need to extract or not.
348 jcr->num_files_examined++;
349 rctx.extract = false;
351 stat = plugin_create_file(jcr, attr, &rctx.bfd, jcr->replace);
353 stat = create_file(jcr, attr, &rctx.bfd, jcr->replace);
356 pm_strcpy(jcr->last_fname, attr->ofname);
357 jcr->last_type = attr->type;
359 Dmsg2(130, "Outfile=%s create_file stat=%d\n", attr->ofname, stat);
363 pm_strcpy(jcr->last_fname, attr->ofname);
364 jcr->last_type = attr->type;
366 case CF_EXTRACT: /* File created and we expect file data */
369 case CF_CREATED: /* File created, but there is no content */
372 print_ls_output(jcr, attr);
374 if (have_darwin_os) {
375 /* Only restore the resource fork for regular files */
376 from_base64(&rsrc_len, attr->attrEx);
377 if (attr->type == FT_REG && rsrc_len > 0) {
382 /* set attributes now because file will not be extracted */
384 plugin_set_attributes(jcr, attr, &rctx.bfd);
386 set_attributes(jcr, attr, &rctx.bfd);
394 case STREAM_ENCRYPTED_SESSION_DATA:
395 crypto_error_t cryptoerr;
397 /* Is this an unexpected session data entry? */
399 Jmsg0(jcr, M_ERROR, 0, _("Unexpected cryptographic session data stream.\n"));
400 rctx.extract = false;
405 /* Do we have any keys at all? */
406 if (!jcr->crypto.pki_recipients) {
407 Jmsg(jcr, M_ERROR, 0, _("No private decryption keys have been defined to decrypt encrypted backup data.\n"));
408 rctx.extract = false;
413 if (jcr->crypto.digest) {
414 crypto_digest_free(jcr->crypto.digest);
416 jcr->crypto.digest = crypto_digest_new(jcr, signing_algorithm);
417 if (!jcr->crypto.digest) {
418 Jmsg0(jcr, M_FATAL, 0, _("Could not create digest.\n"));
419 rctx.extract = false;
424 /* Decode and save session keys. */
425 cryptoerr = crypto_session_decode((uint8_t *)sd->msg, (uint32_t)sd->msglen,
426 jcr->crypto.pki_recipients, &rctx.cs);
428 case CRYPTO_ERROR_NONE:
431 case CRYPTO_ERROR_NORECIPIENT:
432 Jmsg(jcr, M_ERROR, 0, _("Missing private key required to decrypt encrypted backup data.\n"));
434 case CRYPTO_ERROR_DECRYPTION:
435 Jmsg(jcr, M_ERROR, 0, _("Decrypt of the session key failed.\n"));
438 /* Shouldn't happen */
439 Jmsg1(jcr, M_ERROR, 0, _("An error occurred while decoding encrypted session data stream: %s\n"), crypto_strerror(cryptoerr));
443 if (cryptoerr != CRYPTO_ERROR_NONE) {
444 rctx.extract = false;
451 case STREAM_FILE_DATA:
452 case STREAM_SPARSE_DATA:
453 case STREAM_WIN32_DATA:
454 case STREAM_GZIP_DATA:
455 case STREAM_SPARSE_GZIP_DATA:
456 case STREAM_WIN32_GZIP_DATA:
457 case STREAM_ENCRYPTED_FILE_DATA:
458 case STREAM_ENCRYPTED_WIN32_DATA:
459 case STREAM_ENCRYPTED_FILE_GZIP_DATA:
460 case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
461 /* Force an expected, consistent stream type here */
462 if (rctx.extract && (rctx.prev_stream == rctx.stream
463 || rctx.prev_stream == STREAM_UNIX_ATTRIBUTES
464 || rctx.prev_stream == STREAM_UNIX_ATTRIBUTES_EX
465 || rctx.prev_stream == STREAM_ENCRYPTED_SESSION_DATA)) {
468 if (rctx.stream == STREAM_SPARSE_DATA ||
469 rctx.stream == STREAM_SPARSE_GZIP_DATA) {
470 rctx.flags |= FO_SPARSE;
473 if (rctx.stream == STREAM_GZIP_DATA
474 || rctx.stream == STREAM_SPARSE_GZIP_DATA
475 || rctx.stream == STREAM_WIN32_GZIP_DATA
476 || rctx.stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
477 || rctx.stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
478 rctx.flags |= FO_GZIP;
481 if (rctx.stream == STREAM_ENCRYPTED_FILE_DATA
482 || rctx.stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
483 || rctx.stream == STREAM_ENCRYPTED_WIN32_DATA
484 || rctx.stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
485 /* Set up a decryption context */
486 if (!rctx.cipher_ctx.cipher) {
488 Jmsg1(jcr, M_ERROR, 0, _("Missing encryption session data stream for %s\n"), jcr->last_fname);
489 rctx.extract = false;
494 if ((rctx.cipher_ctx.cipher = crypto_cipher_new(rctx.cs, false,
495 &rctx.cipher_ctx.block_size)) == NULL) {
496 Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
498 rctx.extract = false;
503 rctx.flags |= FO_ENCRYPT;
506 if (is_win32_stream(rctx.stream) && !have_win32_api()) {
507 set_portable_backup(&rctx.bfd);
508 rctx.flags |= FO_WIN32DECOMP; /* "decompose" BackupWrite data */
511 if (extract_data(jcr, rctx, sd->msg, sd->msglen, &rctx.fileAddr,
512 rctx.flags, &rctx.cipher_ctx) < 0) {
519 /* Resource fork stream - only recorded after a file to be restored */
520 /* Silently ignore if we cannot write - we already reported that */
521 case STREAM_ENCRYPTED_MACOS_FORK_DATA:
522 case STREAM_MACOS_FORK_DATA:
523 #ifdef HAVE_DARWIN_OS
525 jcr->ff->flags |= FO_HFSPLUS;
527 if (rctx.stream == STREAM_ENCRYPTED_MACOS_FORK_DATA) {
528 rctx.fork_flags |= FO_ENCRYPT;
530 /* Set up a decryption context */
531 if (rctx.extract && !rctx.fork_cipher_ctx.cipher) {
533 Jmsg1(jcr, M_ERROR, 0, _("Missing encryption session data stream for %s\n"), jcr->last_fname);
534 rctx.extract = false;
539 if ((rctx.fork_cipher_ctx.cipher = crypto_cipher_new(rctx.cs, false, &rctx.fork_cipher_ctx.block_size)) == NULL) {
540 Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
542 rctx.extract = false;
550 if (rctx.prev_stream != rctx.stream) {
551 if (bopen_rsrc(&rctx.forkbfd, jcr->last_fname, O_WRONLY | O_TRUNC | O_BINARY, 0) < 0) {
552 Jmsg(jcr, M_ERROR, 0, _(" Cannot open resource fork for %s.\n"), jcr->last_fname);
553 rctx.extract = false;
557 rctx.fork_size = rsrc_len;
558 Dmsg0(130, "Restoring resource fork\n");
561 if (extract_data(jcr, rctx, sd->msg, sd->msglen, &rctx.fork_addr, rctx.fork_flags,
562 &rctx.fork_cipher_ctx) < 0) {
563 bclose(&rctx.forkbfd);
572 case STREAM_HFSPLUS_ATTRIBUTES:
573 #ifdef HAVE_DARWIN_OS
574 Dmsg0(130, "Restoring Finder Info\n");
575 jcr->ff->flags |= FO_HFSPLUS;
576 if (sd->msglen != 32) {
577 Jmsg(jcr, M_ERROR, 0, _(" Invalid length of Finder Info (got %d, not 32)\n"), sd->msglen);
580 if (setattrlist(jcr->last_fname, &attrList, sd->msg, sd->msglen, 0) != 0) {
581 Jmsg(jcr, M_ERROR, 0, _(" Could not set Finder Info on %s\n"), jcr->last_fname);
589 case STREAM_UNIX_ACCESS_ACL:
590 case STREAM_UNIX_DEFAULT_ACL:
591 case STREAM_ACL_AIX_TEXT:
592 case STREAM_ACL_DARWIN_ACCESS_ACL:
593 case STREAM_ACL_FREEBSD_DEFAULT_ACL:
594 case STREAM_ACL_FREEBSD_ACCESS_ACL:
595 case STREAM_ACL_HPUX_ACL_ENTRY:
596 case STREAM_ACL_IRIX_DEFAULT_ACL:
597 case STREAM_ACL_IRIX_ACCESS_ACL:
598 case STREAM_ACL_LINUX_DEFAULT_ACL:
599 case STREAM_ACL_LINUX_ACCESS_ACL:
600 case STREAM_ACL_TRU64_DEFAULT_ACL:
601 case STREAM_ACL_TRU64_DEFAULT_DIR_ACL:
602 case STREAM_ACL_TRU64_ACCESS_ACL:
603 case STREAM_ACL_SOLARIS_ACLENT:
604 case STREAM_ACL_SOLARIS_ACE:
606 * Do not restore ACLs when
607 * a) The current file is not extracted
608 * b) and it is not a directory (they are never "extracted")
609 * c) or the file name is empty
611 if ((!rctx.extract && jcr->last_type != FT_DIREND) || (*jcr->last_fname == 0)) {
615 pm_memcpy(jcr->acl_data->content, sd->msg, sd->msglen);
616 jcr->acl_data->content_length = sd->msglen;
617 switch (parse_acl_streams(jcr, rctx.stream)) {
618 case bacl_exit_fatal:
620 case bacl_exit_error:
622 * Non-fatal errors, count them and when the number is under ACL_REPORT_ERR_MAX_PER_JOB
623 * print the error message set by the lower level routine in jcr->errmsg.
625 if (jcr->acl_data->nr_errors < ACL_REPORT_ERR_MAX_PER_JOB) {
626 Qmsg(jcr, M_WARNING, 0, "%s", jcr->errmsg);
628 jcr->acl_data->nr_errors++;
638 case STREAM_XATTR_SOLARIS_SYS:
639 case STREAM_XATTR_SOLARIS:
640 case STREAM_XATTR_DARWIN:
641 case STREAM_XATTR_FREEBSD:
642 case STREAM_XATTR_LINUX:
643 case STREAM_XATTR_NETBSD:
645 * Do not restore Extended Attributes when
646 * a) The current file is not extracted
647 * b) and it is not a directory (they are never "extracted")
648 * c) or the file name is empty
650 if ((!rctx.extract && jcr->last_type != FT_DIREND) || (*jcr->last_fname == 0)) {
654 pm_memcpy(jcr->xattr_data->content, sd->msg, sd->msglen);
655 jcr->xattr_data->content_length = sd->msglen;
656 switch (parse_xattr_streams(jcr, rctx.stream)) {
657 case bxattr_exit_fatal:
659 case bxattr_exit_error:
661 * Non-fatal errors, count them and when the number is under XATTR_REPORT_ERR_MAX_PER_JOB
662 * print the error message set by the lower level routine in jcr->errmsg.
664 if (jcr->xattr_data->nr_errors < XATTR_REPORT_ERR_MAX_PER_JOB) {
665 Qmsg(jcr, M_WARNING, 0, "%s", jcr->errmsg);
667 jcr->xattr_data->nr_errors++;
677 case STREAM_SIGNED_DIGEST:
678 /* Is this an unexpected signature? */
680 Jmsg0(jcr, M_ERROR, 0, _("Unexpected cryptographic signature data stream.\n"));
681 free_signature(rctx);
684 /* Save signature. */
685 if (rctx.extract && (rctx.sig = crypto_sign_decode(jcr, (uint8_t *)sd->msg, (uint32_t)sd->msglen)) == NULL) {
686 Jmsg1(jcr, M_ERROR, 0, _("Failed to decode message signature for %s\n"), jcr->last_fname);
690 case STREAM_MD5_DIGEST:
691 case STREAM_SHA1_DIGEST:
692 case STREAM_SHA256_DIGEST:
693 case STREAM_SHA512_DIGEST:
696 case STREAM_PROGRAM_NAMES:
697 case STREAM_PROGRAM_DATA:
698 if (!non_support_progname) {
699 Pmsg0(000, "Got Program Name or Data Stream. Ignored.\n");
700 non_support_progname++;
704 case STREAM_PLUGIN_NAME:
705 close_previous_stream(rctx);
706 Dmsg1(50, "restore stream_plugin_name=%s\n", sd->msg);
707 plugin_name_stream(jcr, sd->msg);
711 close_previous_stream(rctx);
712 Jmsg(jcr, M_ERROR, 0, _("Unknown stream=%d ignored. This shouldn't happen!\n"),
714 Dmsg2(0, "Unknown stream=%d data=%s\n", rctx.stream, sd->msg);
716 } /* end switch(stream) */
718 } /* end while get_msg() */
721 * If output file is still open, it was the last one in the
722 * archive since we just hit an end of file, so close the file.
724 if (is_bopen(&rctx.forkbfd)) {
725 bclose_chksize(jcr, &rctx.forkbfd, rctx.fork_size);
728 close_previous_stream(rctx);
729 set_jcr_job_status(jcr, JS_Terminated);
733 set_jcr_job_status(jcr, JS_ErrorTerminated);
737 * First output the statistics.
739 Dmsg2(10, "End Do Restore. Files=%d Bytes=%s\n", jcr->JobFiles,
740 edit_uint64(jcr->JobBytes, ec1));
741 if (have_acl && jcr->acl_data->nr_errors > 0) {
742 Jmsg(jcr, M_ERROR, 0, _("Encountered %ld acl errors while doing restore\n"),
743 jcr->acl_data->nr_errors);
745 if (have_xattr && jcr->xattr_data->nr_errors > 0) {
746 Jmsg(jcr, M_ERROR, 0, _("Encountered %ld xattr errors while doing restore\n"),
747 jcr->xattr_data->nr_errors);
749 if (non_support_data > 1 || non_support_attr > 1) {
750 Jmsg(jcr, M_ERROR, 0, _("%d non-supported data streams and %d non-supported attrib streams ignored.\n"),
751 non_support_data, non_support_attr);
753 if (non_support_rsrc) {
754 Jmsg(jcr, M_INFO, 0, _("%d non-supported resource fork streams ignored.\n"), non_support_rsrc);
756 if (non_support_finfo) {
757 Jmsg(jcr, M_INFO, 0, _("%d non-supported Finder Info streams ignored.\n"), non_support_rsrc);
759 if (non_support_acl) {
760 Jmsg(jcr, M_INFO, 0, _("%d non-supported acl streams ignored.\n"), non_support_acl);
762 if (non_support_crypto) {
763 Jmsg(jcr, M_INFO, 0, _("%d non-supported crypto streams ignored.\n"), non_support_acl);
765 if (non_support_xattr) {
766 Jmsg(jcr, M_INFO, 0, _("%d non-supported xattr streams ignored.\n"), non_support_xattr);
770 * Free Signature & Crypto Data
772 free_signature(rctx);
774 if (jcr->crypto.digest) {
775 crypto_digest_free(jcr->crypto.digest);
776 jcr->crypto.digest = NULL;
780 * Free file cipher restore context
782 if (rctx.cipher_ctx.cipher) {
783 crypto_cipher_free(rctx.cipher_ctx.cipher);
784 rctx.cipher_ctx.cipher = NULL;
787 if (rctx.cipher_ctx.buf) {
788 free_pool_memory(rctx.cipher_ctx.buf);
789 rctx.cipher_ctx.buf = NULL;
793 * Free alternate stream cipher restore context
795 if (rctx.fork_cipher_ctx.cipher) {
796 crypto_cipher_free(rctx.fork_cipher_ctx.cipher);
797 rctx.fork_cipher_ctx.cipher = NULL;
799 if (rctx.fork_cipher_ctx.buf) {
800 free_pool_memory(rctx.fork_cipher_ctx.buf);
801 rctx.fork_cipher_ctx.buf = NULL;
804 if (jcr->compress_buf) {
805 free(jcr->compress_buf);
806 jcr->compress_buf = NULL;
807 jcr->compress_buf_size = 0;
810 if (have_acl && jcr->acl_data) {
811 free_pool_memory(jcr->acl_data->content);
813 jcr->acl_data = NULL;
816 if (have_xattr && jcr->xattr_data) {
817 free_pool_memory(jcr->xattr_data->content);
818 free(jcr->xattr_data);
819 jcr->xattr_data = NULL;
822 bclose(&rctx.forkbfd);
824 free_attr(rctx.attr);
829 * Convert ZLIB error code into an ASCII message
831 static const char *zlib_strerror(int stat)
838 return _("Zlib errno");
840 return _("Zlib stream error");
842 return _("Zlib data error");
844 return _("Zlib memory error");
846 return _("Zlib buffer error");
847 case Z_VERSION_ERROR:
848 return _("Zlib version error");
855 static int do_file_digest(JCR *jcr, FF_PKT *ff_pkt, bool top_level)
857 Dmsg1(50, "do_file_digest jcr=%p\n", jcr);
858 return (digest_file(jcr, ff_pkt, jcr->crypto.digest));
862 * Verify the signature for the last restored file
863 * Return value is either true (signature correct)
864 * or false (signature could not be verified).
865 * TODO landonf: Implement without using find_one_file and
866 * without re-reading the file.
868 static bool verify_signature(JCR *jcr, r_ctx &rctx)
870 X509_KEYPAIR *keypair;
871 DIGEST *digest = NULL;
873 uint64_t saved_bytes;
874 crypto_digest_t signing_algorithm = have_sha2 ?
875 CRYPTO_DIGEST_SHA256 : CRYPTO_DIGEST_SHA1;
876 crypto_digest_t algorithm;
877 SIGNATURE *sig = rctx.sig;
880 if (!jcr->crypto.pki_sign) {
881 return true; /* no signature OK */
884 if (rctx.type == FT_REGE || rctx.type == FT_REG || rctx.type == FT_RAW) {
885 Jmsg1(jcr, M_ERROR, 0, _("Missing cryptographic signature for %s\n"),
892 /* Iterate through the trusted signers */
893 foreach_alist(keypair, jcr->crypto.pki_signers) {
894 err = crypto_sign_get_digest(sig, jcr->crypto.pki_keypair, algorithm, &digest);
896 case CRYPTO_ERROR_NONE:
897 Dmsg0(50, "== Got digest\n");
899 * We computed jcr->crypto.digest using signing_algorithm while writing
900 * the file. If it is not the same as the algorithm used for
901 * this file, punt by releasing the computed algorithm and
902 * computing by re-reading the file.
904 if (algorithm != signing_algorithm) {
905 if (jcr->crypto.digest) {
906 crypto_digest_free(jcr->crypto.digest);
907 jcr->crypto.digest = NULL;
910 if (jcr->crypto.digest) {
911 /* Use digest computed while writing the file to verify the signature */
912 if ((err = crypto_sign_verify(sig, keypair, jcr->crypto.digest)) != CRYPTO_ERROR_NONE) {
913 Dmsg1(50, "Bad signature on %s\n", jcr->last_fname);
914 Jmsg2(jcr, M_ERROR, 0, _("Signature validation failed for file %s: ERR=%s\n"),
915 jcr->last_fname, crypto_strerror(err));
919 /* Signature found, digest allocated. Old method,
920 * re-read the file and compute the digest
922 jcr->crypto.digest = digest;
924 /* Checksum the entire file */
925 /* Make sure we don't modify JobBytes by saving and restoring it */
926 saved_bytes = jcr->JobBytes;
927 if (find_one_file(jcr, jcr->ff, do_file_digest, jcr->last_fname, (dev_t)-1, 1) != 0) {
928 Jmsg(jcr, M_ERROR, 0, _("Digest one file failed for file: %s\n"),
930 jcr->JobBytes = saved_bytes;
933 jcr->JobBytes = saved_bytes;
935 /* Verify the signature */
936 if ((err = crypto_sign_verify(sig, keypair, digest)) != CRYPTO_ERROR_NONE) {
937 Dmsg1(50, "Bad signature on %s\n", jcr->last_fname);
938 Jmsg2(jcr, M_ERROR, 0, _("Signature validation failed for file %s: ERR=%s\n"),
939 jcr->last_fname, crypto_strerror(err));
942 jcr->crypto.digest = NULL;
945 /* Valid signature */
946 Dmsg1(50, "Signature good on %s\n", jcr->last_fname);
947 crypto_digest_free(digest);
950 case CRYPTO_ERROR_NOSIGNER:
951 /* Signature not found, try again */
953 crypto_digest_free(digest);
958 /* Something strange happened (that shouldn't happen!)... */
959 Qmsg2(jcr, M_ERROR, 0, _("Signature validation failed for %s: %s\n"), jcr->last_fname, crypto_strerror(err));
965 Dmsg1(50, "Could not find a valid public key for signature on %s\n", jcr->last_fname);
969 crypto_digest_free(digest);
974 bool sparse_data(JCR *jcr, BFILE *bfd, uint64_t *addr, char **data, uint32_t *length)
979 unser_begin(*data, SPARSE_FADDR_SIZE);
981 if (*addr != faddr) {
983 if (blseek(bfd, (boffset_t)*addr, SEEK_SET) < 0) {
985 Jmsg3(jcr, M_ERROR, 0, _("Seek to %s error on %s: ERR=%s\n"),
986 edit_uint64(*addr, ec1), jcr->last_fname,
987 be.bstrerror(bfd->berrno));
991 *data += SPARSE_FADDR_SIZE;
992 *length -= SPARSE_FADDR_SIZE;
996 bool decompress_data(JCR *jcr, char **data, uint32_t *length)
1001 char ec1[50]; /* Buffer printing huge values */
1004 * NOTE! We only use uLong and Byte because they are
1005 * needed by the zlib routines, they should not otherwise
1006 * be used in Bacula.
1008 compress_len = jcr->compress_buf_size;
1009 Dmsg2(200, "Comp_len=%d msglen=%d\n", compress_len, *length);
1010 if ((stat=uncompress((Byte *)jcr->compress_buf, &compress_len,
1011 (const Byte *)*data, (uLong)*length)) != Z_OK) {
1012 Qmsg(jcr, M_ERROR, 0, _("Uncompression error on file %s. ERR=%s\n"),
1013 jcr->last_fname, zlib_strerror(stat));
1016 *data = jcr->compress_buf;
1017 *length = compress_len;
1018 Dmsg2(200, "Write uncompressed %d bytes, total before write=%s\n", compress_len, edit_uint64(jcr->JobBytes, ec1));
1021 Qmsg(jcr, M_ERROR, 0, _("GZIP data stream found, but GZIP not configured!\n"));
1026 static void unser_crypto_packet_len(RESTORE_CIPHER_CTX *ctx)
1029 if (ctx->packet_len == 0 && ctx->buf_len >= CRYPTO_LEN_SIZE) {
1030 unser_begin(&ctx->buf[0], CRYPTO_LEN_SIZE);
1031 unser_uint32(ctx->packet_len);
1032 ctx->packet_len += CRYPTO_LEN_SIZE;
1036 bool store_data(JCR *jcr, BFILE *bfd, char *data, const int32_t length, bool win32_decomp)
1038 if (jcr->crypto.digest) {
1039 crypto_digest_update(jcr->crypto.digest, (uint8_t *)data, length);
1042 if (!processWin32BackupAPIBlock(bfd, data, length)) {
1044 Jmsg2(jcr, M_ERROR, 0, _("Write error in Win32 Block Decomposition on %s: %s\n"),
1045 jcr->last_fname, be.bstrerror(bfd->berrno));
1048 } else if (bwrite(bfd, data, length) != (ssize_t)length) {
1050 Jmsg2(jcr, M_ERROR, 0, _("Write error on %s: %s\n"),
1051 jcr->last_fname, be.bstrerror(bfd->berrno));
1059 * In the context of jcr, write data to bfd.
1060 * We write buflen bytes in buf at addr. addr is updated in place.
1061 * The flags specify whether to use sparse files or compression.
1062 * Return value is the number of bytes written, or -1 on errors.
1064 int32_t extract_data(JCR *jcr, r_ctx &rctx, POOLMEM *buf, int32_t buflen,
1065 uint64_t *addr, int flags, RESTORE_CIPHER_CTX *cipher_ctx)
1067 BFILE *bfd = &rctx.bfd;
1068 char *wbuf; /* write buffer */
1069 uint32_t wsize; /* write size */
1070 uint32_t rsize; /* read size */
1071 uint32_t decrypted_len = 0; /* Decryption output length */
1072 char ec1[50]; /* Buffer printing huge values */
1075 jcr->ReadBytes += rsize;
1079 if (flags & FO_ENCRYPT) {
1080 ASSERT(cipher_ctx->cipher);
1082 /* NOTE: We must implement block preserving semantics for the
1083 * non-streaming compression and sparse code. */
1086 * Grow the crypto buffer, if necessary.
1087 * crypto_cipher_update() will process only whole blocks,
1088 * buffering the remaining input.
1090 cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf,
1091 cipher_ctx->buf_len + wsize + cipher_ctx->block_size);
1093 /* Decrypt the input block */
1094 if (!crypto_cipher_update(cipher_ctx->cipher,
1095 (const u_int8_t *)wbuf,
1097 (u_int8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
1099 /* Decryption failed. Shouldn't happen. */
1100 Jmsg(jcr, M_FATAL, 0, _("Decryption error\n"));
1104 if (decrypted_len == 0) {
1105 /* No full block of encrypted data available, write more data */
1109 Dmsg2(200, "decrypted len=%d encrypted len=%d\n", decrypted_len, wsize);
1111 cipher_ctx->buf_len += decrypted_len;
1112 wbuf = cipher_ctx->buf;
1114 /* If one full preserved block is available, write it to disk,
1115 * and then buffer any remaining data. This should be effecient
1116 * as long as Bacula's block size is not significantly smaller than the
1117 * encryption block size (extremely unlikely!) */
1118 unser_crypto_packet_len(cipher_ctx);
1119 Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1121 if (cipher_ctx->packet_len == 0 || cipher_ctx->buf_len < cipher_ctx->packet_len) {
1122 /* No full preserved block is available. */
1126 /* We have one full block, set up the filter input buffers */
1127 wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1128 wbuf = &wbuf[CRYPTO_LEN_SIZE]; /* Skip the block length header */
1129 cipher_ctx->buf_len -= cipher_ctx->packet_len;
1130 Dmsg2(130, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
1133 if (flags & FO_SPARSE) {
1134 if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1139 if (flags & FO_GZIP) {
1140 if (!decompress_data(jcr, &wbuf, &wsize)) {
1145 if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1148 jcr->JobBytes += wsize;
1150 Dmsg2(130, "Write %u bytes, JobBytes=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1152 /* Clean up crypto buffers */
1153 if (flags & FO_ENCRYPT) {
1154 /* Move any remaining data to start of buffer */
1155 if (cipher_ctx->buf_len > 0) {
1156 Dmsg1(130, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1157 memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1158 cipher_ctx->buf_len);
1160 /* The packet was successfully written, reset the length so that the next
1161 * packet length may be re-read by unser_crypto_packet_len() */
1162 cipher_ctx->packet_len = 0;
1167 rctx.extract = false;
1174 * If extracting, close any previous stream
1176 static void close_previous_stream(r_ctx &rctx)
1179 * If extracting, it was from previous stream, so
1180 * close the output file and validate the signature.
1183 if (rctx.size > 0 && !is_bopen(&rctx.bfd)) {
1184 Jmsg0(rctx.jcr, M_ERROR, 0, _("Logic error: output file should be open\n"));
1185 Dmsg2(000, "=== logic error size=%d bopen=%d\n", rctx.size,
1186 is_bopen(&rctx.bfd));
1189 if (rctx.prev_stream != STREAM_ENCRYPTED_SESSION_DATA) {
1190 deallocate_cipher(rctx);
1191 deallocate_fork_cipher(rctx);
1194 if (rctx.jcr->plugin) {
1195 plugin_set_attributes(rctx.jcr, rctx.attr, &rctx.bfd);
1197 set_attributes(rctx.jcr, rctx.attr, &rctx.bfd);
1199 rctx.extract = false;
1201 /* Verify the cryptographic signature, if any */
1202 rctx.type = rctx.attr->type;
1203 verify_signature(rctx.jcr, rctx);
1205 /* Free Signature */
1206 free_signature(rctx);
1208 rctx.jcr->ff->flags = 0;
1209 Dmsg0(130, "Stop extracting.\n");
1210 } else if (is_bopen(&rctx.bfd)) {
1211 Jmsg0(rctx.jcr, M_ERROR, 0, _("Logic error: output file should not be open\n"));
1212 Dmsg0(000, "=== logic error !open\n");
1219 * In the context of jcr, flush any remaining data from the cipher context,
1220 * writing it to bfd.
1221 * Return value is true on success, false on failure.
1223 bool flush_cipher(JCR *jcr, BFILE *bfd, uint64_t *addr, int flags,
1224 RESTORE_CIPHER_CTX *cipher_ctx)
1226 uint32_t decrypted_len = 0;
1227 char *wbuf; /* write buffer */
1228 uint32_t wsize; /* write size */
1229 char ec1[50]; /* Buffer printing huge values */
1230 bool second_pass = false;
1233 /* Write out the remaining block and free the cipher context */
1234 cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf, cipher_ctx->buf_len +
1235 cipher_ctx->block_size);
1237 if (!crypto_cipher_finalize(cipher_ctx->cipher, (uint8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
1239 /* Writing out the final, buffered block failed. Shouldn't happen. */
1240 Jmsg3(jcr, M_ERROR, 0, _("Decryption error. buf_len=%d decrypt_len=%d on file %s\n"),
1241 cipher_ctx->buf_len, decrypted_len, jcr->last_fname);
1244 Dmsg2(130, "Flush decrypt len=%d buf_len=%d\n", decrypted_len, cipher_ctx->buf_len);
1245 /* If nothing new was decrypted, and our output buffer is empty, return */
1246 if (decrypted_len == 0 && cipher_ctx->buf_len == 0) {
1250 cipher_ctx->buf_len += decrypted_len;
1252 unser_crypto_packet_len(cipher_ctx);
1253 Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1254 wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1255 wbuf = &cipher_ctx->buf[CRYPTO_LEN_SIZE]; /* Decrypted, possibly decompressed output here. */
1256 cipher_ctx->buf_len -= cipher_ctx->packet_len;
1257 Dmsg2(130, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
1259 if (flags & FO_SPARSE) {
1260 if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1265 if (flags & FO_GZIP) {
1266 if (!decompress_data(jcr, &wbuf, &wsize)) {
1271 Dmsg0(130, "Call store_data\n");
1272 if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1275 jcr->JobBytes += wsize;
1276 Dmsg2(130, "Flush write %u bytes, JobBytes=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1278 /* Move any remaining data to start of buffer */
1279 if (cipher_ctx->buf_len > 0) {
1280 Dmsg1(130, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1281 memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1282 cipher_ctx->buf_len);
1284 /* The packet was successfully written, reset the length so that the next
1285 * packet length may be re-read by unser_crypto_packet_len() */
1286 cipher_ctx->packet_len = 0;
1288 if (cipher_ctx->buf_len >0 && !second_pass) {
1293 /* Stop decryption */
1294 cipher_ctx->buf_len = 0;
1295 cipher_ctx->packet_len = 0;
1300 static void deallocate_cipher(r_ctx &rctx)
1302 /* Flush and deallocate previous stream's cipher context */
1303 if (rctx.cipher_ctx.cipher) {
1304 flush_cipher(rctx.jcr, &rctx.bfd, &rctx.fileAddr, rctx.flags, &rctx.cipher_ctx);
1305 crypto_cipher_free(rctx.cipher_ctx.cipher);
1306 rctx.cipher_ctx.cipher = NULL;
1310 static void deallocate_fork_cipher(r_ctx &rctx)
1313 /* Flush and deallocate previous stream's fork cipher context */
1314 if (rctx.fork_cipher_ctx.cipher) {
1315 flush_cipher(rctx.jcr, &rctx.forkbfd, &rctx.fork_addr, rctx.fork_flags, &rctx.fork_cipher_ctx);
1316 crypto_cipher_free(rctx.fork_cipher_ctx.cipher);
1317 rctx.fork_cipher_ctx.cipher = NULL;
1321 static void free_signature(r_ctx &rctx)
1324 crypto_sign_free(rctx.sig);
1329 static void free_session(r_ctx &rctx)
1332 crypto_session_free(rctx.cs);
1338 /* This code if implemented goes above */
1339 #ifdef stbernard_implemented
1340 / #if defined(HAVE_WIN32)
1341 bool bResumeOfmOnExit = FALSE;
1342 if (isOpenFileManagerRunning()) {
1343 if ( pauseOpenFileManager() ) {
1344 Jmsg(jcr, M_INFO, 0, _("Open File Manager paused\n") );
1345 bResumeOfmOnExit = TRUE;
1348 Jmsg(jcr, M_ERROR, 0, _("FAILED to pause Open File Manager\n") );
1352 char username[UNLEN+1];
1353 DWORD usize = sizeof(username);
1354 int privs = enable_backup_privileges(NULL, 1);
1355 if (GetUserName(username, &usize)) {
1356 Jmsg2(jcr, M_INFO, 0, _("Running as '%s'. Privmask=%#08x\n"), username,
1358 Jmsg(jcr, M_WARNING, 0, _("Failed to retrieve current UserName\n"));