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);
}
