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 = get_pool_memory(PM_MESSAGE);
257 jcr->xattr_data = get_pool_memory(PM_MESSAGE);
260 while (bget_msg(sd) >= 0 && !job_canceled(jcr)) {
261 /* Remember previous stream type */
262 rctx.prev_stream = rctx.stream;
264 /* First we expect a Stream Record Header */
265 if (sscanf(sd->msg, rec_header, &VolSessionId, &VolSessionTime, &file_index,
266 &rctx.stream, &rctx.size) != 5) {
267 Jmsg1(jcr, M_FATAL, 0, _("Record header scan error: %s\n"), sd->msg);
270 Dmsg5(50, "Got hdr: Files=%d FilInx=%d size=%d Stream=%d, %s.\n",
271 jcr->JobFiles, file_index, rctx.size, rctx.stream, stream_to_ascii(rctx.stream));
273 /* * Now we expect the Stream Data */
274 if (bget_msg(sd) < 0) {
275 Jmsg1(jcr, M_FATAL, 0, _("Data record error. ERR=%s\n"), sd->bstrerror());
278 if (rctx.size != (uint32_t)sd->msglen) {
279 Jmsg2(jcr, M_FATAL, 0, _("Actual data size %d not same as header %d\n"),
280 sd->msglen, rctx.size);
281 Dmsg2(50, "Actual data size %d not same as header %d\n",
282 sd->msglen, rctx.size);
285 Dmsg3(130, "Got stream: %s len=%d extract=%d\n", stream_to_ascii(rctx.stream),
286 sd->msglen, rctx.extract);
288 /* If we change streams, close and reset alternate data streams */
289 if (rctx.prev_stream != rctx.stream) {
290 if (is_bopen(&rctx.forkbfd)) {
291 deallocate_fork_cipher(rctx);
292 bclose_chksize(jcr, &rctx.forkbfd, rctx.fork_size);
294 rctx.fork_size = -1; /* Use an impossible value and set a proper one below */
298 /* File Attributes stream */
299 switch (rctx.stream) {
300 case STREAM_UNIX_ATTRIBUTES:
301 case STREAM_UNIX_ATTRIBUTES_EX:
302 close_previous_stream(rctx); /* if any previous stream open, close it */
305 /* TODO: manage deleted files */
306 if (rctx.type == FT_DELETED) { /* deleted file */
311 * Unpack attributes and do sanity check them
313 if (!unpack_attributes_record(jcr, rctx.stream, sd->msg, attr)) {
317 if (file_index != attr->file_index) {
318 Jmsg(jcr, M_FATAL, 0, _("Record header file index %ld not equal record index %ld\n"),
319 file_index, attr->file_index);
320 Dmsg0(200, "File index error\n");
325 Dmsg3(200, "File %s\nattrib=%s\nattribsEx=%s\n", attr->fname,
326 attr->attr, attr->attrEx);
328 attr->data_stream = decode_stat(attr->attr, &attr->statp, &attr->LinkFI);
330 if (!is_restore_stream_supported(attr->data_stream)) {
331 if (!non_support_data++) {
332 Jmsg(jcr, M_ERROR, 0, _("%s stream not supported on this Client.\n"),
333 stream_to_ascii(attr->data_stream));
338 build_attr_output_fnames(jcr, attr);
341 * Try to actually create the file, which returns a status telling
342 * us if we need to extract or not.
344 jcr->num_files_examined++;
345 rctx.extract = false;
347 stat = plugin_create_file(jcr, attr, &rctx.bfd, jcr->replace);
349 stat = create_file(jcr, attr, &rctx.bfd, jcr->replace);
352 pm_strcpy(jcr->last_fname, attr->ofname);
353 jcr->last_type = attr->type;
355 Dmsg2(130, "Outfile=%s create_file stat=%d\n", attr->ofname, stat);
359 pm_strcpy(jcr->last_fname, attr->ofname);
360 jcr->last_type = attr->type;
362 case CF_EXTRACT: /* File created and we expect file data */
365 case CF_CREATED: /* File created, but there is no content */
368 print_ls_output(jcr, attr);
370 if (have_darwin_os) {
371 /* Only restore the resource fork for regular files */
372 from_base64(&rsrc_len, attr->attrEx);
373 if (attr->type == FT_REG && rsrc_len > 0) {
378 /* set attributes now because file will not be extracted */
380 plugin_set_attributes(jcr, attr, &rctx.bfd);
382 set_attributes(jcr, attr, &rctx.bfd);
390 case STREAM_ENCRYPTED_SESSION_DATA:
391 crypto_error_t cryptoerr;
393 /* Is this an unexpected session data entry? */
395 Jmsg0(jcr, M_ERROR, 0, _("Unexpected cryptographic session data stream.\n"));
396 rctx.extract = false;
401 /* Do we have any keys at all? */
402 if (!jcr->crypto.pki_recipients) {
403 Jmsg(jcr, M_ERROR, 0, _("No private decryption keys have been defined to decrypt encrypted backup data.\n"));
404 rctx.extract = false;
409 if (jcr->crypto.digest) {
410 crypto_digest_free(jcr->crypto.digest);
412 jcr->crypto.digest = crypto_digest_new(jcr, signing_algorithm);
413 if (!jcr->crypto.digest) {
414 Jmsg0(jcr, M_FATAL, 0, _("Could not create digest.\n"));
415 rctx.extract = false;
420 /* Decode and save session keys. */
421 cryptoerr = crypto_session_decode((uint8_t *)sd->msg, (uint32_t)sd->msglen,
422 jcr->crypto.pki_recipients, &rctx.cs);
424 case CRYPTO_ERROR_NONE:
427 case CRYPTO_ERROR_NORECIPIENT:
428 Jmsg(jcr, M_ERROR, 0, _("Missing private key required to decrypt encrypted backup data.\n"));
430 case CRYPTO_ERROR_DECRYPTION:
431 Jmsg(jcr, M_ERROR, 0, _("Decrypt of the session key failed.\n"));
434 /* Shouldn't happen */
435 Jmsg1(jcr, M_ERROR, 0, _("An error occurred while decoding encrypted session data stream: %s\n"), crypto_strerror(cryptoerr));
439 if (cryptoerr != CRYPTO_ERROR_NONE) {
440 rctx.extract = false;
447 case STREAM_FILE_DATA:
448 case STREAM_SPARSE_DATA:
449 case STREAM_WIN32_DATA:
450 case STREAM_GZIP_DATA:
451 case STREAM_SPARSE_GZIP_DATA:
452 case STREAM_WIN32_GZIP_DATA:
453 case STREAM_ENCRYPTED_FILE_DATA:
454 case STREAM_ENCRYPTED_WIN32_DATA:
455 case STREAM_ENCRYPTED_FILE_GZIP_DATA:
456 case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
457 /* Force an expected, consistent stream type here */
458 if (rctx.extract && (rctx.prev_stream == rctx.stream
459 || rctx.prev_stream == STREAM_UNIX_ATTRIBUTES
460 || rctx.prev_stream == STREAM_UNIX_ATTRIBUTES_EX
461 || rctx.prev_stream == STREAM_ENCRYPTED_SESSION_DATA)) {
464 if (rctx.stream == STREAM_SPARSE_DATA ||
465 rctx.stream == STREAM_SPARSE_GZIP_DATA) {
466 rctx.flags |= FO_SPARSE;
469 if (rctx.stream == STREAM_GZIP_DATA
470 || rctx.stream == STREAM_SPARSE_GZIP_DATA
471 || rctx.stream == STREAM_WIN32_GZIP_DATA
472 || rctx.stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
473 || rctx.stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
474 rctx.flags |= FO_GZIP;
477 if (rctx.stream == STREAM_ENCRYPTED_FILE_DATA
478 || rctx.stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
479 || rctx.stream == STREAM_ENCRYPTED_WIN32_DATA
480 || rctx.stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
481 /* Set up a decryption context */
482 if (!rctx.cipher_ctx.cipher) {
484 Jmsg1(jcr, M_ERROR, 0, _("Missing encryption session data stream for %s\n"), jcr->last_fname);
485 rctx.extract = false;
490 if ((rctx.cipher_ctx.cipher = crypto_cipher_new(rctx.cs, false,
491 &rctx.cipher_ctx.block_size)) == NULL) {
492 Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
494 rctx.extract = false;
499 rctx.flags |= FO_ENCRYPT;
502 if (is_win32_stream(rctx.stream) && !have_win32_api()) {
503 set_portable_backup(&rctx.bfd);
504 rctx.flags |= FO_WIN32DECOMP; /* "decompose" BackupWrite data */
507 if (extract_data(jcr, rctx, sd->msg, sd->msglen, &rctx.fileAddr,
508 rctx.flags, &rctx.cipher_ctx) < 0) {
515 /* Resource fork stream - only recorded after a file to be restored */
516 /* Silently ignore if we cannot write - we already reported that */
517 case STREAM_ENCRYPTED_MACOS_FORK_DATA:
518 case STREAM_MACOS_FORK_DATA:
519 #ifdef HAVE_DARWIN_OS
521 jcr->ff->flags |= FO_HFSPLUS;
523 if (rctx.stream == STREAM_ENCRYPTED_MACOS_FORK_DATA) {
524 rctx.fork_flags |= FO_ENCRYPT;
526 /* Set up a decryption context */
527 if (rctx.extract && !rctx.fork_cipher_ctx.cipher) {
529 Jmsg1(jcr, M_ERROR, 0, _("Missing encryption session data stream for %s\n"), jcr->last_fname);
530 rctx.extract = false;
535 if ((rctx.fork_cipher_ctx.cipher = crypto_cipher_new(rctx.cs, false, &rctx.fork_cipher_ctx.block_size)) == NULL) {
536 Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
538 rctx.extract = false;
546 if (rctx.prev_stream != rctx.stream) {
547 if (bopen_rsrc(&rctx.forkbfd, jcr->last_fname, O_WRONLY | O_TRUNC | O_BINARY, 0) < 0) {
548 Jmsg(jcr, M_ERROR, 0, _(" Cannot open resource fork for %s.\n"), jcr->last_fname);
549 rctx.extract = false;
553 rctx.fork_size = rsrc_len;
554 Dmsg0(130, "Restoring resource fork\n");
557 if (extract_data(jcr, rctx, sd->msg, sd->msglen, &rctx.fork_addr, rctx.fork_flags,
558 &rctx.fork_cipher_ctx) < 0) {
559 bclose(&rctx.forkbfd);
568 case STREAM_HFSPLUS_ATTRIBUTES:
569 #ifdef HAVE_DARWIN_OS
570 Dmsg0(130, "Restoring Finder Info\n");
571 jcr->ff->flags |= FO_HFSPLUS;
572 if (sd->msglen != 32) {
573 Jmsg(jcr, M_ERROR, 0, _(" Invalid length of Finder Info (got %d, not 32)\n"), sd->msglen);
576 if (setattrlist(jcr->last_fname, &attrList, sd->msg, sd->msglen, 0) != 0) {
577 Jmsg(jcr, M_ERROR, 0, _(" Could not set Finder Info on %s\n"), jcr->last_fname);
585 case STREAM_UNIX_ACCESS_ACL:
586 case STREAM_UNIX_DEFAULT_ACL:
587 case STREAM_ACL_AIX_TEXT:
588 case STREAM_ACL_DARWIN_ACCESS_ACL:
589 case STREAM_ACL_FREEBSD_DEFAULT_ACL:
590 case STREAM_ACL_FREEBSD_ACCESS_ACL:
591 case STREAM_ACL_HPUX_ACL_ENTRY:
592 case STREAM_ACL_IRIX_DEFAULT_ACL:
593 case STREAM_ACL_IRIX_ACCESS_ACL:
594 case STREAM_ACL_LINUX_DEFAULT_ACL:
595 case STREAM_ACL_LINUX_ACCESS_ACL:
596 case STREAM_ACL_TRU64_DEFAULT_ACL:
597 case STREAM_ACL_TRU64_DEFAULT_DIR_ACL:
598 case STREAM_ACL_TRU64_ACCESS_ACL:
599 case STREAM_ACL_SOLARIS_ACLENT:
600 case STREAM_ACL_SOLARIS_ACE:
602 * Do not restore ACLs when
603 * a) The current file is not extracted
604 * b) and it is not a directory (they are never "extracted")
605 * c) or the file name is empty
607 if ((!rctx.extract && jcr->last_type != FT_DIREND) || (*jcr->last_fname == 0)) {
611 pm_memcpy(jcr->acl_data, sd->msg, sd->msglen);
612 jcr->acl_data_len = sd->msglen;
613 if (parse_acl_streams(jcr, rctx.stream) != bsub_exit_ok) {
614 Qmsg1(jcr, M_WARNING, 0, _("Can't restore ACLs of %s\n"), jcr->last_fname);
621 case STREAM_XATTR_SOLARIS_SYS:
622 case STREAM_XATTR_SOLARIS:
623 case STREAM_XATTR_DARWIN:
624 case STREAM_XATTR_FREEBSD:
625 case STREAM_XATTR_LINUX:
626 case STREAM_XATTR_NETBSD:
628 * Do not restore Extended Attributes when
629 * a) The current file is not extracted
630 * b) and it is not a directory (they are never "extracted")
631 * c) or the file name is empty
633 if ((!rctx.extract && jcr->last_type != FT_DIREND) || (*jcr->last_fname == 0)) {
637 pm_memcpy(jcr->xattr_data, sd->msg, sd->msglen);
638 jcr->xattr_data_len = sd->msglen;
639 if (parse_xattr_streams(jcr, rctx.stream) != bsub_exit_ok) {
640 Qmsg1(jcr, M_WARNING, 0, _("Can't restore Extended Attributes of %s\n"), jcr->last_fname);
647 case STREAM_SIGNED_DIGEST:
648 /* Is this an unexpected signature? */
650 Jmsg0(jcr, M_ERROR, 0, _("Unexpected cryptographic signature data stream.\n"));
651 free_signature(rctx);
654 /* Save signature. */
655 if (rctx.extract && (rctx.sig = crypto_sign_decode(jcr, (uint8_t *)sd->msg, (uint32_t)sd->msglen)) == NULL) {
656 Jmsg1(jcr, M_ERROR, 0, _("Failed to decode message signature for %s\n"), jcr->last_fname);
660 case STREAM_MD5_DIGEST:
661 case STREAM_SHA1_DIGEST:
662 case STREAM_SHA256_DIGEST:
663 case STREAM_SHA512_DIGEST:
666 case STREAM_PROGRAM_NAMES:
667 case STREAM_PROGRAM_DATA:
668 if (!non_support_progname) {
669 Pmsg0(000, "Got Program Name or Data Stream. Ignored.\n");
670 non_support_progname++;
674 case STREAM_PLUGIN_NAME:
675 close_previous_stream(rctx);
676 Dmsg1(50, "restore stream_plugin_name=%s\n", sd->msg);
677 plugin_name_stream(jcr, sd->msg);
681 close_previous_stream(rctx);
682 Jmsg(jcr, M_ERROR, 0, _("Unknown stream=%d ignored. This shouldn't happen!\n"),
684 Dmsg2(0, "Unknown stream=%d data=%s\n", rctx.stream, sd->msg);
686 } /* end switch(stream) */
688 } /* end while get_msg() */
691 * If output file is still open, it was the last one in the
692 * archive since we just hit an end of file, so close the file.
694 if (is_bopen(&rctx.forkbfd)) {
695 bclose_chksize(jcr, &rctx.forkbfd, rctx.fork_size);
698 close_previous_stream(rctx);
699 set_jcr_job_status(jcr, JS_Terminated);
703 set_jcr_job_status(jcr, JS_ErrorTerminated);
706 /* Free Signature & Crypto Data */
707 free_signature(rctx);
709 if (jcr->crypto.digest) {
710 crypto_digest_free(jcr->crypto.digest);
711 jcr->crypto.digest = NULL;
714 /* Free file cipher restore context */
715 if (rctx.cipher_ctx.cipher) {
716 crypto_cipher_free(rctx.cipher_ctx.cipher);
717 rctx.cipher_ctx.cipher = NULL;
719 if (rctx.cipher_ctx.buf) {
720 free_pool_memory(rctx.cipher_ctx.buf);
721 rctx.cipher_ctx.buf = NULL;
724 /* Free alternate stream cipher restore context */
725 if (rctx.fork_cipher_ctx.cipher) {
726 crypto_cipher_free(rctx.fork_cipher_ctx.cipher);
727 rctx.fork_cipher_ctx.cipher = NULL;
729 if (rctx.fork_cipher_ctx.buf) {
730 free_pool_memory(rctx.fork_cipher_ctx.buf);
731 rctx.fork_cipher_ctx.buf = NULL;
734 if (jcr->compress_buf) {
735 free(jcr->compress_buf);
736 jcr->compress_buf = NULL;
737 jcr->compress_buf_size = 0;
740 if (have_xattr && jcr->xattr_data) {
741 free_pool_memory(jcr->xattr_data);
742 jcr->xattr_data = NULL;
744 if (have_acl && jcr->acl_data) {
745 free_pool_memory(jcr->acl_data);
746 jcr->acl_data = NULL;
749 bclose(&rctx.forkbfd);
751 free_attr(rctx.attr);
752 Dmsg2(10, "End Do Restore. Files=%d Bytes=%s\n", jcr->JobFiles,
753 edit_uint64(jcr->JobBytes, ec1));
754 if (non_support_data > 1 || non_support_attr > 1) {
755 Jmsg(jcr, M_ERROR, 0, _("%d non-supported data streams and %d non-supported attrib streams ignored.\n"),
756 non_support_data, non_support_attr);
758 if (non_support_rsrc) {
759 Jmsg(jcr, M_INFO, 0, _("%d non-supported resource fork streams ignored.\n"), non_support_rsrc);
761 if (non_support_finfo) {
762 Jmsg(jcr, M_INFO, 0, _("%d non-supported Finder Info streams ignored.\n"), non_support_rsrc);
764 if (non_support_acl) {
765 Jmsg(jcr, M_INFO, 0, _("%d non-supported acl streams ignored.\n"), non_support_acl);
767 if (non_support_crypto) {
768 Jmsg(jcr, M_INFO, 0, _("%d non-supported crypto streams ignored.\n"), non_support_acl);
770 if (non_support_xattr) {
771 Jmsg(jcr, M_INFO, 0, _("%d non-supported xattr streams ignored.\n"), non_support_xattr);
778 * Convert ZLIB error code into an ASCII message
780 static const char *zlib_strerror(int stat)
787 return _("Zlib errno");
789 return _("Zlib stream error");
791 return _("Zlib data error");
793 return _("Zlib memory error");
795 return _("Zlib buffer error");
796 case Z_VERSION_ERROR:
797 return _("Zlib version error");
804 static int do_file_digest(JCR *jcr, FF_PKT *ff_pkt, bool top_level)
806 Dmsg1(50, "do_file_digest jcr=%p\n", jcr);
807 return (digest_file(jcr, ff_pkt, jcr->crypto.digest));
811 * Verify the signature for the last restored file
812 * Return value is either true (signature correct)
813 * or false (signature could not be verified).
814 * TODO landonf: Implement without using find_one_file and
815 * without re-reading the file.
817 static bool verify_signature(JCR *jcr, r_ctx &rctx)
819 X509_KEYPAIR *keypair;
820 DIGEST *digest = NULL;
822 uint64_t saved_bytes;
823 crypto_digest_t signing_algorithm = have_sha2 ?
824 CRYPTO_DIGEST_SHA256 : CRYPTO_DIGEST_SHA1;
825 crypto_digest_t algorithm;
826 SIGNATURE *sig = rctx.sig;
829 if (!jcr->crypto.pki_sign) {
830 return true; /* no signature OK */
833 if (rctx.type == FT_REGE || rctx.type == FT_REG || rctx.type == FT_RAW) {
834 Jmsg1(jcr, M_ERROR, 0, _("Missing cryptographic signature for %s\n"),
841 /* Iterate through the trusted signers */
842 foreach_alist(keypair, jcr->crypto.pki_signers) {
843 err = crypto_sign_get_digest(sig, jcr->crypto.pki_keypair, algorithm, &digest);
845 case CRYPTO_ERROR_NONE:
846 Dmsg0(50, "== Got digest\n");
848 * We computed jcr->crypto.digest using signing_algorithm while writing
849 * the file. If it is not the same as the algorithm used for
850 * this file, punt by releasing the computed algorithm and
851 * computing by re-reading the file.
853 if (algorithm != signing_algorithm) {
854 if (jcr->crypto.digest) {
855 crypto_digest_free(jcr->crypto.digest);
856 jcr->crypto.digest = NULL;
859 if (jcr->crypto.digest) {
860 /* Use digest computed while writing the file to verify the signature */
861 if ((err = crypto_sign_verify(sig, keypair, jcr->crypto.digest)) != CRYPTO_ERROR_NONE) {
862 Dmsg1(50, "Bad signature on %s\n", jcr->last_fname);
863 Jmsg2(jcr, M_ERROR, 0, _("Signature validation failed for file %s: ERR=%s\n"),
864 jcr->last_fname, crypto_strerror(err));
868 /* Signature found, digest allocated. Old method,
869 * re-read the file and compute the digest
871 jcr->crypto.digest = digest;
873 /* Checksum the entire file */
874 /* Make sure we don't modify JobBytes by saving and restoring it */
875 saved_bytes = jcr->JobBytes;
876 if (find_one_file(jcr, jcr->ff, do_file_digest, jcr->last_fname, (dev_t)-1, 1) != 0) {
877 Jmsg(jcr, M_ERROR, 0, _("Digest one file failed for file: %s\n"),
879 jcr->JobBytes = saved_bytes;
882 jcr->JobBytes = saved_bytes;
884 /* Verify the signature */
885 if ((err = crypto_sign_verify(sig, keypair, digest)) != CRYPTO_ERROR_NONE) {
886 Dmsg1(50, "Bad signature on %s\n", jcr->last_fname);
887 Jmsg2(jcr, M_ERROR, 0, _("Signature validation failed for file %s: ERR=%s\n"),
888 jcr->last_fname, crypto_strerror(err));
891 jcr->crypto.digest = NULL;
894 /* Valid signature */
895 Dmsg1(50, "Signature good on %s\n", jcr->last_fname);
896 crypto_digest_free(digest);
899 case CRYPTO_ERROR_NOSIGNER:
900 /* Signature not found, try again */
902 crypto_digest_free(digest);
907 /* Something strange happened (that shouldn't happen!)... */
908 Qmsg2(jcr, M_ERROR, 0, _("Signature validation failed for %s: %s\n"), jcr->last_fname, crypto_strerror(err));
914 Dmsg1(50, "Could not find a valid public key for signature on %s\n", jcr->last_fname);
918 crypto_digest_free(digest);
923 bool sparse_data(JCR *jcr, BFILE *bfd, uint64_t *addr, char **data, uint32_t *length)
928 unser_begin(*data, SPARSE_FADDR_SIZE);
930 if (*addr != faddr) {
932 if (blseek(bfd, (boffset_t)*addr, SEEK_SET) < 0) {
934 Jmsg3(jcr, M_ERROR, 0, _("Seek to %s error on %s: ERR=%s\n"),
935 edit_uint64(*addr, ec1), jcr->last_fname,
936 be.bstrerror(bfd->berrno));
940 *data += SPARSE_FADDR_SIZE;
941 *length -= SPARSE_FADDR_SIZE;
945 bool decompress_data(JCR *jcr, char **data, uint32_t *length)
950 char ec1[50]; /* Buffer printing huge values */
953 * NOTE! We only use uLong and Byte because they are
954 * needed by the zlib routines, they should not otherwise
957 compress_len = jcr->compress_buf_size;
958 Dmsg2(200, "Comp_len=%d msglen=%d\n", compress_len, *length);
959 if ((stat=uncompress((Byte *)jcr->compress_buf, &compress_len,
960 (const Byte *)*data, (uLong)*length)) != Z_OK) {
961 Qmsg(jcr, M_ERROR, 0, _("Uncompression error on file %s. ERR=%s\n"),
962 jcr->last_fname, zlib_strerror(stat));
965 *data = jcr->compress_buf;
966 *length = compress_len;
967 Dmsg2(200, "Write uncompressed %d bytes, total before write=%s\n", compress_len, edit_uint64(jcr->JobBytes, ec1));
970 Qmsg(jcr, M_ERROR, 0, _("GZIP data stream found, but GZIP not configured!\n"));
975 static void unser_crypto_packet_len(RESTORE_CIPHER_CTX *ctx)
978 if (ctx->packet_len == 0 && ctx->buf_len >= CRYPTO_LEN_SIZE) {
979 unser_begin(&ctx->buf[0], CRYPTO_LEN_SIZE);
980 unser_uint32(ctx->packet_len);
981 ctx->packet_len += CRYPTO_LEN_SIZE;
985 bool store_data(JCR *jcr, BFILE *bfd, char *data, const int32_t length, bool win32_decomp)
987 if (jcr->crypto.digest) {
988 crypto_digest_update(jcr->crypto.digest, (uint8_t *)data, length);
991 if (!processWin32BackupAPIBlock(bfd, data, length)) {
993 Jmsg2(jcr, M_ERROR, 0, _("Write error in Win32 Block Decomposition on %s: %s\n"),
994 jcr->last_fname, be.bstrerror(bfd->berrno));
997 } else if (bwrite(bfd, data, length) != (ssize_t)length) {
999 Jmsg2(jcr, M_ERROR, 0, _("Write error on %s: %s\n"),
1000 jcr->last_fname, be.bstrerror(bfd->berrno));
1008 * In the context of jcr, write data to bfd.
1009 * We write buflen bytes in buf at addr. addr is updated in place.
1010 * The flags specify whether to use sparse files or compression.
1011 * Return value is the number of bytes written, or -1 on errors.
1013 int32_t extract_data(JCR *jcr, r_ctx &rctx, POOLMEM *buf, int32_t buflen,
1014 uint64_t *addr, int flags, RESTORE_CIPHER_CTX *cipher_ctx)
1016 BFILE *bfd = &rctx.bfd;
1017 char *wbuf; /* write buffer */
1018 uint32_t wsize; /* write size */
1019 uint32_t rsize; /* read size */
1020 uint32_t decrypted_len = 0; /* Decryption output length */
1021 char ec1[50]; /* Buffer printing huge values */
1024 jcr->ReadBytes += rsize;
1028 if (flags & FO_ENCRYPT) {
1029 ASSERT(cipher_ctx->cipher);
1031 /* NOTE: We must implement block preserving semantics for the
1032 * non-streaming compression and sparse code. */
1035 * Grow the crypto buffer, if necessary.
1036 * crypto_cipher_update() will process only whole blocks,
1037 * buffering the remaining input.
1039 cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf,
1040 cipher_ctx->buf_len + wsize + cipher_ctx->block_size);
1042 /* Decrypt the input block */
1043 if (!crypto_cipher_update(cipher_ctx->cipher,
1044 (const u_int8_t *)wbuf,
1046 (u_int8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
1048 /* Decryption failed. Shouldn't happen. */
1049 Jmsg(jcr, M_FATAL, 0, _("Decryption error\n"));
1053 if (decrypted_len == 0) {
1054 /* No full block of encrypted data available, write more data */
1058 Dmsg2(200, "decrypted len=%d encrypted len=%d\n", decrypted_len, wsize);
1060 cipher_ctx->buf_len += decrypted_len;
1061 wbuf = cipher_ctx->buf;
1063 /* If one full preserved block is available, write it to disk,
1064 * and then buffer any remaining data. This should be effecient
1065 * as long as Bacula's block size is not significantly smaller than the
1066 * encryption block size (extremely unlikely!) */
1067 unser_crypto_packet_len(cipher_ctx);
1068 Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1070 if (cipher_ctx->packet_len == 0 || cipher_ctx->buf_len < cipher_ctx->packet_len) {
1071 /* No full preserved block is available. */
1075 /* We have one full block, set up the filter input buffers */
1076 wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1077 wbuf = &wbuf[CRYPTO_LEN_SIZE]; /* Skip the block length header */
1078 cipher_ctx->buf_len -= cipher_ctx->packet_len;
1079 Dmsg2(130, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
1082 if (flags & FO_SPARSE) {
1083 if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1088 if (flags & FO_GZIP) {
1089 if (!decompress_data(jcr, &wbuf, &wsize)) {
1094 if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1097 jcr->JobBytes += wsize;
1099 Dmsg2(130, "Write %u bytes, JobBytes=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1101 /* Clean up crypto buffers */
1102 if (flags & FO_ENCRYPT) {
1103 /* Move any remaining data to start of buffer */
1104 if (cipher_ctx->buf_len > 0) {
1105 Dmsg1(130, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1106 memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1107 cipher_ctx->buf_len);
1109 /* The packet was successfully written, reset the length so that the next
1110 * packet length may be re-read by unser_crypto_packet_len() */
1111 cipher_ctx->packet_len = 0;
1116 rctx.extract = false;
1123 * If extracting, close any previous stream
1125 static void close_previous_stream(r_ctx &rctx)
1128 * If extracting, it was from previous stream, so
1129 * close the output file and validate the signature.
1132 if (rctx.size > 0 && !is_bopen(&rctx.bfd)) {
1133 Jmsg0(rctx.jcr, M_ERROR, 0, _("Logic error: output file should be open\n"));
1134 Dmsg2(000, "=== logic error size=%d bopen=%d\n", rctx.size,
1135 is_bopen(&rctx.bfd));
1138 if (rctx.prev_stream != STREAM_ENCRYPTED_SESSION_DATA) {
1139 deallocate_cipher(rctx);
1140 deallocate_fork_cipher(rctx);
1143 if (rctx.jcr->plugin) {
1144 plugin_set_attributes(rctx.jcr, rctx.attr, &rctx.bfd);
1146 set_attributes(rctx.jcr, rctx.attr, &rctx.bfd);
1148 rctx.extract = false;
1150 /* Verify the cryptographic signature, if any */
1151 rctx.type = rctx.attr->type;
1152 verify_signature(rctx.jcr, rctx);
1154 /* Free Signature */
1155 free_signature(rctx);
1157 rctx.jcr->ff->flags = 0;
1158 Dmsg0(130, "Stop extracting.\n");
1159 } else if (is_bopen(&rctx.bfd)) {
1160 Jmsg0(rctx.jcr, M_ERROR, 0, _("Logic error: output file should not be open\n"));
1161 Dmsg0(000, "=== logic error !open\n");
1168 * In the context of jcr, flush any remaining data from the cipher context,
1169 * writing it to bfd.
1170 * Return value is true on success, false on failure.
1172 bool flush_cipher(JCR *jcr, BFILE *bfd, uint64_t *addr, int flags,
1173 RESTORE_CIPHER_CTX *cipher_ctx)
1175 uint32_t decrypted_len = 0;
1176 char *wbuf; /* write buffer */
1177 uint32_t wsize; /* write size */
1178 char ec1[50]; /* Buffer printing huge values */
1179 bool second_pass = false;
1182 /* Write out the remaining block and free the cipher context */
1183 cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf, cipher_ctx->buf_len +
1184 cipher_ctx->block_size);
1186 if (!crypto_cipher_finalize(cipher_ctx->cipher, (uint8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
1188 /* Writing out the final, buffered block failed. Shouldn't happen. */
1189 Jmsg3(jcr, M_ERROR, 0, _("Decryption error. buf_len=%d decrypt_len=%d on file %s\n"),
1190 cipher_ctx->buf_len, decrypted_len, jcr->last_fname);
1193 Dmsg2(130, "Flush decrypt len=%d buf_len=%d\n", decrypted_len, cipher_ctx->buf_len);
1194 /* If nothing new was decrypted, and our output buffer is empty, return */
1195 if (decrypted_len == 0 && cipher_ctx->buf_len == 0) {
1199 cipher_ctx->buf_len += decrypted_len;
1201 unser_crypto_packet_len(cipher_ctx);
1202 Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1203 wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1204 wbuf = &cipher_ctx->buf[CRYPTO_LEN_SIZE]; /* Decrypted, possibly decompressed output here. */
1205 cipher_ctx->buf_len -= cipher_ctx->packet_len;
1206 Dmsg2(130, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
1208 if (flags & FO_SPARSE) {
1209 if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1214 if (flags & FO_GZIP) {
1215 if (!decompress_data(jcr, &wbuf, &wsize)) {
1220 Dmsg0(130, "Call store_data\n");
1221 if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1224 jcr->JobBytes += wsize;
1225 Dmsg2(130, "Flush write %u bytes, JobBytes=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1227 /* Move any remaining data to start of buffer */
1228 if (cipher_ctx->buf_len > 0) {
1229 Dmsg1(130, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1230 memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1231 cipher_ctx->buf_len);
1233 /* The packet was successfully written, reset the length so that the next
1234 * packet length may be re-read by unser_crypto_packet_len() */
1235 cipher_ctx->packet_len = 0;
1237 if (cipher_ctx->buf_len >0 && !second_pass) {
1242 /* Stop decryption */
1243 cipher_ctx->buf_len = 0;
1244 cipher_ctx->packet_len = 0;
1249 static void deallocate_cipher(r_ctx &rctx)
1251 /* Flush and deallocate previous stream's cipher context */
1252 if (rctx.cipher_ctx.cipher) {
1253 flush_cipher(rctx.jcr, &rctx.bfd, &rctx.fileAddr, rctx.flags, &rctx.cipher_ctx);
1254 crypto_cipher_free(rctx.cipher_ctx.cipher);
1255 rctx.cipher_ctx.cipher = NULL;
1259 static void deallocate_fork_cipher(r_ctx &rctx)
1262 /* Flush and deallocate previous stream's fork cipher context */
1263 if (rctx.fork_cipher_ctx.cipher) {
1264 flush_cipher(rctx.jcr, &rctx.forkbfd, &rctx.fork_addr, rctx.fork_flags, &rctx.fork_cipher_ctx);
1265 crypto_cipher_free(rctx.fork_cipher_ctx.cipher);
1266 rctx.fork_cipher_ctx.cipher = NULL;
1270 static void free_signature(r_ctx &rctx)
1273 crypto_sign_free(rctx.sig);
1278 static void free_session(r_ctx &rctx)
1281 crypto_session_free(rctx.cs);
1287 /* This code if implemented goes above */
1288 #ifdef stbernard_implemented
1289 / #if defined(HAVE_WIN32)
1290 bool bResumeOfmOnExit = FALSE;
1291 if (isOpenFileManagerRunning()) {
1292 if ( pauseOpenFileManager() ) {
1293 Jmsg(jcr, M_INFO, 0, _("Open File Manager paused\n") );
1294 bResumeOfmOnExit = TRUE;
1297 Jmsg(jcr, M_ERROR, 0, _("FAILED to pause Open File Manager\n") );
1301 char username[UNLEN+1];
1302 DWORD usize = sizeof(username);
1303 int privs = enable_backup_privileges(NULL, 1);
1304 if (GetUserName(username, &usize)) {
1305 Jmsg2(jcr, M_INFO, 0, _("Running as '%s'. Privmask=%#08x\n"), username,
1307 Jmsg(jcr, M_WARNING, 0, _("Failed to retrieve current UserName\n"));