void RequestProcessor::process_callback(int rcode, PacketWrapper *wrapper) { log_debug("callback invoked from cluster %s, reference count: %d", wrapper->get_group()->get_cluster_name().c_str(), wrapper->get_request_reference_count()); TairGroup *group = wrapper->get_group(); //change request's status, if dataserver returns the failed `rcode. //should change the request status. if (rcode == TAIR_RETURN_SUCCESS || rcode == TAIR_RETURN_DATA_NOT_EXIST || rcode == DATA_EXPIRED) { log_debug("request committed to cluster %s success, rcode; %d", group->get_cluster_name().c_str(), rcode); if (wrapper->get_request_status() != COMMITTED_FAILED) { wrapper->set_request_status(COMMITTED_SUCCESS); } group->successed(); } else { log_debug("request committed to cluster %s failed, rcode; %d", group->get_cluster_name().c_str(), rcode); wrapper->set_request_status(COMMITTED_FAILED); if (rcode == TAIR_RETURN_TIMEOUT) { group->failed(); } dump_key("callback_failed", wrapper->get_shared_info()); } //release wrapper log_debug("release wrapper by cluster %s", group->get_cluster_name().c_str()); delete wrapper; }
isc_result_t dns_tsigkeyring_dumpanddetach(dns_tsig_keyring_t **ringp, FILE *fp) { isc_result_t result; dns_rbtnodechain_t chain; dns_name_t foundname; dns_fixedname_t fixedorigin; dns_name_t *origin; isc_stdtime_t now; dns_rbtnode_t *node; dns_tsigkey_t *tkey; dns_tsig_keyring_t *ring; unsigned int references; REQUIRE(ringp != NULL && *ringp != NULL); ring = *ringp; *ringp = NULL; RWLOCK(&ring->lock, isc_rwlocktype_write); INSIST(ring->references > 0); ring->references--; references = ring->references; RWUNLOCK(&ring->lock, isc_rwlocktype_write); if (references != 0) return (DNS_R_CONTINUE); isc_stdtime_get(&now); dns_name_init(&foundname, NULL); dns_fixedname_init(&fixedorigin); origin = dns_fixedname_name(&fixedorigin); dns_rbtnodechain_init(&chain, ring->mctx); result = dns_rbtnodechain_first(&chain, ring->keys, &foundname, origin); if (result != ISC_R_SUCCESS && result != DNS_R_NEWORIGIN) { dns_rbtnodechain_invalidate(&chain); goto destroy; } for (;;) { node = NULL; dns_rbtnodechain_current(&chain, &foundname, origin, &node); tkey = node->data; if (tkey != NULL && tkey->generated && tkey->expire >= now) dump_key(tkey, fp); result = dns_rbtnodechain_next(&chain, &foundname, origin); if (result != ISC_R_SUCCESS && result != DNS_R_NEWORIGIN) { dns_rbtnodechain_invalidate(&chain); if (result == ISC_R_NOMORE) result = ISC_R_SUCCESS; goto destroy; } } destroy: destroyring(ring); return (result); }
void RequestProcessor::dump_key(const tair_dataentry_set &keyset, const char *msg) { if (msg == NULL) { msg = "error"; } tair_dataentry_set::const_iterator it = keyset.begin(); while (it != keyset.end()) { dump_key(**it, msg); ++it; } }
void RequestProcessor::do_process(PROCESS_RHS_FUNC_T pproc, MultiWrapper *wrapper) { tair_client_impl *tair_client = wrapper->get_tair_client(); if (tair_client != NULL) { TairGroup *group = wrapper->get_group(); if ((tair_client->*pproc)(wrapper->get_packet()->area, *(wrapper->get_keys()),&failed_key_code_map, client_callback_with_multi_keys, (void*)wrapper) != TAIR_RETURN_SUCCESS) { dump_key("failed_send_request", wrapper->get_shared_info()); log_debug("send request to cluster %s failed.", wrapper->get_group()->get_cluster_name().c_str()); vector<std::string> servers; tair_client_impl *client = wrapper->get_tair_client(); tair_dataentry_set *keys = wrapper->get_keys(); if (keys == NULL || keys->empty()) { //bug: request without any key. log_error("request without any key, cluster name: %s, group name: %s, pcode: %d", wrapper->get_group()->get_cluster_name().c_str(), wrapper->get_group()->get_group_name().c_str(), wrapper->get_packet()->getPCode()); } else { client->get_server_with_key(**(keys->begin()), servers); if (!servers.empty()) { log_error("failed to send request to data server: %s, group name: %s", servers[0].c_str(), wrapper->get_packet()->get_group_name()); } wrapper->set_request_status(COMMITTED_FAILED); } //just release the wrapper delete wrapper; } else { if (group != NULL) { log_debug("send request to cluster %s success.", group->get_cluster_name().c_str()); } } } else { //bug: should not be here. log_error("wrapper without tair_client, cluster name: %s, group name: %s", wrapper->get_group()->get_cluster_name().c_str(), wrapper->get_group()->get_group_name().c_str()); delete wrapper; } }
void prof_pmk(char *essid) { TIME_STRUCT p1,p2; char key[16][128]; unsigned char pmk_sol[16][40]; unsigned char pmk_fast[16][40]; int i,j; for(i=0;i<16;i++) { strcpy(key[i],"atest"); key[i][0]+=i; } p1 = t_start(); for(i=0;i<16;i++) calc_pmk(key[i],essid,pmk_sol[i]); //key값과 essid로부터 pmk 값을 계산함 t_end(&p1); p2 = t_start(); calc_16pmk(key,essid,pmk_fast); t_end(&p2); //diff for(i=0;i<16;i++) { if(memcmp(pmk_sol[i],pmk_fast[i],sizeof(pmk_sol[i])) != 0) { printf("* %d wrong case (key:%s)\n",i,key[i]); dump_key("pmk_sol",pmk_sol[i],sizeof(pmk_sol[i])); dump_key("pmk_fst",pmk_fast[i],sizeof(pmk_fast[i])); } } printf("original : %0.2lf ms\n",t_get(p1)/1000); printf("simd ver : %0.2lf ms\n",t_get(p2)/1000); printf("performance : x%0.2lf\n",t_get(p1)/t_get(p2)); }
void digsig_init_pkey_internal(void) { int buf_size; printk(KERN_DEBUG "digsig.keys_valid 0x%08x\n\n", digsig_keys.valid); dump_key("n_key", digsig_keys.n_key, 130); dump_key("e_key", digsig_keys.e_key, 5); if (digsig_keys.valid != 1) { printk(KERN_NOTICE "DIGSIG: no valid key, digsig security disabled\n"); return; } DSM_PRINT(DEBUG_SIGN, "Reading raw_public_key_n!\n"); /* * key size in bits encoded in first two bytes, big endian. * round key size up and convert to bytes. * add two bytes for the size field */ buf_size = digsig_keys.n_key[0] << 8 | digsig_keys.n_key[1]; buf_size = (buf_size + 7)/8; buf_size += 2; printk(KERN_INFO "%s: n_key size %d\n", __FUNCTION__, buf_size); digsig_public_key[0] = mpi_read_from_buffer(digsig_keys.n_key, &buf_size, 0); DSM_PRINT(DEBUG_SIGN, "Reading raw_public_key_e!\n"); buf_size = digsig_keys.e_key[0] << 8 | digsig_keys.e_key[1]; buf_size = (buf_size + 7)/8; buf_size += 2; printk(KERN_INFO "%s: e_key size %d\n", __FUNCTION__, buf_size); digsig_public_key[1] = mpi_read_from_buffer(digsig_keys.e_key, &buf_size, 0); g_init = 1; printk(KERN_NOTICE "DIGSIG: digsig security enabled\n"); }
void queue_pkt_open_commit_sig(struct peer *peer) { OpenCommitSig *s = tal(peer, OpenCommitSig); open_commit_sig__init(s); dump_tx("Creating sig for:", peer->them.commit->tx); dump_key("Using key:", &peer->us.commitkey); peer->them.commit->sig = tal(peer->them.commit, struct bitcoin_signature); peer->them.commit->sig->stype = SIGHASH_ALL; peer_sign_theircommit(peer, peer->them.commit->tx, &peer->them.commit->sig->sig); s->sig = signature_to_proto(s, &peer->them.commit->sig->sig); queue_pkt(peer, PKT__PKT_OPEN_COMMIT_SIG, s); }
void RequestProcessor::end_request(PacketWrapper *wrapper) { if (dump_key_switch) { dump_key("end_request", wrapper->get_shared_info()); } //if the request' status is COMMITTED_SUCCESS, to do nothing here. if (wrapper->get_request_status() == COMMITTED_FAILED) { //retry request. SharedInfo *old_shared = wrapper->get_shared_info(); request_inval_packet *req = old_shared->packet; std::string ds = obtain_ds_addr(wrapper); old_shared->packet = NULL; int retry_times = old_shared->get_retry_times(); if (retry_times < InvalRetryThread::RETRY_COUNT) { log_error("REQUEST FAILED, RETRY, retry_times: %d, cluster name: %s, group name: %s, pcode: %d, ds: %s", retry_times, wrapper->get_group()->get_cluster_name().c_str(), wrapper->get_group()->get_group_name().c_str(), req->getPCode(), ds.c_str()); SharedInfo *new_shared = new SharedInfo(0, 0, req); new_shared->set_retry_times(retry_times); //request packet was released by `shared, while the request's status is equ. to COMMITTED_SUCCESS. retry_thread->add_packet(new_shared, retry_times); //`old_shared should not be released here, and it will be released by is wrapper. } //cache the request packet. else { log_error("REQUEST FAILED, HOLD, cluster name: %s, group name: %s, pcode: %d, ds: %s", wrapper->get_group()->get_cluster_name().c_str(), wrapper->get_group()->get_group_name().c_str(), req->getPCode(), ds.c_str()); //change the `shared status, the request packet hold by `shared will not be released by disconstructor of `shared. old_shared->set_request_status(CACHED_IN_STORAGE); //statistic TAIR_INVAL_STAT.statistcs(pcode_opname_map[req->getPCode()], std::string(req->group_name), req->area, inval_area_stat::FINALLY_EXEC); //cache request packet request_storage->write_request(req); } } }
void RequestProcessor::do_process(PROCESS_RH_FUNC_T pproc, SingleWrapper *wrapper) { tair_client_impl *tair_client = wrapper->get_tair_client(); if (tair_client != NULL) { TairGroup *group = wrapper->get_group(); if ((tair_client->*pproc)(wrapper->get_packet()->area, *(wrapper->get_key()), client_callback_with_single_key, (void*)wrapper) != TAIR_RETURN_SUCCESS) { log_error("send request to cluster %s failed.", group->get_cluster_name().c_str()); vector<std::string> servers; tair_client->get_server_with_key(*(wrapper->get_key()), servers); if (!servers.empty()) { log_error("failed to send request to data server: %s, group name: %s", servers[0].c_str(), group->get_group_name().c_str()); } wrapper->set_request_status(COMMITTED_FAILED); dump_key("failed_send_request", wrapper->get_shared_info()); delete wrapper; } else { if (group != NULL) { log_debug("send request to cluster %s success.", group->get_cluster_name().c_str()); } } } else { //bug: should not be here. log_error("wrapper without tair_client, cluster name: %s, group name: %s", wrapper->get_group()->get_cluster_name().c_str(), wrapper->get_group()->get_group_name().c_str()); delete wrapper; } }
int main(int argc, char **argv) { unsigned char sha1_digest[40]={0}; unsigned char ssid[8]={0},buf[8]={0},year,week,x1,x2,x3; unsigned int keys = 0,ssidLen = 0,verbose = 0, opt = 0; unsigned char *strId = NULL; FILE *ofile = NULL; unsigned int year_target = 0; unsigned int year_max = 0; SHA_CTX sha1_ctx; if(argc > 1) { while( (opt = getopt(argc, argv,"vuy:o:i:")) != -1) { switch(opt) { case 'i' : strId = (unsigned char *)optarg; break; case 'o' : if((ofile = fopen(optarg,"wb")) == NULL) { fprintf(stderr,"\nCannot open %s for output.\n",optarg); return(0); } break; case 'v' : verbose++; break; case 'u' : // Hex 0x30 is the specific ascii byte ('0') for the UPC variant serial[0] = 0x30; serial[1] = 0x30; break; case 'y' : sscanf(optarg, "%u", &year_target); if(year_target >= 5 && year_target <= 10) { break; } else { fprintf(stderr, "Invalid year selected: %u\n", year_target); usage(argv); } default: usage(argv); } } if(!strId) usage(argv); if(!(ssidLen = str2ssid(ssid,strId))) usage(argv); if(verbose) fprintf(stdout,"Generating keys..please wait\n"); if (year_target) { year = year_target; year_max = year_target; } else { year = 5; year_max = 10; } // generate values only for 2005 - 2010 for(;year <= year_max;year++) { if(verbose) fprintf(stdout,"Calculating keys for 20%02d...\n",year); serial[2] = (year / 10) + 48; serial[3] = (year % 10) + 48; // 52 weeks of the year for(week = 1;week <= 52;week++) { serial[4] = (week / 10) + 48; serial[5] = (week % 10) + 48; for(x1 = 0;x1 < 36;x1++) { serial[6] = hexmsb(charTable[x1]); serial[7] = hexlsb(charTable[x1]); for(x2 = 0;x2 < 36;x2++) { serial[8] = hexmsb(charTable[x2]); serial[9] = hexlsb(charTable[x2]); for(x3 = 0;x3 < 36;x3++) { serial[10] = hexmsb(charTable[x3]); serial[11] = hexlsb(charTable[x3]); // hash serial number with sha-1 SHA1_Init(&sha1_ctx); SHA1_Update(&sha1_ctx,serial,SERIAL_LENGTH); SHA1_Final(&sha1_ctx,sha1_digest); // compare SSID octets with last number of bytes supplied if(memcmp(&sha1_digest[(SHA1_LENGTH-ssidLen)],ssid,ssidLen) == 0) { keys++; if(verbose) { memcpy(buf,serial,6); fprintf(stdout, "Serial Number Year 20%02d: %s**%C%C%C - potential key = ",year, buf,charTable[x1],charTable[x2],charTable[x3]); dump_key(stdout,sha1_digest); } else { dump_key(stdout,sha1_digest); } if(ofile) { dump_key(ofile,sha1_digest); } } } } } } } if(verbose) fprintf(stdout,"Found %d potential keys.\n",keys); if(ofile) fclose(ofile); } else { usage(argv); } return(0); }
int compute_key(char *strId, int year, char *output, int len) { unsigned char sha1_digest[40]={0}; char ssid[8]={0},buf[8]={0},week,x1,x2,x3; int keys = 0,ssidLen = 0; int offset = 0; if(!(ssidLen = str2ssid(ssid,strId))) return -99; //fprintf(stdout,"\nGenerating keys..please wait\n\n"); serial[3] = year | '0'; // 52 weeks of the year for(week = 1;week <= 52;week++) { serial[4] = (week / 10) + '0'; serial[5] = (week % 10) + '0'; for(x1 = 0;x1 < 36;x1++) { serial[6] = hexmsb(charTable[x1]); serial[7] = hexlsb(charTable[x1]); for(x2 = 0;x2 < 36;x2++) { serial[8] = hexmsb(charTable[x2]); serial[9] = hexlsb(charTable[x2]); for(x3 = 0;x3 < 36;x3++) { serial[10] = hexmsb(charTable[x3]); serial[11] = hexlsb(charTable[x3]); // hash serial number with sha-1 CC_SHA1(serial, SERIAL_LENGTH, sha1_digest); // compare SSID octets with last number of bytes supplied if(memcmp(&sha1_digest[(20-ssidLen)],ssid,ssidLen) == 0) { // check if more keys will fit in the provided buffer if (keys >= len/(OUTPUT_KEY_SIZE)) goto __done; keys++; memcpy(buf,serial,6); sprintf(&output[offset], "[%s**%C%C%C]: ", buf, charTable[x1],charTable[x2],charTable[x3]); offset += OUTPUT_OVERHEAD; dump_key(&output[offset],sha1_digest); offset += DEFAULT_KEY_SIZE*2; strcat(&output[offset], "\n"); output[++offset] = 0; // ensure to null-terminate the string } } } } } __done: //fprintf(stdout,"\nFound %d potential keys.\n",keys); return keys; }
static void tlinit(void) { int rc, i; char *Term = getenv("TERM"); if (Term == NULL) { printf("FATAL ERROR: environment variable TERM not set.\n"); exit(1); } setupterm(Term, 1, &rc); if (rc != 1) { printf("FATAL ERROR: Unable to get terminfo entry for %s.\n", Term); exit(1); } if (!clear_screen || !clr_eol || !cursor_address) { printf("FATAL ERROR: Terminfo entry for %s incomplete.\n", Term); exit(1); } if (!exit_attribute_mode) enter_reverse_mode = enter_standout_mode = enter_bold_mode = NULL; /* initialize the terminal */ TPUTS(init_1string); TPUTS(init_2string); TPUTS(init_3string); set_tkey(0, key_up); set_tkey(1, key_down); set_tkey(2, key_right); set_tkey(3, key_left); set_tkey(4, key_ic); set_tkey(5, key_dc); set_tkey(6, key_ppage); set_tkey(7, key_npage); set_tkey(8, key_home); set_tkey(9, key_end); if (key_f0) { /* old school */ set_tkey(10, key_f0); set_tkey(11, key_f1); i = 12; } else { set_tkey(10, key_f1); set_tkey(21, key_f12); i = 11; } set_tkey(i++, key_f2); set_tkey(i++, key_f3); set_tkey(i++, key_f4); set_tkey(i++, key_f5); set_tkey(i++, key_f6); set_tkey(i++, key_f7); set_tkey(i++, key_f8); set_tkey(i++, key_f9); set_tkey(i++, key_f10); set_tkey(i++, key_f11); #ifdef SAM_NO Key_mask = 0x00c00000; /* C-Home and C-End not in terminfo */ for (k = 0; k < i; ++k) if (Tkeys[k] && *Tkeys[k]) Key_mask |= 1 << k; if (verbose) { for (k = 0; k < i; ++k) dump_key(k, Tkeys[k], NULL); Dbg("Key Mask %x\n", Key_mask); } #endif }