void I18nModeInit() { char *i18nuser = value_of(VarUser); FILE *i18nspool; if (i18n_initialize() != 0) return; if (!i18nuser) i18nuser = zmMainName(); real_spoolfile = ftrack_CreateStat(spoolfile, NULL, i18n_mirror_spool, NULL); if (!real_spoolfile) error(SysErrFatal, catgets( catalog, CAT_SHELL, 819, "Cannot create monitor for mailbox." )); i18nspool = open_tempfile(i18nuser, &spoolfile); if (!i18nspool) error(SysErrFatal, catgets( catalog, CAT_SHELL, 820, "Cannot create copy of spoolfile for translation." )); else (void) fclose(i18nspool); fake_spoolfile = ftrack_Create(spoolfile, NULL, NULL); if (!fake_spoolfile) { error(SysErrFatal, catgets( catalog, CAT_SHELL, 821, "Cannot create monitor for mailbox update." )); } ftrack_Init(fake_spoolfile, NULL, i18n_update_spool, vaptr((char *) fake_spoolfile, (char *) real_spoolfile, NULL)); ftrack_Add(global_ftlist, real_spoolfile); }
/** set the filename and see if we need to do the plugin */ void content::set_filename(const string &filename) { this->evidence_filename = filename; this->do_plugin = plugin_match(this->evidence_filename); if(do_plugin || opt_magic) open_tempfile(); if(opt_save) open_savefile(); }
/* In the pinfo->file list, we replace all the instances of the target * file (except the first) with a temporary file that we can read and * write at will. If some replacements were performed, then tempfile is * not null. * The tempfile is opened exclusively, and should be kept open throughout * the lifetime of xml-mv as a way of guaranteeing privacy. */ bool_t substitute_target(parserinfo_mv_t *pinfo) { bool_t first = TRUE; int i; if( pinfo ) { for(i = 0; i < pinfo->n; i++) { if( strcmp(pinfo->files[i],pinfo->target) == 0 ) { if( !first ) { if( !pinfo->tempfile ) { pinfo->tempfile = make_template_tempfile(progname); pinfo->tempfd = open_tempfile(pinfo->tempfile); if( pinfo->tempfd == -1 ) { errormsg(E_FATAL, "could not create temporary file %s, aborting.\n", pinfo->tempfile); } } pinfo->files[i] = pinfo->tempfile; } else { first = FALSE; } } } return (pinfo->tempfile != NULL); } return FALSE; }
/* Generate a temporary file containing sort-of random data. Diffs between files of random data tend to be pretty boring, so we try to make sure there are a bunch of common substrings between two runs of this function with the same seedbase. */ static apr_file_t * generate_random_file(apr_uint32_t maxlen, apr_uint32_t subseed_base, apr_uint32_t *seed, const char *random_bytes, apr_size_t bytes_range, int dump_files, apr_pool_t *pool) { static char file_buffer[10240]; char *buf = file_buffer; char *const end = buf + sizeof file_buffer; apr_uint32_t len, seqlen; apr_file_t *fp; unsigned long r; fp = open_tempfile("random_XXXXXX", pool); len = svn_test_rand(seed) % maxlen; /* We might go over this by a bit. */ while (len > 0) { /* Generate a pseudo-random sequence of up to MAXSEQ bytes, where the seed is in the range [seedbase..seedbase+MAXSEQ-1]. (Use our own pseudo-random number generator here to avoid clobbering the seed of the libc random number generator.) */ seqlen = svn_test_rand(seed) % MAXSEQ; if (seqlen > len) seqlen = len; len -= seqlen; r = subseed_base + svn_test_rand(seed) % SEEDS; while (seqlen-- > 0) { const int ch = (random_bytes ? (unsigned)random_bytes[r % bytes_range] : (int)(r % bytes_range)); if (buf == end) { apr_size_t ignore_length; apr_file_write_full(fp, file_buffer, sizeof file_buffer, &ignore_length); buf = file_buffer; } *buf++ = (char)ch; r = r * 1103515245 + 12345; } } if (buf > file_buffer) { apr_size_t ignore_length; apr_file_write_full(fp, file_buffer, buf - file_buffer, &ignore_length); } rewind_file(fp); if (dump_files) dump_file_contents(fp); return fp; }
int main ( int argc, char *argv[] ) { Param params; FlowCom *comPtr = NULL; char line [ LINE_LEN ]; while ( argc > 1 ) { if ( !strcmp( argv[1], "-D" ) ) { setDebugFlag(); } else if ( !strcmp( argv[1], "-V" ) ) { printf ( "%s\n", VERSION ); exit ( 0 ); } else { break; } argv++; argc--; } open_tempfile(); open_infile ( ( argc > 1 ) ? argv[ 1 ] : NULL ); tprintf ( "%% picture environment flowchart generated by flow " ); tprintf ( "%s\n", VERSION ); while ( readline_infile ( line, LINE_LEN ) != NULL ) { if ( ( comPtr = getCommand ( line, params ) ) != NULL ) { switch ( comPtr -> command ) { case MACRO: if ( doMacro ( params ) ) { errout ( E_NO_END_MACRO ); } break; case EXPAND: doExpand ( params ); break; default: if ( !doCommand ( comPtr, params ) ) { return 10; } } } else { break; } } close_infile(); close_tempfile(); apply_tempfile ( getPic(), ( argc > 2 ) ? argv[ 2 ] : NULL ); remove_tempfile(); // dumpFigure(); return 0; /* just to suppress the warning */ }
static apr_file_t * copy_tempfile(apr_file_t *fp, apr_pool_t *pool) { static char file_buffer[10240]; apr_file_t *newfp; apr_size_t length1, length2; newfp = open_tempfile("copy_XXXXXX", pool); rewind_file(fp); do { apr_file_read_full(fp, file_buffer, sizeof file_buffer, &length1); apr_file_write_full(newfp, file_buffer, length1, &length2); assert(length1 == length2); } while (length1 == sizeof file_buffer); rewind_file(fp); rewind_file(newfp); return newfp; }
// Encrypt contents of stdin and write to stdout void clean (const char* keyfile) { keys_t keys; load_keys(keyfile, &keys); // Read the entire file hmac_sha1_state hmac(keys.hmac, HMAC_KEY_LEN); // Calculate the file's SHA1 HMAC as we go uint64_t file_size = 0; // Keep track of the length, make sure it doesn't get too big std::string file_contents; // First 8MB or so of the file go here std::fstream temp_file; // The rest of the file spills into a temporary file on disk temp_file.exceptions(std::fstream::badbit); char buffer[1024]; while (std::cin && file_size < MAX_CRYPT_BYTES) { std::cin.read(buffer, sizeof(buffer)); size_t bytes_read = std::cin.gcount(); hmac.add(reinterpret_cast<unsigned char*>(buffer), bytes_read); file_size += bytes_read; if (file_size <= 8388608) { file_contents.append(buffer, bytes_read); } else { if (!temp_file.is_open()) { open_tempfile(temp_file, std::fstream::in | std::fstream::out | std::fstream::binary | std::fstream::app); } temp_file.write(buffer, bytes_read); } } // Make sure the file isn't so large we'll overflow the counter value (which would doom security) if (file_size >= MAX_CRYPT_BYTES) { std::clog << "File too long to encrypt securely\n"; std::exit(1); } // We use an HMAC of the file as the encryption nonce (IV) for CTR mode. // By using a hash of the file we ensure that the encryption is // deterministic so git doesn't think the file has changed when it really // hasn't. CTR mode with a synthetic IV is provably semantically secure // under deterministic CPA as long as the synthetic IV is derived from a // secure PRF applied to the message. Since HMAC-SHA1 is a secure PRF, this // encryption scheme is semantically secure under deterministic CPA. // // Informally, consider that if a file changes just a tiny bit, the IV will // be completely different, resulting in a completely different ciphertext // that leaks no information about the similarities of the plaintexts. Also, // since we're using the output from a secure hash function plus a counter // as the input to our block cipher, we should never have a situation where // two different plaintext blocks get encrypted with the same CTR value. A // nonce will be reused only if the entire file is the same, which leaks no // information except that the files are the same. // // To prevent an attacker from building a dictionary of hash values and then // looking up the nonce (which must be stored in the clear to allow for // decryption), we use an HMAC as opposed to a straight hash. uint8_t digest[SHA1_LEN]; hmac.get(digest); // Write a header that... std::cout.write("\0GITCRYPT\0", 10); // ...identifies this as an encrypted file std::cout.write(reinterpret_cast<char*>(digest), NONCE_LEN); // ...includes the nonce // Now encrypt the file and write to stdout aes_ctr_state state(digest, NONCE_LEN); // First read from the in-memory copy const uint8_t* file_data = reinterpret_cast<const uint8_t*>(file_contents.data()); size_t file_data_len = file_contents.size(); for (size_t i = 0; i < file_data_len; i += sizeof(buffer)) { size_t buffer_len = std::min(sizeof(buffer), file_data_len - i); state.process(&keys.enc, file_data + i, reinterpret_cast<uint8_t*>(buffer), buffer_len); std::cout.write(buffer, buffer_len); } // Then read from the temporary file if applicable if (temp_file.is_open()) { temp_file.seekg(0); while (temp_file) { temp_file.read(buffer, sizeof(buffer)); size_t buffer_len = temp_file.gcount(); state.process(&keys.enc, reinterpret_cast<uint8_t*>(buffer), reinterpret_cast<uint8_t*>(buffer), buffer_len); std::cout.write(buffer, buffer_len); } } }
/* (Note: *LAST_SEED is an output parameter.) */ static svn_error_t * do_random_combine_test(const char **msg, svn_boolean_t msg_only, apr_pool_t *pool, apr_uint32_t *last_seed) { static char msg_buff[256]; apr_uint32_t seed, bytes_range, maxlen; int i, iterations, dump_files, print_windows; const char *random_bytes; /* Initialize parameters and print out the seed in case we dump core or something. */ init_params(&seed, &maxlen, &iterations, &dump_files, &print_windows, &random_bytes, &bytes_range, pool); sprintf(msg_buff, "random combine delta test, seed = %lu", (unsigned long) seed); *msg = msg_buff; if (msg_only) return SVN_NO_ERROR; else printf("SEED: %s\n", msg_buff); for (i = 0; i < iterations; i++) { /* Generate source and target for the delta and its application. */ apr_uint32_t subseed_base = svn_test_rand((*last_seed = seed, &seed)); apr_file_t *source = generate_random_file(maxlen, subseed_base, &seed, random_bytes, bytes_range, dump_files, pool); apr_file_t *middle = generate_random_file(maxlen, subseed_base, &seed, random_bytes, bytes_range, dump_files, pool); apr_file_t *target = generate_random_file(maxlen, subseed_base, &seed, random_bytes, bytes_range, dump_files, pool); apr_file_t *source_copy = copy_tempfile(source, pool); apr_file_t *middle_copy = copy_tempfile(middle, pool); apr_file_t *target_regen = open_tempfile(NULL, pool); svn_txdelta_stream_t *txdelta_stream_A; svn_txdelta_stream_t *txdelta_stream_B; svn_txdelta_window_handler_t handler; svn_stream_t *stream; void *handler_baton; /* Set up a four-stage pipeline: create two deltas, combine them and convert the result to svndiff format, parse that back into delta format, and apply it to a copy of the source file to see if we get the same target back. */ apr_pool_t *delta_pool = svn_pool_create(pool); /* Make stage 4: apply the text delta. */ svn_txdelta_apply(svn_stream_from_aprfile(source_copy, delta_pool), svn_stream_from_aprfile(target_regen, delta_pool), NULL, NULL, delta_pool, &handler, &handler_baton); /* Make stage 3: reparse the text delta. */ stream = svn_txdelta_parse_svndiff(handler, handler_baton, TRUE, delta_pool); /* Make stage 2: encode the text delta in svndiff format. */ svn_txdelta_to_svndiff2(&handler, &handler_baton, stream, 1, delta_pool); /* Make stage 1: create the text deltas. */ svn_txdelta(&txdelta_stream_A, svn_stream_from_aprfile(source, delta_pool), svn_stream_from_aprfile(middle, delta_pool), delta_pool); svn_txdelta(&txdelta_stream_B, svn_stream_from_aprfile(middle_copy, delta_pool), svn_stream_from_aprfile(target, delta_pool), delta_pool); { svn_txdelta_window_t *window_A; svn_txdelta_window_t *window_B; svn_txdelta_window_t *composite; apr_pool_t *wpool = svn_pool_create(delta_pool); do { SVN_ERR(svn_txdelta_next_window(&window_A, txdelta_stream_A, wpool)); if (print_windows) delta_window_print(window_A, "A ", stdout); SVN_ERR(svn_txdelta_next_window(&window_B, txdelta_stream_B, wpool)); if (print_windows) delta_window_print(window_B, "B ", stdout); if (!window_B) break; assert(window_A != NULL || window_B->src_ops == 0); if (window_B->src_ops == 0) { composite = window_B; composite->sview_len = 0; } else composite = svn_txdelta_compose_windows(window_A, window_B, wpool); if (print_windows) delta_window_print(composite, "AB", stdout); /* The source view length should not be 0 if there are source copy ops in the window. */ if (composite && composite->sview_len == 0 && composite->src_ops > 0) return svn_error_create (SVN_ERR_FS_GENERAL, NULL, "combined delta window is inconsistent"); SVN_ERR(handler(composite, handler_baton)); svn_pool_clear(wpool); } while (composite != NULL); svn_pool_destroy(wpool); } svn_pool_destroy(delta_pool); SVN_ERR(compare_files(target, target_regen, dump_files)); apr_file_close(source); apr_file_close(middle); apr_file_close(target); apr_file_close(source_copy); apr_file_close(middle_copy); apr_file_close(target_regen); } return SVN_NO_ERROR; }
/* Implements svn_test_driver_t. */ static svn_error_t * random_test(const char **msg, svn_boolean_t msg_only, svn_test_opts_t *opts, apr_pool_t *pool) { static char msg_buff[256]; apr_uint32_t seed, bytes_range, maxlen; int i, iterations, dump_files, print_windows; const char *random_bytes; /* Initialize parameters and print out the seed in case we dump core or something. */ init_params(&seed, &maxlen, &iterations, &dump_files, &print_windows, &random_bytes, &bytes_range, pool); sprintf(msg_buff, "random delta test, seed = %lu", (unsigned long) seed); *msg = msg_buff; if (msg_only) return SVN_NO_ERROR; else printf("SEED: %s\n", msg_buff); for (i = 0; i < iterations; i++) { /* Generate source and target for the delta and its application. */ apr_uint32_t subseed_base = svn_test_rand(&seed); apr_file_t *source = generate_random_file(maxlen, subseed_base, &seed, random_bytes, bytes_range, dump_files, pool); apr_file_t *target = generate_random_file(maxlen, subseed_base, &seed, random_bytes, bytes_range, dump_files, pool); apr_file_t *source_copy = copy_tempfile(source, pool); apr_file_t *target_regen = open_tempfile(NULL, pool); svn_txdelta_stream_t *txdelta_stream; svn_txdelta_window_handler_t handler; svn_stream_t *stream; void *handler_baton; /* Set up a four-stage pipeline: create a delta, convert it to svndiff format, parse it back into delta format, and apply it to a copy of the source file to see if we get the same target back. */ apr_pool_t *delta_pool = svn_pool_create(pool); /* Make stage 4: apply the text delta. */ svn_txdelta_apply(svn_stream_from_aprfile(source_copy, delta_pool), svn_stream_from_aprfile(target_regen, delta_pool), NULL, NULL, delta_pool, &handler, &handler_baton); /* Make stage 3: reparse the text delta. */ stream = svn_txdelta_parse_svndiff(handler, handler_baton, TRUE, delta_pool); /* Make stage 2: encode the text delta in svndiff format. */ svn_txdelta_to_svndiff2(&handler, &handler_baton, stream, 1, delta_pool); /* Make stage 1: create the text delta. */ svn_txdelta(&txdelta_stream, svn_stream_from_aprfile(source, delta_pool), svn_stream_from_aprfile(target, delta_pool), delta_pool); SVN_ERR(svn_txdelta_send_txstream(txdelta_stream, handler, handler_baton, delta_pool)); svn_pool_destroy(delta_pool); SVN_ERR(compare_files(target, target_regen, dump_files)); apr_file_close(source); apr_file_close(target); apr_file_close(source_copy); apr_file_close(target_regen); } return SVN_NO_ERROR; }
/* Implements svn_test_driver_t. */ static svn_error_t * random_test(apr_pool_t *pool) { apr_uint32_t seed, maxlen; apr_size_t bytes_range; int i, iterations, dump_files, print_windows; const char *random_bytes; /* Initialize parameters and print out the seed in case we dump core or something. */ init_params(&seed, &maxlen, &iterations, &dump_files, &print_windows, &random_bytes, &bytes_range, pool); for (i = 0; i < iterations; i++) { /* Generate source and target for the delta and its application. */ apr_uint32_t subseed_base = svn_test_rand(&seed); apr_file_t *source = generate_random_file(maxlen, subseed_base, &seed, random_bytes, bytes_range, dump_files, pool); apr_file_t *target = generate_random_file(maxlen, subseed_base, &seed, random_bytes, bytes_range, dump_files, pool); apr_file_t *source_copy = copy_tempfile(source, pool); apr_file_t *target_regen = open_tempfile(NULL, pool); svn_txdelta_stream_t *txdelta_stream; svn_txdelta_window_handler_t handler; svn_stream_t *stream; void *handler_baton; /* Set up a four-stage pipeline: create a delta, convert it to svndiff format, parse it back into delta format, and apply it to a copy of the source file to see if we get the same target back. */ apr_pool_t *delta_pool = svn_pool_create(pool); /* Make stage 4: apply the text delta. */ svn_txdelta_apply(svn_stream_from_aprfile(source_copy, delta_pool), svn_stream_from_aprfile(target_regen, delta_pool), NULL, NULL, delta_pool, &handler, &handler_baton); /* Make stage 3: reparse the text delta. */ stream = svn_txdelta_parse_svndiff(handler, handler_baton, TRUE, delta_pool); /* Make stage 2: encode the text delta in svndiff format using varying compression levels. */ svn_txdelta_to_svndiff3(&handler, &handler_baton, stream, 1, i % 10, delta_pool); /* Make stage 1: create the text delta. */ svn_txdelta2(&txdelta_stream, svn_stream_from_aprfile(source, delta_pool), svn_stream_from_aprfile(target, delta_pool), FALSE, delta_pool); SVN_ERR(svn_txdelta_send_txstream(txdelta_stream, handler, handler_baton, delta_pool)); svn_pool_destroy(delta_pool); SVN_ERR(compare_files(target, target_regen, dump_files)); apr_file_close(source); apr_file_close(target); apr_file_close(source_copy); apr_file_close(target_regen); } return SVN_NO_ERROR; }