int user_action(char board1[BOARD_SIZE][BOARD_SIZE], char board2[BOARD_SIZE][BOARD_SIZE], char user) { switch (user) { case 'a': add_cell(board2) ; break ; case 'r': remove_cell(board2) ; break ; case 'n': apply_rules(board1, board2) ; break ; case 'q': return 0 ; case 'p': while (1) { apply_rules(board1, board2) ; copy_board(board1, board2) ; printf("\033[2J\033[H") ; usleep(500000) ; print_board(board1) ; } } return 1 ; }
static bool apply_relevant_rules(Postprocessor *pp, bool (applyfn)(PP_data *, Linkage, pp_rule *), Linkage sublinkage, pp_rule *rule_array, int *relevant_rules, const char **msg) { int i, idx; PP_data *pp_data = &pp->pp_data; /* If we didn't accumulate link names for this sentence, we need * to apply all rules. */ if (pp_linkset_population(pp->set_of_links_of_sentence) == 0) { return apply_rules(pp_data, applyfn, sublinkage, rule_array, msg); } /* We did, and we don't. */ for (i = 0; (idx = relevant_rules[i]) != -1; i++) { *msg = rule_array[idx].msg; if (!applyfn(pp_data, sublinkage, &(rule_array[idx]))) return false; } return true; }
void schedule_window(xcb_window_t win) { coordinates_t loc; uint8_t override_redirect = 0; xcb_get_window_attributes_reply_t *wa = xcb_get_window_attributes_reply(dpy, xcb_get_window_attributes(dpy, win), NULL); if (wa != NULL) { override_redirect = wa->override_redirect; free(wa); } if (override_redirect || locate_window(win, &loc)) { return; } /* ignore pending windows */ for (pending_rule_t *pr = pending_rule_head; pr != NULL; pr = pr->next) { if (pr->win == win) { return; } } rule_consequence_t *csq = make_rule_conquence(); apply_rules(win, csq); if (!schedule_rules(win, csq)) { manage_window(win, csq, -1); free(csq); } }
int main(int argc, char **argv) { int clear = 0; int c; if (!smack_smackfs_path()) { fprintf(stderr, "SmackFS is not mounted.\n"); exit(1); } while ((c = getopt(argc, argv, "c")) != -1) { switch (c) { case 'c': clear = 1; break; default: usage(argv[0]); } } if (optind == argc) { if (apply_rules_file(STDIN_FILENO, clear)) exit(1); } else { if (apply_rules(argv[optind], clear)) exit(1); } exit(0); }
int build_job (void) { struct ndm_job_param * job = &the_job; int i, rc, n_err; char errbuf[100]; NDMOS_MACRO_ZEROFILL(job); args_to_job (); ndma_job_auto_adjust (job); if (o_rules) apply_rules (job, o_rules); i = n_err = 0; do { rc = ndma_job_audit (job, errbuf, i); if (rc > n_err || rc < 0) { ndmjob_log (0, "error: %s", errbuf); } n_err = rc; } while (i++ < n_err); if (n_err) { error_byebye ("can't proceed"); /* no return */ } return 0; }
static void modify_access_rules(char *file, enum mask_action action) { char path[PATH_MAX]; int ret; sprintf(path,"%s/%s", ACCESSES_D_PATH, file); if (action == CREATE) ret = apply_rules(path, 0); else if (action == MODIFY) { ret = apply_rules(path, 1); ret = apply_rules(path, 0); } if (ret) syslog(LOG_ERR, "Failed load access rules (%s), action (%d) :%m", path, action); }
static int internal_process(Postprocessor *pp, Linkage sublinkage, const char **msg) { size_t i; PP_data *pp_data = &pp->pp_data; /* quick test: try applying just the relevant global rules */ if (!apply_relevant_rules(pp, apply_contains_one_globally, sublinkage, pp->knowledge->contains_one_rules, pp->relevant_contains_one_rules, msg)) { for (i = 0; i < pp_data->wowlen; i++) pp_data->word_links[i] = NULL; pp_data->N_domains = 0; return -1; } /* build graph; confirm that it's legally connected */ build_graph(pp, sublinkage); build_domains(pp, sublinkage); build_domain_forest(&pp->pp_data, sublinkage); #if defined(CHECK_DOMAIN_NESTING) /* These messages were deemed to not be useful, so * this code is commented out. See comment above. */ if (!check_domain_nesting(pp, sublinkage->num_links)) printf("WARNING: The domains are not nested.\n"); #endif /* The order below should be optimal for most cases */ if (!apply_relevant_rules(pp, apply_contains_one, sublinkage, pp->knowledge->contains_one_rules, pp->relevant_contains_one_rules, msg)) return 1; if (!apply_relevant_rules(pp, apply_contains_none, sublinkage, pp->knowledge->contains_none_rules, pp->relevant_contains_none_rules, msg)) return 1; if (!apply_rules(pp_data, apply_must_form_a_cycle, sublinkage, pp->knowledge->form_a_cycle_rules,msg)) return 1; if (!apply_rules(pp_data, apply_bounded, sublinkage, pp->knowledge->bounded_rules, msg)) return 1; return 0; /* This linkage satisfied all the rules */ }
static int interval_limit_access_checker(request_rec *r) { interval_limit_config *conf = ap_get_module_config(r->per_dir_config, &interval_limit_module); int i, block_access; char *threshold_exceeded_rules=NULL; threshold_exceeded_entry *threshold_exceeded, *ol; if (!conf || !conf->enabled) { return DECLINED; } if (!conf->rules || conf->rules->nelts < 1) { return DECLINED; } block_access =0; apr_array_header_t *threshold_exceededs =apr_array_make(r->pool, 2, sizeof(threshold_exceeded_entry)); if( apply_rules(r, conf->rules, threshold_exceededs) !=0 ) { ILLOG_ERROR(r, MODTAG "apply_rules failure!"); return DECLINED; } if (threshold_exceededs->nelts > 0) { ol = (threshold_exceeded_entry *)threshold_exceededs->elts; for ( i =0; i <threshold_exceededs->nelts; i++) { threshold_exceeded = &ol[i]; ILLOG_DEBUG(r, MODTAG "dump threshold_exceeded: name=%s block=%d", threshold_exceeded->name, threshold_exceeded->block); if (threshold_exceeded_rules == NULL) { threshold_exceeded_rules = (char*)apr_pstrdup(r->pool, threshold_exceeded->name); } else { threshold_exceeded_rules = (char*)apr_psprintf(r->pool, "%s,%s", threshold_exceeded_rules, threshold_exceeded->name); } if (threshold_exceeded->block){ block_access = 1; } } if (threshold_exceeded_rules) { apr_table_setn(r->subprocess_env, "threshold_exceeded_rules", threshold_exceeded_rules); apr_table_set(r->headers_in, "threshold_exceeded_rules", threshold_exceeded_rules); } } if (block_access) { return (HTTP_SERVICE_UNAVAILABLE); } return OK; }
static int apply_all(void) { if (!smack_smackfs_path()) { fprintf(stderr, "SmackFS is not mounted.\n"); return -1; } if (clear()) return -1; if (apply_rules(ACCESSES_D_PATH, 0)) return -1; if (apply_cipso(CIPSO_D_PATH)) return -1; return 0; }
static int apply_all(void) { if (is_smackfs_mounted() != 1) { fprintf(stderr, "ERROR: SmackFS is not mounted.\n"); return -1; } if (clear()) return -1; if (apply_rules(ACCESSES_D_PATH, 0)) perror("apply_rules"); if (apply_cipso(CIPSO_D_PATH)) perror("apply_cipso"); return 0; }
std::string apply_rules(const std::vector<rule_t> & rules, const string_view_t &numview) { std::string result = ""; for (std::string old_number; numview.str != old_number && numview.size(); ) { old_number = numview.str; for (const auto &rule : rules) { if (const string_view_t matched_view = rule.match(numview)) { matched_view.fill('?'); result = concat(rule.replacement, result); if (const auto n_hashes = rule.n_hashes()) { const size_t pos_begin = (matched_view.pos_begin > n_hashes)? matched_view.pos_begin - n_hashes : 0; result = concat(apply_rules(rules, string_view_t{numview.str, pos_begin, matched_view.pos_begin}), result); } break; } } } return result; }
static int apply_relevant_rules(Postprocessor *pp, int(applyfn)(Postprocessor *pp,Sublinkage*,pp_rule *rule), Sublinkage *sublinkage, pp_rule *rule_array, int *relevant_rules, char **msg) { int i, idx; /* if we didn't accumulate link names for this sentence, we need to apply all rules */ if (pp_linkset_population(pp->set_of_links_of_sentence)==0) { return apply_rules(pp, applyfn, sublinkage, rule_array, msg); } /* we did, and we don't */ for (i=0; (idx=relevant_rules[i])!=-1; i++) { *msg = rule_array[idx].msg; /* Adam had forgotten this -- DS 4/9/98 */ if (!applyfn(pp, sublinkage, &(rule_array[idx]))) return 0; } return 1; }
int build_plain (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u32 *plain_buf, int *out_len) { const combinator_ctx_t *combinator_ctx = hashcat_ctx->combinator_ctx; const hashconfig_t *hashconfig = hashcat_ctx->hashconfig; const hashes_t *hashes = hashcat_ctx->hashes; const mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx; const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx; const user_options_t *user_options = hashcat_ctx->user_options; const u32 gidvid = plain->gidvid; const u32 il_pos = plain->il_pos; int plain_len = 0; u8 *plain_ptr = (u8 *) plain_buf; if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) { pw_t pw; const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw); if (rc == -1) return -1; for (int i = 0; i < 16; i++) { plain_buf[i] = pw.i[i]; } plain_len = (int) pw.pw_len; const u32 off = device_param->innerloop_pos + il_pos; plain_len = (int) apply_rules (straight_ctx->kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], (u32) plain_len); if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max; } else if (user_options->attack_mode == ATTACK_MODE_COMBI) { pw_t pw; const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw); if (rc == -1) return -1; for (int i = 0; i < 16; i++) { plain_buf[i] = pw.i[i]; } plain_len = (int) pw.pw_len; char *comb_buf = (char *) device_param->combs_buf[il_pos].i; u32 comb_len = device_param->combs_buf[il_pos].pw_len; if (combinator_ctx->combs_mode == COMBINATOR_MODE_BASE_LEFT) { memcpy (plain_ptr + plain_len, comb_buf, (size_t) comb_len); } else { memmove (plain_ptr + comb_len, plain_ptr, (size_t) plain_len); memcpy (plain_ptr, comb_buf, comb_len); } plain_len += comb_len; if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max; } else if (user_options->attack_mode == ATTACK_MODE_BF) { u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid; u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos; u32 l_start = device_param->kernel_params_mp_l_buf32[5]; u32 r_start = device_param->kernel_params_mp_r_buf32[5]; u32 l_stop = device_param->kernel_params_mp_l_buf32[4]; u32 r_stop = device_param->kernel_params_mp_r_buf32[4]; sp_exec (l_off, (char *) plain_ptr + l_start, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, l_start, l_start + l_stop); sp_exec (r_off, (char *) plain_ptr + r_start, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, r_start, r_start + r_stop); plain_len = (int) mask_ctx->css_cnt; } else if (user_options->attack_mode == ATTACK_MODE_HYBRID1) { pw_t pw; const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw); if (rc == -1) return -1; for (int i = 0; i < 16; i++) { plain_buf[i] = pw.i[i]; } plain_len = (int) pw.pw_len; u64 off = device_param->kernel_params_mp_buf64[3] + il_pos; u32 start = 0; u32 stop = device_param->kernel_params_mp_buf32[4]; sp_exec (off, (char *) plain_ptr + plain_len, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, start, start + stop); plain_len += start + stop; if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max; } else if (user_options->attack_mode == ATTACK_MODE_HYBRID2) { pw_t pw; const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw); if (rc == -1) return -1; for (int i = 0; i < 16; i++) { plain_buf[i] = pw.i[i]; } plain_len = (int) pw.pw_len; u64 off = device_param->kernel_params_mp_buf64[3] + il_pos; u32 start = 0; u32 stop = device_param->kernel_params_mp_buf32[4]; memmove (plain_ptr + stop, plain_ptr, plain_len); sp_exec (off, (char *) plain_ptr, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, start, start + stop); plain_len += start + stop; if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max; } if (user_options->attack_mode == ATTACK_MODE_BF) { if (hashconfig->opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here { if (hashconfig->opti_type & OPTI_TYPE_SINGLE_HASH) { if (hashconfig->opti_type & OPTI_TYPE_APPENDED_SALT) { plain_len = plain_len - hashes->salts_buf[0].salt_len; } } if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE) { for (int i = 0, j = 0; i < plain_len; i += 2, j += 1) { plain_ptr[j] = plain_ptr[i]; } plain_len = plain_len / 2; } } } plain_ptr[plain_len] = 0; *out_len = plain_len; return 0; }
static void load_all_rules() { if (apply_rules(ACCESSES_D_PATH, 0)) syslog(LOG_DEBUG, "Failed to load all rules"); }
int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u64 pws_cnt) { combinator_ctx_t *combinator_ctx = hashcat_ctx->combinator_ctx; hashconfig_t *hashconfig = hashcat_ctx->hashconfig; mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx; outfile_ctx_t *outfile_ctx = hashcat_ctx->outfile_ctx; straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx; user_options_t *user_options = hashcat_ctx->user_options; out_t out; out.fp = stdout; char *filename = outfile_ctx->filename; if (filename) { FILE *fp = fopen (filename, "ab"); if (fp == NULL) { event_log_error (hashcat_ctx, "%s: %s", filename, strerror (errno)); return -1; } if (lock_file (fp) == -1) { fclose (fp); event_log_error (hashcat_ctx, "%s: %s", filename, strerror (errno)); return -1; } out.fp = fp; } out.len = 0; u32 plain_buf[64] = { 0 }; u8 *plain_ptr = (u8 *) plain_buf; u32 plain_len = 0; const u32 il_cnt = device_param->kernel_params_buf32[30]; // ugly, i know if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) { pw_t pw; for (u64 gidvid = 0; gidvid < pws_cnt; gidvid++) { const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw); if (rc == -1) { if (filename) fclose (out.fp); return -1; } for (u32 il_pos = 0; il_pos < il_cnt; il_pos++) { const u32 off = device_param->innerloop_pos + il_pos; if (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL) { for (int i = 0; i < 8; i++) { plain_buf[i] = pw.i[i]; } plain_len = apply_rules_optimized (straight_ctx->kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], pw.pw_len); } else { for (int i = 0; i < 64; i++) { plain_buf[i] = pw.i[i]; } plain_len = apply_rules (straight_ctx->kernel_rules_buf[off].cmds, plain_buf, pw.pw_len); } if (plain_len > hashconfig->pw_max) plain_len = hashconfig->pw_max; out_push (&out, plain_ptr, plain_len); } } } else if (user_options->attack_mode == ATTACK_MODE_COMBI) { pw_t pw; for (u64 gidvid = 0; gidvid < pws_cnt; gidvid++) { const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw); if (rc == -1) { if (filename) fclose (out.fp); return -1; } for (u32 il_pos = 0; il_pos < il_cnt; il_pos++) { for (int i = 0; i < 64; i++) { plain_buf[i] = pw.i[i]; } plain_len = pw.pw_len; char *comb_buf = (char *) device_param->combs_buf[il_pos].i; u32 comb_len = device_param->combs_buf[il_pos].pw_len; if (combinator_ctx->combs_mode == COMBINATOR_MODE_BASE_LEFT) { memcpy (plain_ptr + plain_len, comb_buf, comb_len); } else { memmove (plain_ptr + comb_len, plain_ptr, plain_len); memcpy (plain_ptr, comb_buf, comb_len); } plain_len += comb_len; if (plain_len > hashconfig->pw_max) plain_len = hashconfig->pw_max; out_push (&out, plain_ptr, plain_len); } } } else if (user_options->attack_mode == ATTACK_MODE_BF) { for (u64 gidvid = 0; gidvid < pws_cnt; gidvid++) { for (u32 il_pos = 0; il_pos < il_cnt; il_pos++) { u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid; u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos; u32 l_start = device_param->kernel_params_mp_l_buf32[5]; u32 r_start = device_param->kernel_params_mp_r_buf32[5]; u32 l_stop = device_param->kernel_params_mp_l_buf32[4]; u32 r_stop = device_param->kernel_params_mp_r_buf32[4]; sp_exec (l_off, (char *) plain_ptr + l_start, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, l_start, l_start + l_stop); sp_exec (r_off, (char *) plain_ptr + r_start, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, r_start, r_start + r_stop); plain_len = mask_ctx->css_cnt; out_push (&out, plain_ptr, plain_len); } } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID1) { pw_t pw; for (u64 gidvid = 0; gidvid < pws_cnt; gidvid++) { const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw); if (rc == -1) { if (filename) fclose (out.fp); return -1; } for (u32 il_pos = 0; il_pos < il_cnt; il_pos++) { for (int i = 0; i < 64; i++) { plain_buf[i] = pw.i[i]; } plain_len = pw.pw_len; u64 off = device_param->kernel_params_mp_buf64[3] + il_pos; u32 start = 0; u32 stop = device_param->kernel_params_mp_buf32[4]; sp_exec (off, (char *) plain_ptr + plain_len, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, start, start + stop); plain_len += start + stop; out_push (&out, plain_ptr, plain_len); } } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID2) { pw_t pw; for (u64 gidvid = 0; gidvid < pws_cnt; gidvid++) { const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw); if (rc == -1) { if (filename) fclose (out.fp); return -1; } for (u32 il_pos = 0; il_pos < il_cnt; il_pos++) { u64 off = device_param->kernel_params_mp_buf64[3] + gidvid; u32 start = 0; u32 stop = device_param->kernel_params_mp_buf32[4]; sp_exec (off, (char *) plain_ptr, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, start, start + stop); plain_len = stop; char *comb_buf = (char *) device_param->combs_buf[il_pos].i; u32 comb_len = device_param->combs_buf[il_pos].pw_len; memcpy (plain_ptr + plain_len, comb_buf, comb_len); plain_len += comb_len; if (plain_len > hashconfig->pw_max) plain_len = hashconfig->pw_max; out_push (&out, plain_ptr, plain_len); } } } out_flush (&out); if (filename) fclose (out.fp); return 0; }
void tell(const std::vector<rule_t> & rules, std::string number) { std::cout << number << " --> "; std::string result = apply_rules(rules, string_view_t{number}); number.erase( std::remove(number.begin(), number.end(), '?'), number.end()); std::cout << number << (number.empty()?"":" ") << result << std::endl; }