/* One version is public and will not modify the distribution hash, the other will. */ static uint32_t _generate_hash_wrapper(const memcached_st *ptr, const char *key, size_t key_length) { WATCHPOINT_ASSERT(memcached_server_count(ptr)); if (memcached_server_count(ptr) == 1) return 0; if (ptr->flags.hash_with_prefix_key) { size_t temp_length= ptr->prefix_key_length + key_length; char *temp = malloc(temp_length); uint32_t ret; if (temp_length > MEMCACHED_MAX_KEY -1) return 0; strncpy(temp, ptr->prefix_key, ptr->prefix_key_length); strncpy(temp + ptr->prefix_key_length, key, key_length); ret = generate_hash(ptr, temp, temp_length); free(temp); return ret; } else { return generate_hash(ptr, key, key_length); } }
int main(void) { char *teststr = "something"; char *teststr2 = "elsetohjk"; int length, length2; unsigned int hash; int limit = LIMIT; printf("Number of hashes: %d\n", limit); assert(sizeof(int) == 4); length = strlen(teststr); length2 = strlen(teststr2); for (limit=0; limit < LIMIT; limit += 2) { hash = generate_hash(teststr2, length2); hash = generate_hash(teststr, length); // hash = SuperFastHash(teststr, length); // hash = SuperFastHash(teststr2, length2); } printf("hash of '%s' is: %u (%08x)\n", teststr, hash, hash); return 0; }
size_t hash() { if(!hashed) generate_hash(); return hash_value; }
static size_t hashmap_bucket_index( const hashmap_t *hashmap, hashmap_key_t key ) { assert( NULL != hashmap ); assert( NULL != key ); return generate_hash( key, strlen( key ) ) % hashmap->num_buckets; }
bool decrypt(int hash_mode, int crypto_mode, int version, unsigned char *in, unsigned char *out, int length, unsigned char *key, unsigned char *iv, unsigned char *hash, unsigned char *test_hash) { // Setup buffers for key, iv and hash. unsigned char key_final[0x10] = {}; unsigned char iv_final[0x10] = {}; unsigned char hash_final_10[0x10] = {}; unsigned char hash_final_14[0x14] = {}; // Generate crypto key and hash. generate_key(crypto_mode, version, key_final, iv_final, key, iv); if ((hash_mode & 0xFF) == 0x01) generate_hash(hash_mode, version, hash_final_14, hash); else generate_hash(hash_mode, version, hash_final_10, hash); if ((crypto_mode & 0xFF) == 0x01) // No algorithm. { memcpy(out, in, length); } else if ((crypto_mode & 0xFF) == 0x02) // AES128-CBC { aescbc128_decrypt(key_final, iv_final, in, out, length); } else { LOG_ERROR(LOADER, "EDAT: Unknown crypto algorithm!"); return false; } if ((hash_mode & 0xFF) == 0x01) // 0x14 SHA1-HMAC { return hmac_hash_compare(hash_final_14, 0x14, in, length, test_hash, 0x14); } else if ((hash_mode & 0xFF) == 0x02) // 0x10 AES-CMAC { return cmac_hash_compare(hash_final_10, 0x10, in, length, test_hash, 0x10); } else if ((hash_mode & 0xFF) == 0x04) //0x10 SHA1-HMAC { return hmac_hash_compare(hash_final_10, 0x10, in, length, test_hash, 0x10); } else { LOG_ERROR(LOADER, "EDAT: Unknown hashing algorithm!"); return false; } }
/* * Create a new user session. This is done upon each successful login. */ void create_session(unsigned long long sid) { char session_id[SID_LEN + 1]; char restrict_ip[2] = "0\0"; char pkbuf[256]; char timestamp[21]; char ssid[21]; char tenant[TENANT_MAX + 1]; char *username; int primary_key_size; MYSQL_RES *res; TCTDB *tdb; TCMAP *cols; GHashTable *db_row = NULL; username = make_mysql_safe_string(get_var(qvars, "username")); res = sql_query("SELECT uid, name, capabilities FROM passwd WHERE " "username = '******'", username); db_row = get_dbrow(res); get_tenant(env_vars.host, tenant); generate_hash(session_id, SHA256); if (strcmp(get_var(qvars, "restrict_ip"), "true") == 0) { d_fprintf(debug_log, "Restricting session to origin ip " "address\n"); restrict_ip[0] = '1'; } tdb = tctdbnew(); tctdbopen(tdb, SESSION_DB, TDBOWRITER | TDBOCREAT); primary_key_size = sprintf(pkbuf, "%ld", (long)tctdbgenuid(tdb)); snprintf(timestamp, sizeof(timestamp), "%ld", (long)time(NULL)); snprintf(ssid, sizeof(ssid), "%llu", sid); cols = tcmapnew3("tenant", tenant, "sid", ssid, "uid", get_var(db_row, "uid"), "username", get_var(qvars, "username"), "name", get_var(db_row, "name"), "login_at", timestamp, "last_seen", timestamp, "origin_ip", env_vars.remote_addr, "client_id", env_vars.http_user_agent, "session_id", session_id, "csrf_token", "\0", "restrict_ip", restrict_ip, "capabilities", get_var(db_row, "capabilities"), NULL); tctdbput(tdb, pkbuf, primary_key_size, cols); tcmapdel(cols); tctdbclose(tdb); tctdbdel(tdb); fcgx_p("Set-Cookie: session_id=%s; path=/; httponly\r\n", session_id); mysql_free_result(res); free_vars(db_row); free(username); }
int main(int argc, char** argv) { for(std::vector<testcase>::const_iterator i = tests.begin(); i != tests.end(); ++i) { std::string hash = to_string(generate_hash(i->schema)); if(hash.compare(i->hash) == 0) { std::cout << "OK " << hash << std::endl; } else { std::cout << "FAILED got:" << hash << ", expected:" << i->hash << std::endl; } } }
int file_data_write(struct File *f, char *buf, size_t count, int block_no) { int err; int pblk, hash_addr; int addr; int hash_second_table_addr; int second_table_offset; int flag = 0; uint32_t hash = generate_hash(buf, BLKSIZE); int hash_first_table_addr = HashBlock_Start + (hash & HashLowBits); fseek(fp,hash_first_table_addr,SEEK_SET); fread(&addr, sizeof(int), 1, fp); if(addr == 0) { if(alloc_block(&hash_addr) < 0) { printf("\n error in block allocation for write"); return -1; } fseek(fp,hash_first_table_addr,SEEK_SET); fwrite(&hash_addr, sizeof(int), 1, fp); flush_block(hash_addr); if((err = file_get_block(f, block_no, &pblk)) < 0) { printf("\n error in getting block for write"); return -1; } flush_block(pblk); fseek(fp,pblk,SEEK_SET); fwrite(buf, count, 1, fp); f->f_size += count; f->f_written += count; f->n_blocks += 1; super->total_blocks+=1; super->written_blocks+=1; second_table_offset = (hash & HashHighBits) >> 25; hash_second_table_addr = (int)((int *)hash_addr + second_table_offset); fseek(fp,hash_second_table_addr,SEEK_SET); fwrite(&pblk, sizeof(int), 1, fp); } else {
static int crypt_all(int *pcount, struct db_salt *salt) { const int count = *pcount; int index = 0; #ifdef _OPENMP #pragma omp parallel for for (index = 0; index < count; index++) #endif { unsigned int g_seed = 0x3f; struct JtR_FEAL8_CTX ctx; generate_hash((unsigned char*)saved_key[index], saved_salt, (unsigned char*)crypt_out[index], &g_seed, &ctx); } return count; }
/** * is_component_authenticated() usage the code, signature & public key retrieved * for each component. * * @src: char * * @sig: char * * @cert: char * */ int is_component_authenticated(char *src, char *sig, char *cert) { char command[256]; char *computed_hash; char *reference_hash; char pub_key[] = "/tmp/pub_keyXXXXXX", *pub_file; char code_hash[] = "/tmp/code_hash_XXXXXX", *code_file; char tmp_hash[] = "/tmp/tmp_hash_XXXXXX", *tmp_file; char f_computed_hash[] = "/tmp/computed_hash_XXXXXX", *computed_file; char f_reference_hash[] = "/tmp/reference_hash_XXXXXX", *reference_file; char sw_file[32],hw_file[32]; int retval; if (!create_file("src", src, src_size) || !create_file("sig", sig, SIG_SIZE) || !create_file("cert", cert, CERT_SIZE)) { return 0; } pub_file = mktemp(pub_key); sprintf(command, "openssl x509 -in cert -pubkey -inform DER -noout > %s", pub_file); retval = system(command); if (retval != 0) { remove("src"); remove("sig"); remove("cert"); printf("Error generating public key\n"); return 0; } generate_hash(cert, sw_file, hw_file); code_file = mktemp(code_hash); sprintf(command, "openssl dgst -sha256 -binary -out %s src", code_file); retval = system(command); if (retval != 0) { remove_file(sw_file, hw_file, code_file, pub_file); printf("Error in openssl digest\n"); return 0; } tmp_file = mktemp(tmp_hash); sprintf(command, "cat %s %s | openssl dgst -sha256 -binary -out %s", sw_file, code_file, tmp_file); retval = system(command); if (retval != 0) { remove_file(sw_file, hw_file, code_file, pub_file); remove(tmp_file); printf("Error generating temp has\n"); return 0; } computed_file = mktemp(f_computed_hash); sprintf(command, "cat %s %s | openssl dgst -sha256 -binary -out %s", hw_file, tmp_file, computed_file); retval = system(command); if (retval != 0) { remove_file(sw_file, hw_file, code_file, pub_file); remove(tmp_file); remove(computed_file); printf("Error generating hash\n"); return 0; } reference_file = mktemp(f_reference_hash); sprintf(command, "openssl rsautl -in sig -pubin -inkey %s -verify > %s", pub_file, reference_file); retval = system(command); if (retval != 0) { remove_file(sw_file, hw_file, code_file, pub_file); remove(tmp_file); remove(computed_file); remove(reference_file); printf("Error generating reference hash\n"); return 0; } computed_hash = read_file(computed_file); reference_hash = read_file(reference_file); remove_file(sw_file, hw_file, code_file, pub_file); remove(tmp_file); remove(computed_file); remove(reference_file); if (strcmp(computed_hash, reference_hash)) { free(computed_hash); free(reference_hash); return 1; } free(computed_hash); free(reference_hash); return 0; }
/* * This file does the per-file evaluation and is run to generate every entry * in the manifest. * * All output is written to a pipe which is read by the child process, * which is running output_manifest(). */ static int eval_file(const char *fname, const struct stat64 *statb) { int fd, ret, err_code, i; char last_field[PATH_MAX], ftype, *acl_str, *quoted_name; err_code = EXIT; switch (statb->st_mode & S_IFMT) { /* Regular file */ case S_IFREG: ftype = 'F'; break; /* Directory */ case S_IFDIR: ftype = 'D'; break; /* Block Device */ case S_IFBLK: ftype = 'B'; break; /* Character Device */ case S_IFCHR: ftype = 'C'; break; /* Named Pipe */ case S_IFIFO: ftype = 'P'; break; /* Socket */ case S_IFSOCK: ftype = 'S'; break; /* Door */ case S_IFDOOR: ftype = 'O'; break; /* Symbolic link */ case S_IFLNK: ftype = 'L'; break; default: ftype = '-'; break; } /* First, make sure this file should be cataloged */ if ((subtree_root != NULL) && (exclude_fname(fname, ftype, subtree_root))) return (err_code); for (i = 0; i < PATH_MAX; i++) last_field[i] = '\0'; /* * Regular files, compute the MD5 checksum and put it into 'last_field' * UNLESS instructed to ignore the checksums. */ if (ftype == 'F') { if (compute_chksum) { fd = open(fname, O_RDONLY|O_LARGEFILE); if (fd < 0) { err_code = WARNING_EXIT; perror(fname); /* default value since the computution failed */ (void) strcpy(last_field, "-"); } else { if (generate_hash(fd, last_field) != 0) { err_code = WARNING_EXIT; (void) fprintf(stderr, CONTENTS_WARN, fname); (void) strcpy(last_field, "-"); } } (void) close(fd); } /* Instructed to ignore checksums, just put in a '-' */ else (void) strcpy(last_field, "-"); } /* * For symbolic links, put the destination of the symbolic link into * 'last_field' */ if (ftype == 'L') { ret = readlink(fname, last_field, sizeof (last_field)); if (ret < 0) { err_code = WARNING_EXIT; perror(fname); /* default value since the computation failed */ (void) strcpy(last_field, "-"); } else (void) strlcpy(last_field, sanitized_fname(last_field, B_FALSE), sizeof (last_field)); /* * Boundary condition: possible for a symlink to point to * nothing [ ln -s '' link_name ]. For this case, set the * destination to "\000". */ if (strlen(last_field) == 0) (void) strcpy(last_field, "\\000"); } acl_str = get_acl_string(fname, statb, &err_code); /* Sanitize 'fname', so its in the proper format for the manifest */ quoted_name = sanitized_fname(fname, B_TRUE); /* Start to build the entry.... */ (void) printf("%s %c %d %o %s %x %d %d", quoted_name, ftype, (int)statb->st_size, (int)statb->st_mode, acl_str, (int)statb->st_mtime, (int)statb->st_uid, (int)statb->st_gid); /* Finish it off based upon whether or not it's a device node */ if ((ftype == 'B') && (ftype == 'C')) (void) printf(" %x\n", (int)statb->st_rdev); else if (strlen(last_field) > 0) (void) printf(" %s\n", last_field); else (void) printf("\n"); /* free the memory consumed */ free(acl_str); free(quoted_name); return (err_code); }
uint32_t Module::hash() const { HashGenerator hashgen; generate_hash(hashgen); return hashgen.hash(); }
boost::uuids::uuid generate_hash(const char* schema) { const avro::ValidSchema validSchema(avro::compileJsonSchemaFromString(schema)); boost::uuids::uuid uuid = generate_hash(validSchema); return uuid; }
static gboolean option_file_list = FALSE; static gboolean option_lookup_ean = FALSE; static char *ean_service = NULL; static char *access_key = NULL; static char *private_key = NULL; static char *associate_tag = NULL; static guint num_queries = 0; static GMainLoop *loop = NULL; static GHashTable *create_params (void); static void test_hash (void) { /* From http://github.com/kastner/dvd_fingerprint/blob/master/dvd_fingerprint.rb */ g_assert_cmpstr (generate_hash (":/VIDEO_TS/VIDEO_TS.BUP:12288:/VIDEO_TS/VIDEO_TS.IFO:12288:/VIDEO_TS/VIDEO_TS.VOB:58052608:/VIDEO_TS/VTS_01_0.BUP:98304:/VIDEO_TS/VTS_01_0.IFO:98304:/VIDEO_TS/VTS_01_0.VOB:75163648:/VIDEO_TS/VTS_01_1.VOB:1073598464:/VIDEO_TS/VTS_01_2.VOB:1073448960:/VIDEO_TS/VTS_01_3.VOB:1073741824:/VIDEO_TS/VTS_01_4.VOB:1073647616:/VIDEO_TS/VTS_01_5.VOB:835813376", -1), ==, "2075AB92-06CD-ED43-A753-2B75627BE844"); } static void test_file_list (void) { guint i; struct { const char *dir; const char *gtin; const char *file_list; } directories[] = { { "Alexander Nevsky", "3809DA3F-8323-2E48-70C6-861B34968674", ":/VIDEO_TS/VIDEO_TS.BUP:18432:/VIDEO_TS/VIDEO_TS.IFO:18432:/VIDEO_TS/VIDEO_TS.VOB:178176:/VIDEO_TS/VTS_01_0.BUP:24576:/VIDEO_TS/VTS_01_0.IFO:24576:/VIDEO_TS/VTS_01_0.VOB:104853504:/VIDEO_TS/VTS_01_1.VOB:13611008:/VIDEO_TS/VTS_02_0.BUP:18432:/VIDEO_TS/VTS_02_0.IFO:18432:/VIDEO_TS/VTS_02_0.VOB:178176:/VIDEO_TS/VTS_02_1.VOB:25085952:/VIDEO_TS/VTS_03_0.BUP:18432:/VIDEO_TS/VTS_03_0.IFO:18432:/VIDEO_TS/VTS_03_0.VOB:178176:/VIDEO_TS/VTS_03_1.VOB:9498624:/VIDEO_TS/VTS_04_0.BUP:18432:/VIDEO_TS/VTS_04_0.IFO:18432:/VIDEO_TS/VTS_04_0.VOB:178176:/VIDEO_TS/VTS_04_1.VOB:2146304:/VIDEO_TS/VTS_05_0.BUP:65536:/VIDEO_TS/VTS_05_0.IFO:65536:/VIDEO_TS/VTS_05_0.VOB:178176:/VIDEO_TS/VTS_05_1.VOB:1073565696:/VIDEO_TS/VTS_05_2.VOB:1073565696:/VIDEO_TS/VTS_05_3.VOB:1073565696:/VIDEO_TS/VTS_05_4.VOB:1073565696:/VIDEO_TS/VTS_05_5.VOB:206231552" }, { "Être et Avoir", "D2740096-2507-09FC-EE0F-D577CBF98536", ":/VIDEO_TS/VIDEO_TS.BUP:22528:/VIDEO_TS/VIDEO_TS.IFO:22528:/VIDEO_TS/VIDEO_TS.VOB:157696:/VIDEO_TS/VTS_01_0.BUP:24576:/VIDEO_TS/VTS_01_0.IFO:24576:/VIDEO_TS/VTS_01_0.VOB:58773504:/VIDEO_TS/VTS_01_1.VOB:9805824:/VIDEO_TS/VTS_02_0.BUP:18432:/VIDEO_TS/VTS_02_0.IFO:18432:/VIDEO_TS/VTS_02_0.VOB:157696:/VIDEO_TS/VTS_02_1.VOB:3958784:/VIDEO_TS/VTS_03_0.BUP:18432:/VIDEO_TS/VTS_03_0.IFO:18432:/VIDEO_TS/VTS_03_0.VOB:157696:/VIDEO_TS/VTS_03_1.VOB:80705536:/VIDEO_TS/VTS_04_0.BUP:18432:/VIDEO_TS/VTS_04_0.IFO:18432:/VIDEO_TS/VTS_04_0.VOB:157696:/VIDEO_TS/VTS_04_1.VOB:99594240:/VIDEO_TS/VTS_05_0.BUP:18432:/VIDEO_TS/VTS_05_0.IFO:18432:/VIDEO_TS/VTS_05_0.VOB:157696:/VIDEO_TS/VTS_05_1.VOB:71680000:/VIDEO_TS/VTS_06_0.BUP:18432:/VIDEO_TS/VTS_06_0.IFO:18432:/VIDEO_TS/VTS_06_0.VOB:157696:/VIDEO_TS/VTS_06_1.VOB:148228096:/VIDEO_TS/VTS_07_0.BUP:18432:/VIDEO_TS/VTS_07_0.IFO:18432:/VIDEO_TS/VTS_07_0.VOB:157696:/VIDEO_TS/VTS_07_1.VOB:87965696:/VIDEO_TS/VTS_08_0.BUP:26624:/VIDEO_TS/VTS_08_0.IFO:26624:/VIDEO_TS/VTS_08_0.VOB:157696:/VIDEO_TS/VTS_08_1.VOB:426055680:/VIDEO_TS/VTS_09_0.BUP:73728:/VIDEO_TS/VTS_09_0.IFO:73728:/VIDEO_TS/VTS_09_0.VOB:157696:/VIDEO_TS/VTS_09_1.VOB:1073565696:/VIDEO_TS/VTS_09_2.VOB:1073565696:/VIDEO_TS/VTS_09_3.VOB:932294656" }, { "The Kite Runner", "5F03F0D5-6AB6-FDB4-43AE-825693898CFF", ":/VIDEO_TS/VIDEO_TS.BUP:20480:/VIDEO_TS/VIDEO_TS.IFO:20480:/VIDEO_TS/VIDEO_TS.VOB:935936:/VIDEO_TS/VTS_01_0.BUP:14336:/VIDEO_TS/VTS_01_0.IFO:14336:/VIDEO_TS/VTS_01_1.VOB:471040:/VIDEO_TS/VTS_02_0.BUP:24576:/VIDEO_TS/VTS_02_0.IFO:24576:/VIDEO_TS/VTS_02_0.VOB:13301760:/VIDEO_TS/VTS_02_1.VOB:423208960:/VIDEO_TS/VTS_03_0.BUP:18432:/VIDEO_TS/VTS_03_0.IFO:18432:/VIDEO_TS/VTS_03_0.VOB:229376:/VIDEO_TS/VTS_03_1.VOB:75370496:/VIDEO_TS/VTS_04_0.BUP:40960:/VIDEO_TS/VTS_04_0.IFO:40960:/VIDEO_TS/VTS_04_1.VOB:1073709056:/VIDEO_TS/VTS_04_2.VOB:327958528:/VIDEO_TS/VTS_05_0.BUP:90112:/VIDEO_TS/VTS_05_0.IFO:90112:/VIDEO_TS/VTS_05_0.VOB:58671104:/VIDEO_TS/VTS_05_1.VOB:1073709056:/VIDEO_TS/VTS_05_2.VOB:1073709056:/VIDEO_TS/VTS_05_3.VOB:1073709056:/VIDEO_TS/VTS_05_4.VOB:1073709056:/VIDEO_TS/VTS_05_5.VOB:884168704:/VIDEO_TS/VTS_06_0.BUP:14336:/VIDEO_TS/VTS_06_0.IFO:14336:/VIDEO_TS/VTS_06_1.VOB:43491328:/VIDEO_TS/VTS_07_0.BUP:18432:/VIDEO_TS/VTS_07_0.IFO:18432:/VIDEO_TS/VTS_07_0.VOB:18966528:/VIDEO_TS/VTS_07_1.VOB:6029312" }, { "The Straight Story", "4C059E8A-37E4-493E-6272-F9A713DB5AA9", ":/VIDEO_TS/VIDEO_TS.BUP:22528:/VIDEO_TS/VIDEO_TS.IFO:22528:/VIDEO_TS/VIDEO_TS.VOB:157696:/VIDEO_TS/VTS_01_0.BUP:34816:/VIDEO_TS/VTS_01_0.IFO:34816:/VIDEO_TS/VTS_01_0.VOB:255559680:/VIDEO_TS/VTS_01_1.VOB:997376:/VIDEO_TS/VTS_02_0.BUP:65536:/VIDEO_TS/VTS_02_0.IFO:65536:/VIDEO_TS/VTS_02_0.VOB:157696:/VIDEO_TS/VTS_02_1.VOB:1073565696:/VIDEO_TS/VTS_02_2.VOB:1073565696:/VIDEO_TS/VTS_02_3.VOB:1073565696:/VIDEO_TS/VTS_02_4.VOB:1073565696:/VIDEO_TS/VTS_02_5.VOB:1073565696:/VIDEO_TS/VTS_02_6.VOB:1073565696:/VIDEO_TS/VTS_02_7.VOB:376975360:/VIDEO_TS/VTS_03_0.BUP:18432:/VIDEO_TS/VTS_03_0.IFO:18432:/VIDEO_TS/VTS_03_0.VOB:157696:/VIDEO_TS/VTS_03_1.VOB:6483968:/VIDEO_TS/VTS_04_0.BUP:18432:/VIDEO_TS/VTS_04_0.IFO:18432:/VIDEO_TS/VTS_04_0.VOB:157696:/VIDEO_TS/VTS_04_1.VOB:5986304:/VIDEO_TS/VTS_05_0.BUP:18432:/VIDEO_TS/VTS_05_0.IFO:18432:/VIDEO_TS/VTS_05_0.VOB:157696:/VIDEO_TS/VTS_05_1.VOB:15337472:/VIDEO_TS/VTS_06_0.BUP:18432:/VIDEO_TS/VTS_06_0.IFO:18432:/VIDEO_TS/VTS_06_0.VOB:157696:/VIDEO_TS/VTS_06_1.VOB:67874816:/VIDEO_TS/VTS_07_0.BUP:18432:/VIDEO_TS/VTS_07_0.IFO:18432:/VIDEO_TS/VTS_07_0.VOB:157696:/VIDEO_TS/VTS_07_1.VOB:123170816:/VIDEO_TS/VTS_08_0.BUP:18432:/VIDEO_TS/VTS_08_0.IFO:18432:/VIDEO_TS/VTS_08_0.VOB:157696:/VIDEO_TS/VTS_08_1.VOB:9367552" },
int main(int argc, char **argv) { char **base_paths = NULL; char **paths = NULL; int i; int pcre_opts = PCRE_MULTILINE; int study_opts = 0; worker_t *workers = NULL; int workers_len; int num_cores; #ifdef HAVE_PLEDGE if (pledge("stdio rpath proc exec", NULL) == -1) { die("pledge: %s", strerror(errno)); } #endif set_log_level(LOG_LEVEL_WARN); work_queue = NULL; work_queue_tail = NULL; root_ignores = init_ignore(NULL, "", 0); out_fd = stdout; parse_options(argc, argv, &base_paths, &paths); log_debug("PCRE Version: %s", pcre_version()); if (opts.stats) { memset(&stats, 0, sizeof(stats)); gettimeofday(&(stats.time_start), NULL); } #ifdef USE_PCRE_JIT int has_jit = 0; pcre_config(PCRE_CONFIG_JIT, &has_jit); if (has_jit) { study_opts |= PCRE_STUDY_JIT_COMPILE; } #endif #ifdef _WIN32 { SYSTEM_INFO si; GetSystemInfo(&si); num_cores = si.dwNumberOfProcessors; } #else num_cores = (int)sysconf(_SC_NPROCESSORS_ONLN); #endif workers_len = num_cores < 8 ? num_cores : 8; if (opts.literal) { workers_len--; } if (opts.workers) { workers_len = opts.workers; } if (workers_len < 1) { workers_len = 1; } log_debug("Using %i workers", workers_len); done_adding_files = FALSE; workers = ag_calloc(workers_len, sizeof(worker_t)); if (pthread_cond_init(&files_ready, NULL)) { die("pthread_cond_init failed!"); } if (pthread_mutex_init(&print_mtx, NULL)) { die("pthread_mutex_init failed!"); } if (opts.stats && pthread_mutex_init(&stats_mtx, NULL)) { die("pthread_mutex_init failed!"); } if (pthread_mutex_init(&work_queue_mtx, NULL)) { die("pthread_mutex_init failed!"); } if (opts.casing == CASE_SMART) { opts.casing = is_lowercase(opts.query) ? CASE_INSENSITIVE : CASE_SENSITIVE; } if (opts.literal) { if (opts.casing == CASE_INSENSITIVE) { /* Search routine needs the query to be lowercase */ char *c = opts.query; for (; *c != '\0'; ++c) { *c = (char)tolower(*c); } } generate_alpha_skip(opts.query, opts.query_len, alpha_skip_lookup, opts.casing == CASE_SENSITIVE); find_skip_lookup = NULL; generate_find_skip(opts.query, opts.query_len, &find_skip_lookup, opts.casing == CASE_SENSITIVE); generate_hash(opts.query, opts.query_len, h_table, opts.casing == CASE_SENSITIVE); if (opts.word_regexp) { init_wordchar_table(); opts.literal_starts_wordchar = is_wordchar(opts.query[0]); opts.literal_ends_wordchar = is_wordchar(opts.query[opts.query_len - 1]); } } else { if (opts.casing == CASE_INSENSITIVE) { pcre_opts |= PCRE_CASELESS; } if (opts.word_regexp) { char *word_regexp_query; ag_asprintf(&word_regexp_query, "\\b(?:%s)\\b", opts.query); free(opts.query); opts.query = word_regexp_query; opts.query_len = strlen(opts.query); } compile_study(&opts.re, &opts.re_extra, opts.query, pcre_opts, study_opts); } if (opts.search_stream) { search_stream(stdin, ""); } else { for (i = 0; i < workers_len; i++) { workers[i].id = i; int rv = pthread_create(&(workers[i].thread), NULL, &search_file_worker, &(workers[i].id)); if (rv != 0) { die("Error in pthread_create(): %s", strerror(rv)); } #if defined(HAVE_PTHREAD_SETAFFINITY_NP) && (defined(USE_CPU_SET) || defined(HAVE_SYS_CPUSET_H)) if (opts.use_thread_affinity) { #ifdef __linux__ cpu_set_t cpu_set; #elif __FreeBSD__ cpuset_t cpu_set; #endif CPU_ZERO(&cpu_set); CPU_SET(i % num_cores, &cpu_set); rv = pthread_setaffinity_np(workers[i].thread, sizeof(cpu_set), &cpu_set); if (rv) { log_err("Error in pthread_setaffinity_np(): %s", strerror(rv)); log_err("Performance may be affected. Use --noaffinity to suppress this message."); } else { log_debug("Thread %i set to CPU %i", i, i); } } else { log_debug("Thread affinity disabled."); } #else log_debug("No CPU affinity support."); #endif } #ifdef HAVE_PLEDGE if (pledge("stdio rpath", NULL) == -1) { die("pledge: %s", strerror(errno)); } #endif for (i = 0; paths[i] != NULL; i++) { log_debug("searching path %s for %s", paths[i], opts.query); symhash = NULL; ignores *ig = init_ignore(root_ignores, "", 0); struct stat s = { .st_dev = 0 }; #ifndef _WIN32 /* The device is ignored if opts.one_dev is false, so it's fine * to leave it at the default 0 */ if (opts.one_dev && lstat(paths[i], &s) == -1) { log_err("Failed to get device information for path %s. Skipping...", paths[i]); } #endif search_dir(ig, base_paths[i], paths[i], 0, s.st_dev); cleanup_ignore(ig); } pthread_mutex_lock(&work_queue_mtx); done_adding_files = TRUE; pthread_cond_broadcast(&files_ready); pthread_mutex_unlock(&work_queue_mtx); for (i = 0; i < workers_len; i++) { if (pthread_join(workers[i].thread, NULL)) { die("pthread_join failed!"); } } } if (opts.stats) { gettimeofday(&(stats.time_end), NULL); double time_diff = ((long)stats.time_end.tv_sec * 1000000 + stats.time_end.tv_usec) - ((long)stats.time_start.tv_sec * 1000000 + stats.time_start.tv_usec); time_diff /= 1000000; printf("%zu matches\n%zu files contained matches\n%zu files searched\n%zu bytes searched\n%f seconds\n", stats.total_matches, stats.total_file_matches, stats.total_files, stats.total_bytes, time_diff); pthread_mutex_destroy(&stats_mtx); } if (opts.pager) { pclose(out_fd); } cleanup_options(); pthread_cond_destroy(&files_ready); pthread_mutex_destroy(&work_queue_mtx); pthread_mutex_destroy(&print_mtx); cleanup_ignore(root_ignores); free(workers); for (i = 0; paths[i] != NULL; i++) { free(paths[i]); free(base_paths[i]); } free(base_paths); free(paths); if (find_skip_lookup) { free(find_skip_lookup); } return !opts.match_found; }
int main(int argc, char *argv[]) { if (argc < 3) { fprintf(stderr, "usage: verify foo.efi cert0 [... certN]\n"); exit(1); } OpenSSL_add_all_algorithms(); ERR_load_PKCS7_strings(); ERR_load_crypto_strings(); int binfd = open(argv[1], O_RDONLY); if (binfd < 0) err(1, "verify: %s", argv[1]); struct stat sb; fstat(binfd, &sb); void *bin = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, binfd, 0); size_t bin_size = sb.st_size; PE_COFF_LOADER_IMAGE_CONTEXT context; int rc = read_header(bin, sb.st_size, &context); if (rc < 0) { fprintf(stderr, "read_header(): %m\n"); exit(1); } UINT8 sha256hash[32]; rc = generate_hash(bin, sb.st_size, &context, sha256hash); if (rc < 0) { fprintf(stderr, "you can't handle a hash\n"); exit(1); } WIN_CERTIFICATE_EFI_PKCS *efi_pkcs = NULL; if (context.SecDir->Size != 0) { efi_pkcs = ImageAddress(bin, bin_size, context.SecDir->VirtualAddress); if (!efi_pkcs) { fprintf(stderr, "signature is at invalid " "offset\n"); exit(1); } } int found = 0; for (int i = 2; argv[i] != NULL; i++) { int fd = open(argv[i], O_RDONLY); if (fd < 0) err(1, "verify: %s", argv[i]); printf("adding cert from \"%s\"\n", argv[i]); uint8_t *cert; struct stat sb; fstat(fd, &sb); cert = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0); size_t cert_size = sb.st_size; rc = AuthenticodeVerify((UINT8 *)&efi_pkcs->CertData, efi_pkcs->Hdr.dwLength - sizeof(efi_pkcs->Hdr), cert, cert_size, sha256hash, 32); if (rc == 1) { found = 1; break; } char errbuf[120]; unsigned long err = ERR_get_error(); ERR_error_string(err, errbuf); printf("%s\n", errbuf); munmap(cert, sb.st_size); close(fd); } if (!found) { fprintf(stderr, "verify failed!\n"); exit(1); } printf("Image verifies correctly\n"); return 0; }