/** Add color data to an attribute node. * @param attr The attribute node. * @param col The value to set. */ void data_add_color(AttributeNode attr, const Color *col) { char buffer[1+6+1]; DataNode data_node; buffer[0] = '#'; convert_to_hex(col->red, &buffer[1]); convert_to_hex(col->green, &buffer[3]); convert_to_hex(col->blue, &buffer[5]); buffer[7] = 0; data_node = xmlNewChild(attr, NULL, (const xmlChar *)"color", NULL); xmlSetProp(data_node, (const xmlChar *)"val", (xmlChar *)buffer); }
static int l_encrypt(lua_State *L) { size_t keyLen, valLen, outLen, bufferSize; // TODO Key must be the correct key size const char *key = luaL_checklstring(L, 1, &keyLen); const char *val = luaL_checklstring(L, 2, &valLen); bufferSize = valLen + AES_BLOCK_SIZE; unsigned char buffer[bufferSize]; if (encrypt_str(buffer, val, valLen, key, &outLen) != 1) return luaL_error(L, "Error encrypting value"); size_t hexOutLen = outLen * 2; char hexStr[hexOutLen]; convert_to_hex(buffer, outLen, hexStr); luaL_Buffer b; luaL_buffinit(L, &b); luaL_addlstring(&b, hexStr, hexOutLen); luaL_pushresult(&b); return 1; }
void MyClass::GOST2012(){ emit set_max(0); QFile file(fname); emit sendStringFileName(fname); CTX = (GOST34112012Context*)(malloc(sizeof(GOST34112012Context))); if(sizeHash==64) GOST34112012Init(CTX, 512); if(sizeHash==32) GOST34112012Init(CTX, 256); if (file.open(QIODevice::ReadOnly) ) { while (!file.atEnd()) { QByteArray line = file.read(4096); GOST34112012Update(CTX, (unsigned char*)(line.data()), line.size()); } } file.close(); GOST34112012Final(CTX, &digest[0]); convert_to_hex(digest, hexdigest, sizeHash, 1);//eflag=1 (в Госте в таком виде хеш получается)// eflag=0 наоборот развернут QString rez = (char*)hexdigest; // QString rez = (char*)digest; // rez = rez.toLocal8Bit().toHex(); GOST34112012Cleanup(CTX); emit sendString(rez);emit set_max(100);emit change_value(100);emit finished();emit sendStringDone("Complete"); }
multipolygon_type multipolygon_finish() { set_size(m_multipolygon_size_offset, m_polygons); std::string data; std::swap(data, m_data); if (m_out_type == out_type::hex) { return convert_to_hex(data); } else { return data; } }
linestring_type linestring_finish(size_t num_points) { set_size(m_linestring_size_offset, num_points); std::string data; std::swap(data, m_data); if (m_out_type == out_type::hex) { return convert_to_hex(data); } else { return data; } }
point_type make_point(const osmium::geom::Coordinates& xy) const { std::string data; header(data, wkbPoint, false); str_push(data, xy.x); str_push(data, xy.y); if (m_out_type == out_type::hex) { return convert_to_hex(data); } else { return data; } }
static int l_hash(lua_State *L) { size_t len; const char *str = luaL_checklstring(L, 1, &len); unsigned char encr[SHA256_DIGEST_LENGTH]; if (hash_str(encr, str, len) != 1) return luaL_error(L, "Error hashing value"); size_t hexOutLen = SHA256_DIGEST_LENGTH * 2; char hexStr[hexOutLen]; convert_to_hex(encr, SHA256_DIGEST_LENGTH, hexStr); luaL_Buffer b; luaL_buffinit(L, &b); luaL_addlstring(&b, hexStr, hexOutLen); luaL_pushresult(&b); return 1; }
void go(std::ifstream *input_, unsigned int &buff_count, unsigned int &good_buff_count, unsigned int &total_count, bool show_raw, bool convert, bool show_zero, bool do_search, T search_int, T buffer_select){ bool good_buffer; int show_next = 0; unsigned int count = 0; unsigned int word_count = 0; T word; if(buffer_select != 0){ good_buffer = false; } else{ good_buffer = true; } while(true){ input_->read((char*)&word, sizeof(T)); if(input_->eof()){ if(buff_count > 1){ std::cout << " Buffer Size: " << word_count << " words\n"; std::cout << "============================================================================================================================\n"; } break; } if(do_search){ if(show_next > 0){ std::cout << convert_to_hex(word) << " "; if(convert){ std::cout << convert_to_hex(word, true) << " "; } show_next = show_next - 1; if(show_next <= 0){ std::cout << std::endl; } } else if(word == search_int){ std::cout << convert_to_hex(word) << " "; if(convert){ std::cout << convert_to_hex(word, true) << " "; } show_next = 4; } total_count++; word_count++; continue; } // Check for end of buffer /*if(word == ENDBUFF || (!show_zero && word == 0)){ total_count++; continue; }*/ if((!show_zero && word == 0)){ total_count++; word_count++; continue; } // Check for a new buffer if(word == HEAD || word == DATA || word == SCAL || word == DEAD || word == DIR || word == PAC || word == ENDFILE){ // new buffer buff_count++; if(buffer_select != 0){ if(word == buffer_select){ good_buffer = true; } else{ good_buffer = false; } } if(good_buffer){ good_buff_count++; if(buff_count > 1){ if(show_raw){ std::cout << "\n"; } std::cout << "\n Buffer Size: " << word_count << " words\n"; std::cout << "============================================================================================================================\n"; } std::cout << "\n============================================================================================================================\n"; std::cout << " Buffer Number: " << buff_count << std::endl; std::cout << " Buffer Type: " << convert_to_hex(word); if(word == HEAD){ std::cout << " \"HEAD\"\n"; } else if(word == DATA){ std::cout << " \"DATA\"\n"; } else if(word == ENDFILE){ std::cout << " \"EOF \"\n"; } else if(word == SCAL){ std::cout << " \"SCAL\"\n"; } else if(word == DEAD){ std::cout << " \"DEAD\"\n"; } else if(word == DIR){ std::cout << " \"DIR\"\n"; } else if(word == PAC){ std::cout << " \"PAC\"\n"; } std::cout << " Total Count: " << total_count << " words\n"; count = 0; } word_count = 0; // New buffer. Reset the buffer word count } if(!good_buffer){ // We don't care about this buffer total_count++; word_count++; continue; } total_count++; word_count++; if(show_raw){ if(count == 0){ std::cout << "\n0000 "; } else if(count % 10 == 0){ std::stringstream stream; stream << count; std::string temp_string = stream.str(); std::string padding = ""; if(temp_string.size() < 4){ for(unsigned int i = 0; i < (4 - temp_string.size()); i++){ padding += "0"; } } std::cout << "\n" << padding << temp_string << " "; } std::cout << convert_to_hex(word) << " "; count++; if(convert){ std::cout << convert_to_hex(word, true) << " "; count++; } } } }
int main(int argc, char *argv[]){ if(argc > 1 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0)){ help(argv[0]); return 1; } else if(argc < 2){ std::cout << " Error: Invalid number of arguments to " << argv[0] << ". Expected 1, received " << argc-1 << ".\n"; help(argv[0]); return 1; } std::ifstream input(argv[1], std::ios::binary); if(!input.is_open()){ std::cout << " Error: failed to open input file\n"; return 1; } std::streampos foffset = 0; int buffer_select = 0; int search_int = 0; int word_size = 4; bool show_raw = false; bool convert = false; bool show_zero = true; bool do_search = false; int index = 2; while(index < argc){ if(strcmp(argv[index], "--type") == 0){ if(index + 1 >= argc){ std::cout << " Error! Missing required argument to '--type'!\n"; help(argv[0]); return 1; } buffer_select = atoi(argv[++index]); std::cout << " Displaying only buffer type " << convert_to_hex(buffer_select) << "\n"; } else if(strcmp(argv[index], "--raw") == 0){ show_raw = true; } else if(strcmp(argv[index], "--convert") == 0){ convert = true; } else if(strcmp(argv[index], "--search") == 0){ if(index + 1 >= argc){ std::cout << " Error! Missing required argument to '--search'!\n"; help(argv[0]); return 1; } do_search = true; search_int = atoi(argv[++index]); std::cout << " Searching for " << search_int << " (" << convert_to_hex(search_int) << ")\n"; } else if(strcmp(argv[index], "--zero") == 0){ show_zero = false; } else if(strcmp(argv[index], "--word") == 0){ if(index + 1 >= argc){ std::cout << " Error! Missing required argument to '--word'!\n"; help(argv[0]); return 1; } word_size = atoi(argv[++index]); if(word_size != 1 && word_size != 2 && word_size != 4 && word_size != 8){ std::cout << " Error: Invalid word size (" << word_size << " bytes)!\n"; return 1; } std::cout << " Using word size of " << word_size << " bytes\n"; } else if(strcmp(argv[index], "--offset") == 0){ if(index + 1 >= argc){ std::cout << " Error! Missing required argument to '--offset'!\n"; help(argv[0]); return 1; } foffset = strtoll(argv[++index], NULL, 0); std::cout << " Starting at word no. " << foffset << " in file.\n"; } else{ std::cout << " Error! Unrecognized option '" << argv[index] << "'!\n"; help(argv[0]); return 1; } index++; } input.seekg(foffset*word_size); unsigned int good_buff_count = 0; unsigned int total_count = 0; unsigned int buff_count = 0; if(word_size == 1){ go<unsigned char>(&input, buff_count, good_buff_count, total_count, show_raw, convert, show_zero, do_search, search_int, buffer_select); } else if(word_size == 2){ go<unsigned short>(&input, buff_count, good_buff_count, total_count, show_raw, convert, show_zero, do_search, search_int, buffer_select); } else if(word_size == 4){ go<unsigned int>(&input, buff_count, good_buff_count, total_count, show_raw, convert, show_zero, do_search, search_int, buffer_select); } else{ go<unsigned long long>(&input, buff_count, good_buff_count, total_count, show_raw, convert, show_zero, do_search, search_int, buffer_select); } input.close(); if(!do_search){ std::cout << "\n\n Read " << total_count << " " << word_size << " byte words ("; total_count *= word_size; std::cout << total_count << " bytes)\n"; std::cout << " Found " << buff_count << " total buffers\n"; if(buffer_select != 0){ std::cout << " Found " << good_buff_count << " " << convert_to_hex(buffer_select) << " buffers\n"; } } return 0; }
/**************** * Print SEXP to buffer using the MODE. Returns the length of the * SEXP in buffer or 0 if the buffer is too short (We have at least an * empty list consisting of 2 bytes). If a buffer of NULL is provided, * the required length is returned. */ size_t gcry_sexp_sprint (const gcry_sexp_t list, int mode, void *buffer, size_t maxlength ) { static unsigned char empty[3] = { ST_OPEN, ST_CLOSE, ST_STOP }; const unsigned char *s; char *d; DATALEN n; char numbuf[20]; size_t len = 0; int i, indent = 0; s = list? list->d : empty; d = buffer; while ( *s != ST_STOP ) { switch ( *s ) { case ST_OPEN: s++; if ( mode != GCRYSEXP_FMT_CANON ) { if (indent) len++; len += indent; } len++; if ( buffer ) { if ( len >= maxlength ) return 0; if ( mode != GCRYSEXP_FMT_CANON ) { if (indent) *d++ = '\n'; for (i=0; i < indent; i++) *d++ = ' '; } *d++ = '('; } indent++; break; case ST_CLOSE: s++; len++; if ( buffer ) { if ( len >= maxlength ) return 0; *d++ = ')'; } indent--; if (*s != ST_OPEN && *s != ST_STOP && mode != GCRYSEXP_FMT_CANON) { len++; len += indent; if (buffer) { if (len >= maxlength) return 0; *d++ = '\n'; for (i=0; i < indent; i++) *d++ = ' '; } } break; case ST_DATA: s++; memcpy ( &n, s, sizeof n ); s += sizeof n; if (mode == GCRYSEXP_FMT_ADVANCED) { int type; size_t nn; switch ( (type=suitable_encoding (s, n))) { case 1: nn = convert_to_string (s, n, NULL); break; case 2: nn = convert_to_token (s, n, NULL); break; default: nn = convert_to_hex (s, n, NULL); break; } len += nn; if (buffer) { if (len >= maxlength) return 0; switch (type) { case 1: convert_to_string (s, n, d); break; case 2: convert_to_token (s, n, d); break; default: convert_to_hex (s, n, d); break; } d += nn; } if (s[n] != ST_CLOSE) { len++; if (buffer) { if (len >= maxlength) return 0; *d++ = ' '; } } } else { sprintf (numbuf, "%u:", (unsigned int)n ); len += strlen (numbuf) + n; if ( buffer ) { if ( len >= maxlength ) return 0; d = stpcpy ( d, numbuf ); memcpy ( d, s, n ); d += n; } } s += n; break; default: BUG (); } } if ( mode != GCRYSEXP_FMT_CANON ) { len++; if (buffer) { if ( len >= maxlength ) return 0; *d++ = '\n'; } } if (buffer) { if ( len >= maxlength ) return 0; *d++ = 0; /* for convenience we make a C string */ } else len++; /* we need one byte more for this */ return len; }
/* * DUID should not change over time so save it to file. * See RFC 3315 chapter 9 for details. */ static int set_duid(struct connman_service *service, struct connman_network *network, GDHCPClient *dhcp_client, int index) { GKeyFile *keyfile; const char *ident; char *hex_duid; unsigned char *duid; int duid_len; ident = __connman_service_get_ident(service); keyfile = connman_storage_load_service(ident); if (keyfile == NULL) return -EINVAL; hex_duid = g_key_file_get_string(keyfile, ident, "IPv6.DHCP.DUID", NULL); if (hex_duid != NULL) { unsigned int i, j = 0, hex; size_t hex_duid_len = strlen(hex_duid); duid = g_try_malloc0(hex_duid_len / 2); if (duid == NULL) { g_key_file_free(keyfile); g_free(hex_duid); return -ENOMEM; } for (i = 0; i < hex_duid_len; i += 2) { sscanf(hex_duid + i, "%02x", &hex); duid[j++] = hex; } duid_len = hex_duid_len / 2; } else { int ret; int type = __connman_ipconfig_get_type_from_index(index); ret = g_dhcpv6_create_duid(G_DHCPV6_DUID_LLT, index, type, &duid, &duid_len); if (ret < 0) { g_key_file_free(keyfile); return ret; } hex_duid = convert_to_hex(duid, duid_len); if (hex_duid == NULL) { g_key_file_free(keyfile); return -ENOMEM; } g_key_file_set_string(keyfile, ident, "IPv6.DHCP.DUID", hex_duid); __connman_storage_save_service(keyfile, ident); } g_free(hex_duid); g_key_file_free(keyfile); g_dhcpv6_client_set_duid(dhcp_client, duid, duid_len); return 0; }