/*
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;
}
