int sync_cb(struct ccns_handle *h, struct ccn_charbuf *lhash, struct ccn_charbuf *rhash, struct ccn_charbuf *name) { char *hexL; char *hexR; struct ccn_charbuf *uri = ccn_charbuf_create(); ccn_uri_append(uri, name->buf, name->length, 1); if (lhash == NULL || lhash->length == 0) { hexL = strdup("none"); } else hexL = hex_string(lhash->buf, lhash->length); if (rhash == NULL || rhash->length == 0) { hexR = strdup("none"); } else hexR = hex_string(rhash->buf, rhash->length); printf("%s %s %s\n", ccn_charbuf_as_string(uri), hexL, hexR); fflush(stdout); free(hexL); free(hexR); ccn_charbuf_destroy(&uri); return(0); }
//------------------------------------------------------------------------------ // Name: dump_lines(edb::address_t address, int lines) // Desc: //------------------------------------------------------------------------------ void DumpState::dump_lines(edb::address_t address, int lines) { for(int i = 0; i < lines; ++i) { quint8 buf[16]; if(edb::v1::debugger_core->read_bytes(address, buf, sizeof(buf))) { std::cout << hex_string(address) << " : "; for(int j = 0x00; j < 0x04; ++j) std::cout << hex_string(buf[j]) << " "; std::cout << " "; for(int j = 0x04; j < 0x08; ++j) std::cout << hex_string(buf[j]) << " "; std::cout << "- "; for(int j = 0x08; j < 0x0c; ++j) std::cout << hex_string(buf[j]) << " "; std::cout << " "; for(int j = 0x0c; j < 0x10; ++j) std::cout << hex_string(buf[j]) << " "; for(int j = 0; j < 16; ++j) { const quint8 ch = buf[j]; std::cout << ( ( std::isprint(ch) || (std::isspace(ch) && (ch != '\f' && ch != '\t' && ch != '\r' && ch != '\n') && ch < 0x80) ) ? static_cast<char>(ch) : '.'); } std::cout << "\n"; } else { break; } address += 16; } }
static int gdbscm_memory_port_print (SCM exp, SCM port, scm_print_state *pstate) { ioscm_memory_port *iomem = (ioscm_memory_port *) SCM_STREAM (exp); char *type = SCM_PTOBNAME (SCM_PTOBNUM (exp)); scm_puts ("#<", port); scm_print_port_mode (exp, port); /* scm_print_port_mode includes a trailing space. */ gdbscm_printf (port, "%s %s-%s", type, hex_string (iomem->start), hex_string (iomem->end)); scm_putc ('>', port); return 1; }
int HostProxy_GadgetFS::reconnect() { int status; if (p_is_connected) {fprintf(stderr,"GadgetFS already connected.\n"); return 0;} if (!descriptor) {return 1;} if (debugLevel>0) { char* hex=hex_string((void*)descriptor,descriptorLength); fprintf(stderr,"%s\n",hex); free(hex); } device_filename = find_gadget_filename(); p_device_file = open_gadget(device_filename); if (p_device_file < 0) { fprintf(stderr,"Fail on open %d %s\n",errno,strerror(errno)); return 1; } status = write(p_device_file, descriptor, descriptorLength); if (status < 0) { fprintf(stderr,"Fail on write %d %s\n",errno,strerror(errno)); close(p_device_file); p_device_file=0; return 1; } p_is_connected = true; return 0; }
//------------------------------------------------------------------------------ // Name: dump_code(const State &state) // Desc: //------------------------------------------------------------------------------ void DumpState::dump_code(const State &state) { QSettings settings; const int instructions_to_print = settings.value("DumpState/instructions_after_ip", 6).toInt(); const edb::address_t ip = state.instruction_pointer(); edb::address_t address = ip; for(int i = 0; i < instructions_to_print + 1; ++i) { quint8 buf[edb::Instruction::MAX_SIZE]; int size = sizeof(buf); if(edb::v1::get_instruction_bytes(address, buf, size)) { edb::Instruction insn(buf, size, address, std::nothrow); if(insn.valid()) { std::cout << ((address == ip) ? "> " : " ") << hex_string(address) << ": " << edisassm::to_string(insn) << "\n"; } else { break; } address += insn.size(); } else { break; } } }
static const char * get_function_name (CORE_ADDR funaddr, char *buf, int buf_size) { { struct symbol *symbol = find_pc_function (funaddr); if (symbol) return SYMBOL_PRINT_NAME (symbol); } { /* Try the minimal symbols. */ struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (funaddr); if (msymbol.minsym) return MSYMBOL_PRINT_NAME (msymbol.minsym); } { char *tmp = xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT), hex_string (funaddr)); gdb_assert (strlen (tmp) + 1 <= buf_size); strcpy (buf, tmp); xfree (tmp); return buf; } }
std::basic_ostream<charT, traits> & operator << ( std::basic_ostream<charT, traits> & s, const mapnik::color & c ) { std::string hex_string( c.to_string() ); s << hex_string; return s; }
void mi_cmd_var_create (char *command, char **argv, int argc) { struct ui_out *uiout = current_uiout; CORE_ADDR frameaddr = 0; struct varobj *var; char *name; char *frame; char *expr; struct cleanup *old_cleanups; enum varobj_type var_type; if (argc != 3) error (_("-var-create: Usage: NAME FRAME EXPRESSION.")); name = xstrdup (argv[0]); /* Add cleanup for name. Must be free_current_contents as name can be reallocated. */ old_cleanups = make_cleanup (free_current_contents, &name); frame = xstrdup (argv[1]); make_cleanup (xfree, frame); expr = xstrdup (argv[2]); make_cleanup (xfree, expr); if (strcmp (name, "-") == 0) { xfree (name); name = varobj_gen_name (); } else if (!isalpha (*name)) error (_("-var-create: name of object must begin with a letter")); if (strcmp (frame, "*") == 0) var_type = USE_CURRENT_FRAME; else if (strcmp (frame, "@") == 0) var_type = USE_SELECTED_FRAME; else { var_type = USE_SPECIFIED_FRAME; frameaddr = string_to_core_addr (frame); } if (varobjdebug) fprintf_unfiltered (gdb_stdlog, "Name=\"%s\", Frame=\"%s\" (%s), Expression=\"%s\"\n", name, frame, hex_string (frameaddr), expr); var = varobj_create (name, expr, frameaddr, var_type); if (var == NULL) error (_("-var-create: unable to create variable object")); print_varobj (var, PRINT_ALL_VALUES, 0 /* don't print expression */); ui_out_field_int (uiout, "has_more", varobj_has_more (var, 0)); do_cleanups (old_cleanups); }
static void _uid64(Request& r, MethodParams& /*params*/) { unsigned char id[64/8]; random(&id, sizeof(id)); r.write_pass_lang(*new String(hex_string(id, sizeof(id), true))); }
//------------------------------------------------------------------------------ // Name: show_menu() // Desc: //------------------------------------------------------------------------------ void DumpState::show_menu() { State state; edb::v1::debugger_core->get_state(state); std::cout << "------------------------------------------------------------------------------\n"; dump_registers(state); std::cout << "[" << hex_string<quint16>(*state["ss"]) << ":" << hex_string(state.stack_pointer()) << "]---------------------------------------------------------[stack]\n"; dump_stack(state); const edb::address_t data_address = edb::v1::current_data_view_address(); std::cout << "[" << hex_string<quint16>(*state["ds"]) << ":" << hex_string(data_address) << "]---------------------------------------------------------[ data]\n"; dump_data(data_address); std::cout << "[" << hex_string<quint16>(*state["cs"]) << ":" << hex_string(state.instruction_pointer()) << "]---------------------------------------------------------[ code]\n"; dump_code(state); std::cout << "------------------------------------------------------------------------------\n"; }
void DeviceQualifier::print(__u8 tabs) { int i; char* hex=hex_string(&descriptor,sizeof(descriptor)); printf("%.*sHS Qualifier: %s\n",tabs,TABPADDING,hex); free(hex); for(i=0;i<descriptor.bNumConfigurations;i++) { if (configurations[i]) {configurations[i]->print(tabs+1,(configurations[i]==device->get_active_configuration())?true:false);} } }
//return -1 to stall int DeviceProxy_Loopback::control_request(const usb_ctrlrequest* setup_packet, int* nbytes, __u8* dataptr, int timeout) { if (debugLevel>1) { char* hex=hex_string((void*)setup_packet,sizeof(*setup_packet)); fprintf(stderr, "Loopback< %s\n",hex); free(hex); } if((setup_packet->bRequestType & USB_DIR_IN) && setup_packet->bRequest == USB_REQ_GET_DESCRIPTOR) { __u8* buf; __u8* p; __u8 idx; const usb_string_descriptor* string_desc; switch ((setup_packet->wValue)>>8) { case USB_DT_DEVICE: memcpy(dataptr, &loopback_device_descriptor, loopback_device_descriptor.bLength); *nbytes = loopback_device_descriptor.bLength; break; case USB_DT_CONFIG: idx=setup_packet->wValue & 0xff; if (idx>=loopback_device_descriptor.bNumConfigurations) return -1; buf=(__u8*)malloc(loopback_config_descriptor.wTotalLength); p=buf; memcpy(p, &loopback_config_descriptor, loopback_config_descriptor.bLength); p+=loopback_config_descriptor.bLength; memcpy(p, &loopback_interface_descriptor, loopback_interface_descriptor.bLength); p+=loopback_interface_descriptor.bLength; memcpy(p, &loopback_eps[0], loopback_eps[0].bLength); p+=loopback_eps[0].bLength; memcpy(p, &loopback_eps[1], loopback_eps[1].bLength); *nbytes = loopback_config_descriptor.wTotalLength>setup_packet->wLength?setup_packet->wLength:loopback_config_descriptor.wTotalLength; memcpy(dataptr, buf, *nbytes); free(buf); break; case USB_DT_STRING: idx=setup_packet->wValue & 0xff; if (idx>0 && setup_packet->wIndex!=0x409) return -1; if (idx>loopback_stringMaxIndex) return -1; string_desc=loopback_strings[idx]->get_descriptor(); *nbytes=string_desc->bLength>setup_packet->wLength?setup_packet->wLength:string_desc->bLength; memcpy(dataptr,string_desc,*nbytes); /* if (true) { char* hex=hex_string(dataptr, *nbytes); fprintf(stderr, "Loopback> %s\n",hex); free(hex); } exit(0); */ break; case USB_DT_DEVICE_QUALIFIER: return -1; break; case USB_DT_OTHER_SPEED_CONFIG: return -1; break; } } else if ((setup_packet->bRequestType & USB_DIR_IN) && setup_packet->bRequest == USB_REQ_GET_CONFIGURATION){
void stratum_client::handle_job_succeeded(const std::string& job_id, uint32_t nonce, const binary& hash) { std::cout << "job [" << job_id << "] succeeded, " << nonce << std::endl; { std::ostringstream oss; oss << "{\"method\": \"submit\", \"params\": " "{\"id\": \"" << rpc_id_ << "\", \"job_id\": \"" << job_id << "\", \"nonce\": \"" << std::string(hex_string(nonce)) << "\", \"result\": \"" << std::string(hex_string(hash)) << "\"}, \"id\":1}\n"; std::ostream request_stream(&request_); request_stream << oss.str(); } boost::asio::async_write(socket_, request_, boost::bind(&stratum_client::handle_write_completed, this, boost::asio::placeholders::error)); }
static void _md5(Request& r, MethodParams& params) { const char *string=params.as_string(0, PARAMETER_MUST_BE_STRING).cstr_to_string_body_untaint(String::L_AS_IS, r.connection(false), &r.charsets).cstr(); PA_MD5_CTX context; unsigned char digest[16]; pa_MD5Init(&context); pa_MD5Update(&context, (const unsigned char*)string, strlen(string)); pa_MD5Final(digest, &context); r.write_pass_lang(*new String(hex_string(digest, sizeof(digest), false))); }
/// Return the first specified number of hex digits of a given value. std::string hex_string(const std::string& preceding, const long double value, const long digits) { if (digits == 0L) { return preceding; } const long double magnitude(std::abs(value)); const long double front(16.0L * (magnitude - std::floor(magnitude))); const std::string accumulated(preceding + hex_digit(front)); return hex_string(accumulated, front, digits - 1L); }
static void _sha1(Request& r, MethodParams& params) { const char *string = params.as_string(0, PARAMETER_MUST_BE_STRING).cstr_to_string_body_untaint(String::L_AS_IS, r.connection(false), &r.charsets).cstr(); SHA1Context c; unsigned char digest[20]; SHA1Reset (&c); SHA1Input (&c, (const unsigned char*)string, strlen(string)); SHA1ReadDigest(digest, &c); r.write_pass_lang(*new String(hex_string(digest, sizeof(digest), false))); }
/* Appends OpenCL programs to the list of `struct so_list' objects. */ static void append_ocl_sos (struct so_list **link_ptr) { CORE_ADDR *ocl_program_addr_base; struct objfile *objfile; ALL_OBJFILES (objfile) { ocl_program_addr_base = (CORE_ADDR *) objfile_data (objfile, ocl_program_data_key); if (ocl_program_addr_base != NULL) { enum bfd_endian byte_order = bfd_big_endian (objfile->obfd)? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE; TRY { CORE_ADDR data = read_memory_unsigned_integer (*ocl_program_addr_base, sizeof (CORE_ADDR), byte_order); if (data != 0x0) { struct so_list *newobj; /* Allocate so_list structure. */ newobj = XCNEW (struct so_list); /* Encode FD and object ID in path name. */ xsnprintf (newobj->so_name, sizeof newobj->so_name, "@%s <%d>", hex_string (data), SPUADDR_SPU (*ocl_program_addr_base)); strcpy (newobj->so_original_name, newobj->so_name); *link_ptr = newobj; link_ptr = &newobj->next; } } CATCH (ex, RETURN_MASK_ALL) { /* Ignore memory errors. */ switch (ex.error) { case MEMORY_ERROR: break; default: throw_exception (ex); break; } } END_CATCH } } }
static int rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf) { #ifdef ARCH3264 int ret = ptracex (req, id, addr, data, buf); #else int ret = 0; #endif #if 0 printf ("rs6000_ptrace64 (%d, %d, %s, %08x, 0x%x) = 0x%x\n", req, id, hex_string (addr), data, (unsigned int)buf, ret); #endif return ret; }
static int lsscm_print_lazy_string_smob (SCM self, SCM port, scm_print_state *pstate) { lazy_string_smob *ls_smob = (lazy_string_smob *) SCM_SMOB_DATA (self); gdbscm_printf (port, "#<%s", lazy_string_smob_name); gdbscm_printf (port, " @%s", hex_string (ls_smob->address)); if (ls_smob->length >= 0) gdbscm_printf (port, " length %d", ls_smob->length); if (ls_smob->encoding != NULL) gdbscm_printf (port, " encoding %s", ls_smob->encoding); scm_puts (">", port); scm_remember_upto_here_1 (self); /* Non-zero means success. */ return 1; }
static CORE_ADDR find_toc_address (CORE_ADDR pc) { struct vmap *vp; extern CORE_ADDR get_toc_offset (struct objfile *); /* xcoffread.c */ for (vp = vmap; vp; vp = vp->nxt) { if (pc >= vp->tstart && pc < vp->tend) { /* vp->objfile is only NULL for the exec file. */ return vp->dstart + get_toc_offset (vp->objfile == NULL ? symfile_objfile : vp->objfile); } } error ("Unable to find TOC entry for pc %s\n", hex_string (pc)); }
static void mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr, ssize_t len, const bfd_byte *myaddr) { struct mi_interp *mi = top_level_interpreter_data (); struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ()); struct obj_section *sec; if (mi_suppress_notification.memory) return; target_terminal_ours (); fprintf_unfiltered (mi->event_channel, "memory-changed"); ui_out_redirect (mi_uiout, mi->event_channel); ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num); ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr); ui_out_field_fmt (mi_uiout, "len", "%s", hex_string (len)); /* Append 'type=code' into notification if MEMADDR falls in the range of sections contain code. */ sec = find_pc_section (memaddr); if (sec != NULL && sec->objfile != NULL) { flagword flags = bfd_get_section_flags (sec->objfile->obfd, sec->the_bfd_section); if (flags & SEC_CODE) ui_out_field_string (mi_uiout, "type", "code"); } ui_out_redirect (mi_uiout, NULL); gdb_flush (mi->event_channel); }
static void __init test_pointer(void) { plain(); null_pointer(); invalid_pointer(); symbol_ptr(); kernel_ptr(); struct_resource(); addr(); escaped_str(); hex_string(); mac(); ip(); uuid(); dentry(); struct_va_format(); struct_rtc_time(); struct_clk(); bitmap(); netdev_features(); flags(); }
//------------------------------------------------------------------------------ // Name: dump_registers(const State &state) // Desc: //------------------------------------------------------------------------------ void DumpState::dump_registers(const State &state) { #if defined(EDB_X86) std::cout << " eax:" << hex_string(*state["eax"]); std::cout << " ebx:" << hex_string(*state["ebx"]); std::cout << " ecx:" << hex_string(*state["ecx"]); std::cout << " edx:" << hex_string(*state["edx"]); std::cout << " eflags:" << hex_string(*state["eflags"]); std::cout << "\n"; std::cout << " esi:" << hex_string(*state["esi"]); std::cout << " edi:" << hex_string(*state["edi"]); std::cout << " esp:" << hex_string(*state["esp"]); std::cout << " ebp:" << hex_string(*state["ebp"]); std::cout << " eip:" << hex_string(state.instruction_pointer()); std::cout << "\n"; std::cout << " cs:" << hex_string<quint16>(*state["cs"]); std::cout << " ds:" << hex_string<quint16>(*state["ds"]); std::cout << " es:" << hex_string<quint16>(*state["es"]); std::cout << " fs:" << hex_string<quint16>(*state["fs"]); std::cout << " gs:" << hex_string<quint16>(*state["gs"]); std::cout << " ss:" << hex_string<quint16>(*state["ss"]); std::cout << " "; std::cout << ((*state["eflags"] & (1 << 11)) != 0 ? 'O' : 'o') << ' '; std::cout << ((*state["eflags"] & (1 << 10)) != 0 ? 'D' : 'd') << ' '; std::cout << ((*state["eflags"] & (1 << 9)) != 0 ? 'I' : 'i') << ' '; std::cout << ((*state["eflags"] & (1 << 8)) != 0 ? 'T' : 't') << ' '; std::cout << ((*state["eflags"] & (1 << 7)) != 0 ? 'S' : 's') << ' '; std::cout << ((*state["eflags"] & (1 << 6)) != 0 ? 'Z' : 'z') << ' '; std::cout << ((*state["eflags"] & (1 << 4)) != 0 ? 'A' : 'a') << ' '; std::cout << ((*state["eflags"] & (1 << 2)) != 0 ? 'P' : 'p') << ' '; std::cout << ((*state["eflags"] & (1 << 0)) != 0 ? 'C' : 'c'); std::cout << "\n"; #elif defined(EDB_X86_64) std::cout << " rax:" << hex_string(*state["rax"]); std::cout << " rbx:" << hex_string(*state["rbx"]); std::cout << " rcx:" << hex_string(*state["rcx"]); std::cout << " rdx:" << hex_string(*state["rdx"]); std::cout << " rflags:" << hex_string(*state["rflags"]); std::cout << "\n"; std::cout << " rsi:" << hex_string(*state["rsi"]); std::cout << " rdi:" << hex_string(*state["rdi"]); std::cout << " rsp:" << hex_string(*state["rsp"]); std::cout << " rbp:" << hex_string(*state["rbp"]); std::cout << " rip:" << hex_string(state.instruction_pointer()); std::cout << "\n"; std::cout << " r8:" << hex_string(*state["r8"]); std::cout << " r9:" << hex_string(*state["r9"]); std::cout << " r10:" << hex_string(*state["r10"]); std::cout << " r11:" << hex_string(*state["r11"]); std::cout << " "; std::cout << ((*state["rflags"] & (1 << 11)) != 0 ? 'O' : 'o') << ' '; std::cout << ((*state["rflags"] & (1 << 10)) != 0 ? 'D' : 'd') << ' '; std::cout << ((*state["rflags"] & (1 << 9)) != 0 ? 'I' : 'i') << ' '; std::cout << ((*state["rflags"] & (1 << 8)) != 0 ? 'T' : 't') << ' '; std::cout << ((*state["rflags"] & (1 << 7)) != 0 ? 'S' : 's') << ' '; std::cout << ((*state["rflags"] & (1 << 6)) != 0 ? 'Z' : 'z') << ' '; std::cout << ((*state["rflags"] & (1 << 4)) != 0 ? 'A' : 'a') << ' '; std::cout << ((*state["rflags"] & (1 << 2)) != 0 ? 'P' : 'p') << ' '; std::cout << ((*state["rflags"] & (1 << 0)) != 0 ? 'C' : 'c'); std::cout << "\n"; std::cout << " r12:" << hex_string(*state["r12"]); std::cout << " r13:" << hex_string(*state["r13"]); std::cout << " r14:" << hex_string(*state["r14"]); std::cout << " r15:" << hex_string(*state["r15"]); std::cout << "\n"; std::cout << " cs:" << hex_string<quint16>(*state["cs"]); std::cout << " ds:" << hex_string<quint16>(*state["ds"]); std::cout << " es:" << hex_string<quint16>(*state["es"]); std::cout << " fs:" << hex_string<quint16>(*state["fs"]); std::cout << "\n"; std::cout << " gs:" << hex_string<quint16>(*state["gs"]); std::cout << " ss:" << hex_string<quint16>(*state["ss"]); std::cout << "\n"; #endif }
/* Build a list of `struct so_list' objects describing the shared objects currently loaded in the inferior. */ static struct so_list * spu_current_sos (void) { enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); struct so_list *head; struct so_list **link_ptr; gdb_byte buf[MAX_SPE_FD * 4]; int i, size; /* First, retrieve the SVR4 shared library list. */ head = svr4_so_ops.current_sos (); /* Append our libraries to the end of the list. */ for (link_ptr = &head; *link_ptr; link_ptr = &(*link_ptr)->next) ; /* Determine list of SPU ids. */ size = target_read (¤t_target, TARGET_OBJECT_SPU, NULL, buf, 0, sizeof buf); /* Do not add stand-alone SPE executable context as shared library, but relocate main SPE executable objfile. */ if (spu_standalone_p ()) { if (size == 4) { int fd = extract_unsigned_integer (buf, 4, byte_order); spu_relocate_main_executable (fd); /* Re-enable breakpoints after main SPU context was established; see also comments in spu_solib_create_inferior_hook. */ enable_breakpoints_after_startup (); } return head; } /* Create an so_list entry for each SPU id. */ for (i = 0; i < size; i += 4) { int fd = extract_unsigned_integer (buf + i, 4, byte_order); struct so_list *newobj; unsigned long long addr; char annex[32], id[100]; int len; /* Read object ID. There's a race window where the inferior may have already created the SPE context, but not installed the object-id yet. Skip such entries; we'll be back for them later. */ xsnprintf (annex, sizeof annex, "%d/object-id", fd); len = target_read (¤t_target, TARGET_OBJECT_SPU, annex, (gdb_byte *) id, 0, sizeof id); if (len <= 0 || len >= sizeof id) continue; id[len] = 0; if (sscanf (id, "0x%llx", &addr) != 1 || !addr) continue; /* Allocate so_list structure. */ newobj = XCNEW (struct so_list); /* Encode FD and object ID in path name. Choose the name so as not to conflict with any (normal) SVR4 library path name. */ xsnprintf (newobj->so_name, sizeof newobj->so_name, "@%s <%d>", hex_string (addr), fd); strcpy (newobj->so_original_name, newobj->so_name); *link_ptr = newobj; link_ptr = &newobj->next; } /* Append OpenCL sos. */ append_ocl_sos (link_ptr); return head; }
void HID::print(__u8 tabs) { char* hex=hex_string((void*)descriptor,descriptor->bLength); printf("%.*sHID: %s\n",tabs,TABPADDING,hex); free(hex); }
static void test_invalids() { struct invalid_instructions invalids[] = {{ CS_ARCH_ARM, CS_MODE_THUMB, "Thumb", 1, {{ (unsigned char *)"\xbd\xe8\x1e\xff", 4, "invalid thumb2 pop because sp used and because both pc and lr are " "present at the same time" }}, }}; struct invalid_instructions * invalid = NULL; uint64_t address = 0x1000; cs_insn *insn; int i; int j; size_t count; printf("\nShould be invalid\n" "-----------------\n"); for (i = 0; i < sizeof(invalids)/sizeof(invalids[0]); i++) { cs_err err; invalid = invalids + i; err = cs_open(invalid->arch, invalid->mode, &handle); if (err) { printf("Failed on cs_open() with error returned: %u\n", err); continue; } cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON); cs_option(handle, CS_OPT_SYNTAX, CS_OPT_SYNTAX_NOREGNAME); for (j = 0; j < invalid->num_invalid_codes; ++j) { struct invalid_code *invalid_code = NULL; char *hex_str = NULL; invalid_code = invalid->invalid_codes + j; hex_str = hex_string(invalid_code->code, invalid_code->size); printf("%s %s: %s\n", invalid->platform_comment, hex_str, invalid_code->comment); free(hex_str); count = cs_disasm(handle, invalid_code->code, invalid_code->size, address, 0, &insn ); if (count) { size_t k; printf(" ERROR:\n"); for (k = 0; k < count; k++) { printf(" 0x%"PRIx64":\t%s\t%s\n", insn[k].address, insn[k].mnemonic, insn[k].op_str); print_insn_detail(&insn[k]); } cs_free(insn, count); } else { printf(" SUCCESS: invalid\n"); } } cs_close(&handle); } }
static void _digest(Request& r, MethodParams& params) { const String &smethod = params.as_string(0, PARAMETER_MUST_BE_STRING); Value& vdata=params.as_no_junction(1, "parameter must be string or file"); String::C data; if(const String* sdata=vdata.get_string()){ String::Body body=sdata->cstr_to_string_body_untaint(String::L_AS_IS, r.connection(false), &r.charsets); // explode content, honor tainting changes data=String::C(body.cstr(), body.length()); } else { VFile *file=vdata.as_vfile(String::L_AS_IS); data=String::C(file->value_ptr(),file->value_size()); } enum Method { M_MD5, M_SHA1, M_SHA256, M_SHA512 } method; if (smethod == "md5") method = M_MD5; else if (smethod == "sha1" ) method = M_SHA1; else if (smethod == "sha256" ) method = M_SHA256; else if (smethod == "sha512" ) method = M_SHA512; else throw Exception(PARSER_RUNTIME, &smethod, "must be 'md5' or 'sha1'"); const char *hmac=0; enum Format { F_HEX, F_BASE64 } format = F_HEX; if(params.count() == 3) if(HashStringValue* options=params.as_hash(2)) { int valid_options=0; if(Value* value=options->get("hmac")) { hmac=value->as_string().cstr(); valid_options++; } if(Value* value=options->get("format")) { const String& sformat=value->as_string(); if (sformat == "hex") format = F_HEX; else if (sformat == "base64" ) format = F_BASE64; else throw Exception(PARSER_RUNTIME, &sformat, "must be 'hex' or 'base64'"); valid_options++; } if(valid_options!=options->count()) throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION); } String::C digest; if(method == M_MD5){ PA_MD5_CTX c; if(hmac){ HMAC(hmac, pa_MD5Init, pa_MD5Update, pa_MD5Final, 64, 16); } else { pa_MD5Init(&c); pa_MD5Update(&c, (const unsigned char*)data.str, data.length); } char *str=(char *)pa_malloc(16); pa_MD5Final((unsigned char *)str, &c); digest = String::C(str, 16); } if(method == M_SHA1){ SHA1Context c; if(hmac){ HMAC(hmac, SHA1Reset, SHA1Input, SHA1ReadDigest, 64, 20); } else { SHA1Reset(&c); SHA1Input(&c, (const unsigned char*)data.str, data.length); } char *str=(char *)pa_malloc(20); SHA1ReadDigest(str, &c); digest = String::C(str, 20); } if(method == M_SHA256){ SHA256_CTX c; if(hmac){ HMAC(hmac, pa_SHA256_Init, pa_SHA256_Update, pa_SHA256_Final, 64, SHA256_DIGEST_LENGTH); } else { pa_SHA256_Init(&c); pa_SHA256_Update(&c, (const unsigned char*)data.str, data.length); } char *str=(char *)pa_malloc(SHA256_DIGEST_LENGTH); pa_SHA256_Final((unsigned char *)str, &c); digest = String::C(str, SHA256_DIGEST_LENGTH); } if(method == M_SHA512){ SHA512_CTX c; if(hmac){ HMAC(hmac, pa_SHA512_Init, pa_SHA512_Update, pa_SHA512_Final, 128, SHA512_DIGEST_LENGTH); } else { pa_SHA512_Init(&c); pa_SHA512_Update(&c, (const unsigned char*)data.str, data.length); } char *str=(char *)pa_malloc(SHA512_DIGEST_LENGTH); pa_SHA512_Final((unsigned char *)str, &c); digest = String::C(str, SHA512_DIGEST_LENGTH); } if(format == F_HEX){ r.write_pass_lang(*new String(hex_string((unsigned char *)digest.str, digest.length, false))); } if(format == F_BASE64){ r.write_pass_lang(*new String(pa_base64_encode(digest.str, digest.length))); } }
std::string hex_string(const long double value, const long digits) { return hex_string(std::string(), value, digits); }
void Endpoint::print(__u8 tabs) { char* hex=hex_string(&descriptor,descriptor.bLength); printf("%.*sEP(%02x): %s\n",tabs,TABPADDING,descriptor.bEndpointAddress,hex); free(hex); }
static void test_valids() { struct valid_instructions valids[] = {{ CS_ARCH_ARM, CS_MODE_THUMB, "Thumb", 3, {{ (unsigned char *)"\x00\xf0\x26\xe8", 4, 0x352, "0x352:\tblx\t#0x3a0\n" "\top_count: 1\n" "\t\toperands[0].type: IMM = 0x3a0\n", "thumb2 blx with misaligned immediate" }, { (unsigned char *)"\x05\xdd", 2, 0x1f0, "0x1f0:\tble\t#0x1fe\n" "\top_count: 1\n" "\t\toperands[0].type: IMM = 0x1fe\n" "\tCode condition: 14\n", "thumb b cc with thumb-aligned target" }, { (unsigned char *)"\xbd\xe8\xf0\x8f", 4, 0, "0x0:\tpop.w\t{r4, r5, r6, r7, r8, r9, r10, r11, pc}\n" "\top_count: 9\n" "\t\toperands[0].type: REG = r4\n" "\t\toperands[1].type: REG = r5\n" "\t\toperands[2].type: REG = r6\n" "\t\toperands[3].type: REG = r7\n" "\t\toperands[4].type: REG = r8\n" "\t\toperands[5].type: REG = r9\n" "\t\toperands[6].type: REG = r10\n" "\t\toperands[7].type: REG = r11\n" "\t\toperands[8].type: REG = pc\n", "thumb2 pop that should be valid" }, } }}; struct valid_instructions * valid = NULL; uint64_t address = 0x1000; cs_insn *insn; int i; int j; size_t count; for (i = 0; i < sizeof(valids)/sizeof(valids[0]); i++) { cs_err err; valid = valids + i; err = cs_open(valid->arch, valid->mode, &handle); if (err) { printf("Failed on cs_open() with error returned: %u\n", err); continue; } cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON); cs_option(handle, CS_OPT_SYNTAX, CS_OPT_SYNTAX_NOREGNAME); #define _this_printf(...) \ { \ size_t used = 0; \ used = snprintf(tmp_buf + cur, left, __VA_ARGS__); \ left -= used; \ cur += used; \ } printf("\nShould be valid\n" "---------------\n"); for (j = 0; j < valid->num_valid_codes; ++j) { char tmp_buf[2048]; size_t left = 2048; size_t cur = 0; size_t used = 0; int success = 0; char * hex_str = NULL; struct valid_code * valid_code = NULL; valid_code = valid->valid_codes + j; hex_str = hex_string(valid_code->code, valid_code->size); printf("%s %s @ 0x%04x: %s\n %s", valid->platform_comment, hex_str, valid_code->start_addr, valid_code->comment, valid_code->expected_out); count = cs_disasm(handle, valid_code->code, valid_code->size, valid_code->start_addr, 0, &insn ); if (count) { size_t k; size_t max_len = 0; size_t tmp_len = 0; for (k = 0; k < count; k++) { _this_printf( "0x%"PRIx64":\t%s\t%s\n", insn[k].address, insn[k].mnemonic, insn[k].op_str ); snprint_insn_detail(tmp_buf, &cur, &left, &insn[k]); } max_len = strlen(tmp_buf); tmp_len = strlen(valid_code->expected_out); if (tmp_len > max_len) { max_len = tmp_len; } if (memcmp(tmp_buf, valid_code->expected_out, max_len)) { printf( " ERROR: '''\n%s''' does not match" " expected '''\n%s'''\n", tmp_buf, valid_code->expected_out ); } else { printf(" SUCCESS: valid\n"); } cs_free(insn, count); } else { printf("ERROR: invalid\n"); } } cs_close(&handle); } #undef _this_prinf }