void describeSession(SSL *ssl) { SSL_SESSION *session = SSL_get_session(ssl); CHECK(session != NULL); char *s; s = hex_to_string(session->session_id, session->session_id_length); fprintf(stderr, "Session ID: %s\n", s); OPENSSL_free(s); s = hex_to_string(session->sid_ctx, session->sid_ctx_length); fprintf(stderr, "Session ID CTX: %s\n", s); OPENSSL_free(s); #if 0 if (session->tlsext_ticklen > 0) { s = hex_to_string(session->tlsext_tick, session->tlsext_ticklen); fprintf(stderr, "Session Ticket: %s\n", s); OPENSSL_free(s); } #endif }
static int rdata_hex_to_string(buffer_type *output, rdata_atom_type rdata, rr_type* ATTR_UNUSED(rr)) { hex_to_string(output, rdata_atom_data(rdata), rdata_atom_size(rdata)); return 1; }
static void print_elo_change(struct player *player, int elo) { static char name[MAX_NAME_LENGTH]; hex_to_string(player->name, name); verbose("\t%-32s | %-16s | %d -> %d (%+d)\n", player->name, name, player->elo, elo, elo - player->elo); }
static int rdata_nsap_to_string(buffer_type *output, rdata_atom_type rdata, rr_type* ATTR_UNUSED(rr)) { buffer_printf(output, "0x"); hex_to_string(output, rdata_atom_data(rdata), rdata_atom_size(rdata)); return 1; }
static int rdata_unknown_to_string(buffer_type *output, rdata_atom_type rdata, rr_type* ATTR_UNUSED(rr)) { uint16_t size = rdata_atom_size(rdata); buffer_printf(output, "\\# %lu ", (unsigned long) size); hex_to_string(output, rdata_atom_data(rdata), size); return 1; }
/* Show the user all relevant information about a certificate: subject, * issuer, validity dates and fingerprints. */ static void ssl_showcert(X509 *cert, int loglev) { char *buf, *from, *to; X509_NAME *name; unsigned int len; unsigned char md[EVP_MAX_MD_SIZE]; /* Subject and issuer names */ if ((name = X509_get_subject_name(cert))) { buf = ssl_printname(name); putlog(loglev, "*", "TLS: certificate subject: %s", buf); nfree(buf); } else putlog(loglev, "*", "TLS: cannot get subject name from certificate!"); if ((name = X509_get_issuer_name(cert))) { buf = ssl_printname(name); putlog(loglev, "*", "TLS: certificate issuer: %s", buf); nfree(buf); } else putlog(loglev, "*", "TLS: cannot get issuer name from certificate!"); /* Fingerprints */ X509_digest(cert, EVP_md5(), md, &len); /* MD5 hash */ if (len <= sizeof(md)) { buf = hex_to_string(md, len); putlog(loglev, "*", "TLS: certificate MD5 Fingerprint: %s", buf); OPENSSL_free(buf); } X509_digest(cert, EVP_sha1(), md, &len); /* SHA-1 hash */ if (len <= sizeof(md)) { buf = hex_to_string(md, len); putlog(loglev, "*", "TLS: certificate SHA1 Fingerprint: %s", buf); OPENSSL_free(buf); } /* Validity time */ from = ssl_printtime(X509_get_notBefore(cert)); to = ssl_printtime(X509_get_notAfter(cert)); putlog(loglev, "*", "TLS: certificate valid from %s to %s", from, to); nfree(from); nfree(to); }
static int rdata_hex_to_string(buffer_type *output, rdata_atom_type rdata, rr_type* ATTR_UNUSED(rr)) { if(rdata_atom_size(rdata) == 0) { /* single zero represents empty buffer, such as CDS deletes */ buffer_printf(output, "0"); } else { hex_to_string(output, rdata_atom_data(rdata), rdata_atom_size(rdata)); } return 1; }
static int rdata_hexlen_to_string(buffer_type *output, rdata_atom_type rdata, rr_type* ATTR_UNUSED(rr)) { if(rdata_atom_size(rdata) <= 1) { /* NSEC3 salt hex can be empty */ buffer_printf(output, "-"); return 1; } hex_to_string(output, rdata_atom_data(rdata)+1, rdata_atom_size(rdata)-1); return 1; }
void html_print_player(struct player *player, int show_clan_link) { char tmp[MAX_NAME_LENGTH]; assert(player != NULL); printf("<tr>"); /* Rank */ if (player->rank == INVALID_RANK) printf("<td>?</td>"); else printf("<td>%u</td>", player->rank); /* Name */ hex_to_string(player->name, tmp); printf("<td>"); html(tmp); printf("</td>"); /* Clan */ hex_to_string(player->clan, tmp); printf("<td>"); if (*tmp != '\0') { if (show_clan_link) printf("<a href=\"/clans/%s.html\">", player->clan); html(tmp); if (show_clan_link) printf("</a>"); } printf("</td>"); /* Elo */ if (player->elo == INVALID_ELO) printf("<td>?</td>"); else printf("<td>%d</td>", player->elo); printf("</tr>\n"); }
int rdata_atoms_to_unknown_string(buffer_type *output, rrtype_descriptor_type *descriptor, size_t rdata_count, rdata_atom_type *rdatas) { size_t i; size_t size = rdata_maximum_wireformat_size(descriptor, rdata_count, rdatas); buffer_printf(output, " \\# %lu ", (unsigned long) size); for (i = 0; i < rdata_count; ++i) { if (rdata_atom_is_domain(descriptor->type, i)) { const dname_type *dname = domain_dname(rdata_atom_domain(rdatas[i])); hex_to_string( output, dname_name(dname), dname->name_size); } else { hex_to_string(output, rdata_atom_data(rdatas[i]), rdata_atom_size(rdatas[i])); } } return 1; }
void describeSession(SSL *ssl) { SSL_SESSION *session = SSL_get_session(ssl); CHECK(session != NULL); { unsigned int len; const unsigned char *id = SSL_SESSION_get_id(session, &len); char *s = hex_to_string(id,len); fprintf(stderr, "Session ID: %s\n", s); OPENSSL_free(s); } { #if OPENSSL_VERSION_NUMBER < 0x10100000L // Don't seem to have this available to read any more char *s = hex_to_string(session->sid_ctx, session->sid_ctx_length); fprintf(stderr, "Session ID CTX: %s\n", s); OPENSSL_free(s); #endif } { unsigned char *ticket; size_t ticklen; #if !defined LIBRESSL_VERSION_NUMBER && OPENSSL_VERSION_NUMBER >= 0x10100000L SSL_SESSION_get0_ticket(session, &ticket, &ticklen); #else ticket = session->tlsext_tick; ticklen = session->tlsext_ticklen; #endif if (ticklen > 0) { char *s = hex_to_string(ticket,ticklen); fprintf(stderr, "Session Ticket: %s\n", s); OPENSSL_free(s); } } }
int main(int argc, char **argv) { FILE *file; char name[MAX_NAME_LENGTH], clan[MAX_NAME_LENGTH]; struct player_array array = PLAYER_ARRAY_ZERO; unsigned i; load_config(); if (argc != 2) { fprintf(stderr, "usage: %s <clan_name>\n", argv[0]); return EXIT_FAILURE; } /* Load players */ sprintf(path, "%s/clans/%s", config.root, argv[1]); if (!(file = fopen(path, "r"))) return perror(path), EXIT_FAILURE; while (fscanf(file, " %s", name) == 1) { struct player player; if (!read_player(&player, name)) strcpy(player.clan, argv[1]); add_player(&array, &player); } fclose(file); /* Sort players */ qsort(array.players, array.length, sizeof(*array.players), cmp_player); /* Eventually, print them */ hex_to_string(argv[1], clan); print_header(&CTF_TAB, clan, NULL); printf("<h2>%s</h2>\n", clan); printf("<p>%u member(s)</p>\n", array.length); printf("<table><thead><tr><th></th><th>Name</th><th>Clan</th><th>Score</th></tr></thead>\n<tbody>\n"); for (i = 0; i < array.length; i++) html_print_player(&array.players[i], 0); printf("</tbody></table>\n"); print_footer(); return EXIT_SUCCESS; }
/* Get the certificate fingerprint of the connection corresponding * to the socket. * * Return value: ptr to the hexadecimal representation of the fingerprint * or NULL if there's no certificate associated with the connection. */ char *ssl_getfp(int sock) { char *p; unsigned i; X509 *cert; static char fp[64]; unsigned char md[EVP_MAX_MD_SIZE]; if (!(cert = ssl_getcert(sock))) return NULL; if (!X509_digest(cert, EVP_sha1(), md, &i)) return NULL; if (!(p = hex_to_string(md, i))) return NULL; strncpyz(fp, p, sizeof fp); OPENSSL_free(p); return fp; }
bool url_crack_processor::process(const uri& u, const http::request& req, const connection_sptr& sock) { std::map<std::string, std::string> qmap=u.query_map(); const std::string& cmd=qmap["cmd"]; if (cmd == "url_crack") { std::string url = qmap["uri"]; url = hex_to_string(url); crack_adapter_sptr cracker = crack_adapter::create(url, get_io_service()); crack_adapter_wptr cracker_wptr(cracker); connection_wptr sock_wsptr(sock); cracker->get_crack_urls()=boost::bind(&this_type::write_urls, this, _1, cracker_wptr); crack_adapters_[cracker] = sock; return true; } return false; }
char *ssl_fpconv(char *in, char *out) { long len; char *fp; unsigned char *md5; if (!in) return NULL; if ((md5 = string_to_hex(in, &len))) { fp = hex_to_string(md5, len); if (fp) { out = user_realloc(out, strlen(fp) + 1); strcpy(out, fp); OPENSSL_free(md5); OPENSSL_free(fp); return out; } OPENSSL_free(md5); } return NULL; }
/* * Print pointer * @param ap Pointer to variable argument list * @return Number of characters printed */ static int pointer_to_string(__builtin_va_list *ap, char *buf, uint64_t *counterp) { void *ptr = __builtin_va_arg(*ap, void*); return hex_to_string((void*)&ptr, sizeof(void*),buf, counterp); }
void monitor_write_hex(u32int value){ char *converted = hex_to_string(value); monitor_write("0x"); monitor_write(converted); monitor_put('\n'); }
char *i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, ASN1_OCTET_STRING *oct) { return hex_to_string(oct->data, oct->length); }
/* * Print hexadecimal * @param ap Pointer to variable argument list * @return Number of characters printed */ static int hexnum_to_string(__builtin_va_list *ap,char *buf, uint64_t *counterp) { int d = __builtin_va_arg(*ap, int); return hex_to_string(&d, sizeof(int),buf, counterp); }