/* The main function of our program. */
int main()
{
/* Our variables we store the result in. */
uint8_t post_x;
/* Initialize to 0 so we are sure there is no garbage. */
post_x = 0;
/* Print out the bits before we call our function. */
printf("\n\nx:\t\t");
print_binary(X_BITS);
printf("\np: %d\nn: %d\n\n", P, N);
/* Call our invert() function and save the result
* in the post_x var. Remember that the second input
* var to invert() is the position and the third is
* the number of bits. See invert() for more details.
*/
post_x = invert(X_BITS, P, N);
/* Print out the bits after we call our function. */
printf("result:\t\t");
print_binary(post_x);
printf("\n\n");
/* Be a good main function and return 0 because all went fine. */
return 0;
}
int compute_HD(int n1,int i, int n2,int j,int bits,int cpog_count){
int ones,bit_diff,q;
char *number;
ones = 0;
if(SET){
if(!DC_custom[i] && !DC_custom[j]){
bit_diff = n1 ^ n2;
for(q = 0; q<bits; q++){
if(bit_diff & 1) ones++;
bit_diff >>= 1;
}
return ones;
}
if(DC_custom[i] && !DC_custom[j]){
print_binary(NULL,n2, bits);
number = numb;
ones = 0;
char str[MAX_NAME];
int_to_string_DC(bits, i, n1, str);
for(q = 0; q<bits; q++){
if(str[q] == '0' && number[q] == '1')
ones++;
if(str[q] == '1' && number[q] == '0')
ones++;
}
return ones;
}
if(!DC_custom[i] && DC_custom[j]){
print_binary(NULL,n1, bits);
number = numb;
char str[MAX_NAME];
int_to_string_DC(bits, j, n2, str);
for(q = 0; q<bits; q++){
if(str[q] == '0' && number[q] == '1')
ones++;
if(str[q] == '1' && number[q] == '0')
ones++;
}
return ones;
}
if(DC_custom[i] && DC_custom[j]){
char str[MAX_NAME], str2[MAX_NAME];
int_to_string_DC(bits, i, n1, str);
int_to_string_DC(bits, j, n2, str2);
for(q = 0; q<bits; q++){
if(str[q] == '0' && str2[q] == '1')
ones++;
if(str[q] == '1' && str2[q] == '0')
ones++;
}
return ones;
}
}
void challenge_34()
{
gmp_randstate_t *state = gmp_rand();
mpz_t p, g, a, A, b, B;
unsigned char server_key[16], client_key[16];
unsigned char server_ct[256] = {0}, client_ct[256] = {0};
unsigned char server_iv[16], client_iv[16];
unsigned char message[128] = "this is a message of 30 bytes.";
int mlen = 30, ctlen_server, ctlen_client, ptlen;
fill_random_bytes(server_iv, 16);
fill_random_bytes(client_iv, 16);
// ServerKeyExchange:
// Sends generated p, g, A
dh_params(p, g);
dh_keyexchange(state, p, g, a, A);
// MITM relays p, g, and p instead of A
// ClientKeyExchange:
// Send generated B
dh_keyexchange(state, p, g, b, B);
// MITM relays p instead of B
// Finished (server):
// Received p from client, sends iv + encrypted message
dh_finished(p, p, a, server_key);
ctlen_server = encrypt_AES_CBC(message, server_ct, mlen, server_key, server_iv);
// MITM relays as is
// Finished (client):
// Received p from server, sends iv + encrypted message
dh_finished(p, p, b, client_key);
ctlen_client = encrypt_AES_CBC(message, client_ct, mlen, client_key, client_iv);
// MITM relays as is
// Key should now be kdf(0), since
// p mod p = 0 and 0^a = 0^b = 0
unsigned char mitm_key[16];
unsigned char pt[256] = {0};
dh_kdf_from_ui(0, mitm_key);
ptlen = decrypt_AES_CBC(server_ct, pt, ctlen_server, mitm_key, server_iv);
print_str("Recovered plaintext from server message:");
print_binary(pt, ptlen);
memset(pt, 0, 256);
ptlen = decrypt_AES_CBC(client_ct, pt, ctlen_client, mitm_key, client_iv);
print_str("Recovered plaintext from client message:");
print_binary(pt, ptlen);
dh_cleanup(state, p, g, a, A, b, B);
}
int main(void)
{
int i;
uint8_t payload[] = {0x18, 0x80, 0x81, 0x01};
uint8_t * payload_new = (uint8_t *)malloc(sizeof(uint8_t) * 4);
for(i=0;i<4;i++) {
payload_new[i] = reverse_bit_order(payload[i]);
}
for(i=0;i<4;i++) {
printf("%d: old=0x%02X (%s)", i, payload[i], print_binary(payload[i]));
printf(" -> new=0x%02X (%s)\n", payload_new[i], print_binary(payload_new[i]));
}
}
// The inverse table
void print_index_of()
{
int i;
for (i=0; i<=NN; i++)
printf("%s = a^%d\n",print_binary(i, MM), index_of[i]);
}
int main(int argc, char* argv[])
{
if (argc != 2)
{
perror("arg not enough:");
exit(1);
}
int ret;
char* str;
char res[128];
struct in_addr addr;
if ((ret = inet_pton(AF_INET, argv[1], &addr)) == 0)
{
perror("inet_pton:");
exit(1);
}
printf("%d\n",addr.s_addr);
print_binary(addr.s_addr);
str = inet_ntop(AF_INET, &addr, res, sizeof(res));
if ( str == NULL)
{
perror("inet_ntop:");
exit(1);
}
printf("%s\n", res);
exit(0);
}
void challenge_39()
{
mpz_t n, e, d;
char *p_str = "38b689c351cf329d5efd5676b";
char *q_str = "54060a750a88d007bd41db2cb";
rsa_keygen(p_str, q_str, n, e, d);
size_t pt_len = 32, ct_len = 0;
unsigned char pt[200] = "yellow submarineyellow submarine";
unsigned char ct[200] = {0};
mpz_out_str(stdout, 16, n);
printf("\n");
mpz_out_str(stdout, 16, e);
printf("\n");
mpz_out_str(stdout, 16, d);
printf("\n");
rsa_encrypt(pt, pt_len, ct, ct_len, n, e);
memset(pt, 0, 32);
rsa_decrypt(ct, ct_len, pt, pt_len, n, d);
printf("Plaintext length: %ld\n", pt_len);
print_binary(pt, pt_len);
}
// just print the binary representation of the GF(2^MM) field
// for debugging
void print_alpha_to()
{
int i;
for (i=0; i<=NN; i++)
printf("a^%3d = %s\n",i, print_binary(alpha_to[i], MM));
}
int main(void) {
printf("Enter a number\n");
unsigned n;
while (scanf("%u", &n) == 1) {
printf("Received:\t");
print_binary(n);
printf("\nNext smallest:\t");
print_binary(next_smallest(n));
printf("\nNext largest:\t");
print_binary(next_largest(n));
printf("\n");
}
return 0;
}
int main(void) {
printf("Enter N, M, j, and i\n");
unsigned N, M, j, i;
while (scanf("%u%u%u%u", &N, &M, &j, &i) == 4) {
printf("N =\t\t");
print_binary(N);
printf("\nM =\t\t");
print_binary(M);
printf("\nResult =\t");
print_binary(insert_into(N, M, j, i));
printf("\n");
}
return 0;
}
void print_bitmap(bitmap_t* bitmap) {
for (unsigned row=0; row<bitmap->height; ++row) {
printf("%3i ",row);
for (unsigned int col = 0; col<bitmap->rowwidth; ++col) {
print_binary(bitmap->data[row*bitmap->rowwidth+col], col == bitmap->rowwidth -1 ? bitmap->width % 8 : 8);
}
printf("\n");
}
}
void trace_event(union perf_event *event)
{
unsigned char *raw_event = (void *)event;
if (!dump_trace)
return;
print_binary(raw_event, event->header.size, 16,
trace_event_printer, event);
}
void loadScenarioOpcodes(int index){
scenarioOpcodes.resize(cpog_count);
clear_scenarios();
for(int i = 0; i < cpog_count; i++){
print_binary(NULL, perm[index][i], bits);
scenarioOpcodes[i] = string(numb);
}
return;
}
void print_memory()
{
int i;
for(i = 0; i < globals.mem_size; i++)
{
int lbln = label_find_by_value(i);
if(lbln != -1)
{
printf("// %s\n", globals.labels[lbln].name);
}
if(globals.mem[i].valid)
{
if(globals.mem[i].is_literal)
{
int l;
if(globals.mem[i].is_reference)
{
l = globals.labels[globals.mem[i].literal].value;
if(l == -1)
{
fprintf(stderr, "ERROR: found label with undefined value. Label name: %s\n", globals.labels[globals.mem[i].literal].name);
}
}
else
{
l = globals.mem[i].literal;
}
print_binary(l, 8);
putchar('\n');
print_binary((l >> 8), 8);
}
else
{
uint16_t tmp = (globals.mem[i].opcode << 9) | (globals.mem[i].op0 << 6) | (globals.mem[i].op1 << 3) | globals.mem[i].op2;
print_binary(tmp, 8);
putchar('\n');
print_binary((tmp >> 8), 8);
}
}
int main(){
//declaration and user inputs number
unsigned int user_input;
printf("Enter an integer value: ");
scanf("%u", &user_input);
//declarations for sum output and a for loop value
int sum_bits;
int i=0;
//so long as the value of user_input shifted count_digits to the right is not 0
while(i<VALUES){
//in this while loop I am going to iterate over the rightmost digit of the number
sum_bits+= (user_input>>i)&1; //if the rightmost digit is 1, add 1 to sum_bits
//otherwise, if the rightmost digit is 0, then this returns 0 and changes nothing
if(i%2==1){
//make sure that the bit in that place is 1
user_input|=(1<<i);
}
i++;
}
printf("The number of bits that are equal to 1 is %d\n", sum_bits);
printf("After setting odd-bits to 1: ");
print_binary(user_input);
int j=0;
while(j<VALUES){
if(j%2==0){
//clear the bit from that place
//note: ~(1<<j) contains 1111111011111 with the 0 in the jth position only
user_input &= ~(1<<j);
}
j++;
}
printf("\nAfter clearing even-bits: ");
print_binary(user_input);
printf("\n");
return 0;
}
//returns x with the bits n+p..p bits replaced with the rightmost
//n bits of y.
int setbits(int x, int p, int n, int y)
{
//bit positions are 32..0 from left to right.
int mask;
int y_bits;
//make a mask to clear out the n bits.
mask = ~((~(~0 << n)) << p);
printf("Mask ");
print_binary(mask);
//now collect relevant bits from y.
y_bits = ( ~((~0)<< n) & y) << p;
printf("y_bits ");
print_binary(y_bits);
printf("x&mask ");
print_binary(x&mask);
return (x & mask) | y_bits;
}
void binary_clock_draw(struct screen* display, struct time* time, int skin){
int lines_values[]={
time->hour,time->minute,time->second
};
char buffer[9];
int i;
const struct picture* binary_bitmaps = &(binary_skin[skin][display->screen_type]);
int y_offset=(display->getheight()-(binary_bitmaps->slide_height*3))/2;
int x_offset=(display->getwidth()-(binary_bitmaps->width*6))/2;
for(i=0;i<3;i++){
print_binary(buffer, lines_values[i], 6);
draw_string(display, binary_bitmaps, buffer, x_offset,
binary_bitmaps->slide_height*i+y_offset);
}
}
/* lpm_insert:
* Insert a new prefix ('ip_string' and 'netmask') into the tree. If
* 'ip_string' does not contain a valid IPv4 address, or the netmask
* is clearly invalid, the tree is not modified and the function
* returns 0. Successful insertion returns 1.
*/
int lpm_insert(struct lpm_tree* tree, char* ip_string, uint32_t netmask)
{
struct sockaddr_storage *prefix = (struct sockaddr_storage *)malloc(sizeof(struct sockaddr_storage));
struct sockaddr_in6 *prefix6 = (struct sockaddr_in6 *)prefix;
struct sockaddr_in *prefix4 = (struct sockaddr_in *) prefix;
if (inet_pton(AF_INET6, ip_string, &prefix6->sin6_addr) == 1 && netmask <= MAX_BITS6) {
prefix->ss_family = AF_INET6;
char buffer[129];
memset(buffer, '\0', 129);
printf("%s\n", print_binary((uint8_t *)&prefix6->sin6_addr, sizeof(prefix6->sin6_addr), buffer, 129));
DEBUG(">> Inserting %s/%d ========\n", ip_string, netmask);
insert(prefix, netmask, tree->head);
DEBUG(">> Done inserting %s/%d ===\n", ip_string, netmask);
return 1;
}
else if (inet_pton(AF_INET, ip_string, &prefix4->sin_addr) == 1 && netmask <= MAX_BITS4) {
prefix4->sin_family = AF_INET;
prefix4->sin_addr.s_addr = htonl(prefix4->sin_addr.s_addr);
char buffer[33];
memset(buffer, '\0', 33);
printf("%s\n", print_binary((uint8_t *)&prefix4->sin_addr, sizeof(prefix4->sin_addr), buffer, 32));
DEBUG(">> Inserting %s/%d ========\n", ip_string, netmask);
insert(prefix, netmask, tree->head);
DEBUG(">> Done inserting %s/%d ===\n", ip_string, netmask);
return 1;
}
return 0;
}
int main()
{
int binary_number_1,binary_number_2,binary_number_3;
printf("Please enter a value for A\r\n");
while( scanf("%d",&binary_number_1) != 1)
{
fflush(stdin);
}
printf("Please enter a value for B\r\n");
while( scanf("%d",&binary_number_2) != 1)
{
fflush(stdin);
}
printf("Please enter a value for C\r\n");
while( scanf("%d",&binary_number_3) != 1)
{
fflush(stdin);
}
printf("first binary number=");
print_binary(binary_number_1);
printf("\r\n");
printf("second binary number=");
print_binary(binary_number_2);
printf("\r\n");
printf("third binary number=");
print_binary(binary_number_3);
printf("\r\n");
return 0;
}
/* debug_print:
* Prints out the current node's parent, the current node's value (if
* it has one), and recurses down to the left then right children. The
* 'left' parameter should indicate the direction of the hop to the
* current node (1 if the left child was used, 0 if the right child
* was used; -1 is used to indicate the root of the tree.)
*/
void debug_print(struct internal_node* parent, int left, int depth, struct internal_node* n)
{
printf("parent:%p", (void*)parent);
if (left == 1) {
printf("->L");
}
else if (left == 0) {
printf("->R");
}
else {
printf("---");
}
if (n == NULL) {
printf(" Reached a null bottom %p\n", (void*)n);
return;
}
else if (n->type == INT_NODE) {
printf(" Internal node %p.\n", (void*)n);
}
else {
struct data_node* node = (struct data_node*)n;
char output[INET6_ADDRSTRLEN];
memset(output, 0, INET6_ADDRSTRLEN);
struct sockaddr_storage *addr = node->prefix;
switch (addr->ss_family) {
case AF_INET6: {
struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
inet_ntop(AF_INET6, &addr6->sin6_addr, output, INET6_ADDRSTRLEN);
break;
}
case AF_INET: {
struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
inet_ntop(AF_INET, &addr4->sin_addr, output, INET6_ADDRSTRLEN);
char buffer[33];
memset(buffer, '\0', 33);
printf("%s\n", print_binary((uint8_t *)&addr4->sin_addr, sizeof(addr4->sin_addr), buffer, 33));
break;
}
}
printf(" External node: %p, %s/%d\n", (void*)n, output, node->netmask);
}
debug_print(n, 1, depth+1, n->l);
debug_print(n, 0, depth+1, n->r);
}
/* Render a value to text. */
static char *print_value(cJSON *item,int depth)
{
char *out=0;
if (!item) return 0;
switch ((item->type)&255)
{
case cJSON_NULL: out=cJSON_strdup(""); break;
case cJSON_False: out=cJSON_strdup("false");break;
case cJSON_True: out=cJSON_strdup("true"); break;
case cJSON_Number: out=print_number(item);break;
case cJSON_String: out=print_string(item);break;
case cJSON_Array: out=print_array(item,depth);break;
case cJSON_Object: out=print_object(item,depth);break;
case cJSON_Binary: out=print_binary(item,depth); break;
}
return out;
}
int timer_display_conf(unsigned char conf) {
printf("Status byte: ");
print_binary(conf);
printf("\n");
printf("Output: %d\n", (conf & TIMER_STATUS_OUTPUT) >> TIMER_STATUS_OUTPUT_BIT);
printf("Null count: %d\n", (conf & TIMER_STATUS_NULL) >> TIMER_STATUS_NULL_BIT);
printf("Type of access: ");
switch (conf & TIMER_LSB_MSB)
{
case TIMER_LSB:
printf("LSB\n");
break;
case TIMER_MSB:
printf("MSB\n");
break;
case TIMER_LSB_MSB:
printf("LSB followed by MSB\n");
break;
default:
printf("Unknown\n");
}
printf("Operating mode: ");
switch (conf & (TIMER_RATE_GEN | TIMER_SQR_WAVE))
{
case TIMER_RATE_GEN:
printf("rate generator\n");
break;
case TIMER_SQR_WAVE:
printf("square wave generator\n");
break;
default:
printf("Unknown\n");
}
printf("Counting mode: ");
if ((conf & TIMER_BCD) == TIMER_BCD)
{
printf("BCD\n");
}
else
{
printf("binary\n");
}
return 0;
}
TEST_F(Helium_100_Test, InterpretFunctionConfig)
{
//unsigned char * config_value = (unsigned char *)0b0111110111011111;
printf("Size of function_config: %d \r\n", CFG_FUNCTION_CONFIG_LENGTH);
int config_value = 0x7ddf;
int config2_value = 0x0000;
struct function_config fc1;
print_binary(config_value);
memcpy (&fc1,&config_value,CFG_FUNCTION_CONFIG_LENGTH);
ASSERT_EQ(0,fc1.beacon_0);
ASSERT_EQ(CFG_FC_BEACON_CODE_RESET_ON,fc1.beacon_oa_cmd_status);
ASSERT_EQ(CFG_FC_BEACON_CODE_UPLOAD_ON,fc1.beacon_code_upload_status);
ASSERT_EQ(CFG_FC_BEACON_OA_COMMANDS_ON,fc1.beacon_radio_reset_status);
ASSERT_EQ(CFG_FC_TELEMETRY_DUMP_ON,fc1.telemetry_status);
ASSERT_EQ(CFG_FC_TELEMETRY_RATE_2HZ,fc1.telemetry_rate); // TODO BROKEN
ASSERT_EQ(CFG_FC_TELEMETRY_ON,fc1.telemetry_dump_status); // TODO BROKEN
ASSERT_EQ(CFG_FC_TX_CRC_ON,fc1.crc_rx);
ASSERT_EQ(CFG_FC_RX_CRC_ON,fc1.crc_tx);
ASSERT_EQ(CFG_FC_PIN14_DIOOVERAIR_ON,fc1.pin14);
ASSERT_EQ(CFG_FC_PIN13_RXPACKETTOG,fc1.pin13);
ASSERT_EQ(CFG_FC_LED_RXTOG,fc1.led);
/*
struct function_config fc1_comp;
fc1_comp.led = CFG_FC_LED_RXTOG;
fc1_comp.pin13 = CFG_FC_PIN13_RXPACKETTOG;
fc1_comp.beacon_0 = 0;
struct function_config2 fc2;
print_binary(config2_value);
memcpy (&fc2,&config2_value,CFG_FUNCTION_CONFIG2_LENGTH);
ASSERT_EQ(0,fc2.t0);
ASSERT_EQ(0,fc2.t4);
ASSERT_EQ(0,fc2.t8);
ASSERT_EQ(0,fc2.tbd);
ASSERT_EQ(0,fc2.txcw);
ASSERT_EQ(0,fc2.rxcw);
ASSERT_EQ(0,fc2.rafc);
*/
}
// Poke
void poke(const char * reg, unsigned int value)
{
// Initialize
skiroc2_slow_control_init();
// Poke
skiroc2_slow_control_poke(reg, value);
// Peek
value = skiroc2_slow_control_peek(reg);
printf("%s ", reg);
print_binary(value);
printf("\n");
// Write to file
dump_register_to_file();
return;
}
void challenge_30()
{
unsigned char message[128] = "comment1=cooking%20MCs;userdata=foo;"
"comment2=%20like%20a%20pound%20of%20bacon";
int mlen = 77, plen;
unsigned char padded_message[256] = {0};
memcpy(padded_message, message, 128);
unsigned char append[16] = ";admin=true";
int alen = 11;
unsigned char mac[16], forged_mac[16], test_mac[16];
print_str("Base MAC");
md4_keyed_mac(message, strlen((char *) message),
(unsigned char *) get_static_word(),
strlen(get_static_word()), mac);
print_hex(mac, 16);
print_str("\nForged MAC");
// Assumes secret length 8, but will be the same for any
// secret length that doesn't increase or decrease the
// number of 64 byte blocks in the hash input + padding
md4_length_extension(mac, mlen + 8 + sha1_pad_length(mlen + 8), append, alen, forged_mac);
print_hex(forged_mac, 16);
print_str("\nPlaintext verified by server: ");
int i;
for (i = 0; i < 16; ++i) {
plen = md4_pad(padded_message, mlen, i);
memcpy(padded_message + plen, append, alen);
plen += alen;
md4_keyed_mac(padded_message, plen,
(unsigned char *) get_static_word(),
strlen(get_static_word()), test_mac);
//print_hex(test_mac, 16);
//print_binary(padded_message, plen);
if (memcmp(forged_mac, test_mac, 16) == 0) {
print_hex(test_mac, 16);
print_binary(padded_message, plen);
}
}
}
unsigned int print_it(t_tmp_arg *tmp, t_params *params, char c,
unsigned int chars_to_save)
{
unsigned int wt;
wt = 0;
(c == 'd') ? (wt = print_int(tmp, params, 0, 0)) : (0);
(c == 'i') ? (wt = print_int(tmp, params, 0, 0)) : (0);
(c == 'u') ? (wt = print_uint(tmp, params, 0, 0)) : (0);
(c == 'x') ? (wt = print_little_hexa(tmp, params, 0, 0)) : (0);
(c == 'X') ? (wt = print_large_hexa(tmp, params, 0, 0)) : (0);
(c == 'n') ? (wt = save_chars(tmp, chars_to_save)) : (0);
(c == 'o') ? (wt = print_octal(tmp, params, 0, 0)) : (0);
(c == 'c') ? (wt = print_char(tmp, params, 0, 0)) : (0);
(c == 's') ? (wt = print_str(tmp, params, 0, 0)) : (0);
(c == '%') ? (wt = print_percent()) : (0);
(c == 'S') ? (wt = print_all_str(tmp, params, 0, 0)) : (0);
(c == 'p') ? (wt = print_ptr(tmp, params, 0, 0)) : (0);
(c == 'b') ? (wt = print_binary(tmp, params, 0, 0)) : (0);
return (wt);
}
static void print_file(const sc_file_t *file)
{
const char *st;
if (file->type == SC_FILE_TYPE_DF)
printf("[");
else
printf(" ");
printf("%02X%02X", file->id >> 8, file->id & 0xFF);
if (file->type == SC_FILE_TYPE_DF)
printf("]");
else
printf(" ");
switch (file->type) {
case SC_FILE_TYPE_WORKING_EF:
st = "wEF";
break;
case SC_FILE_TYPE_INTERNAL_EF:
st = "iEF";
break;
case SC_FILE_TYPE_DF:
st = "DF";
break;
default:
st = "???";
break;
}
printf("\t%4s", st);
printf(" %5lu", (unsigned long)file->size);
if (file->namelen) {
printf("\tName: ");
print_binary(stdout, file->name, file->namelen);
}
printf("\n");
return;
}
int main() {
enumerate_broken_digits();
int T;
scanf("%d", &T);
for (int i = 1; i <= T; i++) {
int N;
scanf("%d", &N);
int d[N];
for (int j = 0; j < N; j++) {
d[j] = read_binary();
}
printf("Case #%d: ", i);
int next;
if (N > 10) {
int j;
for (j = 0; j < N; j++) {
if (d[j] != d[j % 10]) {
printf("ERROR!\n");
break;
}
}
if (j != N) continue;
next = next_state(&d[N-10], 10);
} else {
next = next_state(d, N);
}
if (next < 0)
printf("ERROR!\n");
else {
print_binary(next);
printf("\n");
}
}
return 0;
}
static inline int print_value(FILE *fd, int type, struct rtattr *rta)
{
if (rta == NULL) {
fprintf(stderr, "Missing value TLV\n");
return -1;
}
switch(type) {
case TCF_META_TYPE_INT:
if (RTA_PAYLOAD(rta) < sizeof(__u32)) {
fprintf(stderr, "meta int type value TLV " \
"size mismatch.\n");
return -1;
}
fprintf(fd, "%d", rta_getattr_u32(rta));
break;
case TCF_META_TYPE_VAR:
print_binary(fd, RTA_DATA(rta), RTA_PAYLOAD(rta));
break;
}
return 0;
}
static int fingerprint_test_vector()
{
pj_pool_t *pool;
pj_status_t status;
unsigned i;
int rc = 0;
/* To avoid function not referenced warnings */
(void)create_msgint2;
(void)create_msgint3;
PJ_LOG(3,(THIS_FILE, " draft-denis-behave-rfc3489bis-test-vectors-02"));
pool = pj_pool_create(mem, "fingerprint", 1024, 1024, NULL);
for (i=0; i<PJ_ARRAY_SIZE(test_vectors); ++i) {
struct test_vector *v;
pj_stun_msg *ref_msg, *msg;
pj_size_t parsed_len;
pj_size_t len;
unsigned pos;
pj_uint8_t buf[1500];
char print[1500];
pj_str_t key;
PJ_LOG(3,(THIS_FILE, " Running test %d/%d", i,
PJ_ARRAY_SIZE(test_vectors)));
v = &test_vectors[i];
/* Print reference message */
PJ_LOG(4,(THIS_FILE, "Reference message PDU:\n%s",
print_binary((pj_uint8_t*)v->pdu, v->pdu_len)));
/* Try to parse the reference message first */
status = pj_stun_msg_decode(pool, (pj_uint8_t*)v->pdu, v->pdu_len,
PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET,
&ref_msg, &parsed_len, NULL);
if (status != PJ_SUCCESS) {
PJ_LOG(1,(THIS_FILE, " Error decoding reference message"));
rc = -1010;
goto on_return;
}
if (parsed_len != v->pdu_len) {
PJ_LOG(1,(THIS_FILE, " Parsed len error"));
rc = -1020;
goto on_return;
}
/* Print the reference message */
pj_stun_msg_dump(ref_msg, print, sizeof(print), NULL);
PJ_LOG(4,(THIS_FILE, "Reference message:\n%s", print));
/* Create our message */
msg = v->create(pool, v);
if (msg == NULL) {
PJ_LOG(1,(THIS_FILE, " Error creating stun message"));
rc = -1030;
goto on_return;
}
/* Encode message */
if (v->options & USE_MESSAGE_INTEGRITY) {
pj_str_t s1, s2, r;
pj_stun_create_key(pool, &key, pj_cstr(&r, v->realm),
pj_cstr(&s1, v->username),
PJ_STUN_PASSWD_PLAIN,
pj_cstr(&s2, v->password));
pj_stun_msg_encode(msg, buf, sizeof(buf), 0, &key, &len);
} else {
pj_stun_msg_encode(msg, buf, sizeof(buf), 0, NULL, &len);
}
/* Print our raw message */
PJ_LOG(4,(THIS_FILE, "Message PDU:\n%s",
print_binary((pj_uint8_t*)buf, len)));
/* Print our message */
pj_stun_msg_dump(msg, print, sizeof(print), NULL);
PJ_LOG(4,(THIS_FILE, "Message is:\n%s", print));
/* Compare message length */
if (len != v->pdu_len) {
PJ_LOG(1,(THIS_FILE, " Message length mismatch"));
rc = -1050;
goto on_return;
}
pos = cmp_buf(buf, (const pj_uint8_t*)v->pdu, len);
if (pos != (unsigned)-1) {
PJ_LOG(1,(THIS_FILE, " Message mismatch at byte %d", pos));
rc = -1060;
goto on_return;
}
/* Authenticate the request/response */
if (v->options & USE_MESSAGE_INTEGRITY) {
if (PJ_STUN_IS_REQUEST(msg->hdr.type)) {
pj_stun_auth_cred cred;
pj_status_t status;
pj_bzero(&cred, sizeof(cred));
cred.type = PJ_STUN_AUTH_CRED_STATIC;
cred.data.static_cred.realm = pj_str(v->realm);
cred.data.static_cred.username = pj_str(v->username);
cred.data.static_cred.data = pj_str(v->password);
cred.data.static_cred.nonce = pj_str(v->nonce);
status = pj_stun_authenticate_request(buf, len, msg,
&cred, pool, NULL, NULL);
if (status != PJ_SUCCESS) {
char errmsg[PJ_ERR_MSG_SIZE];
pj_strerror(status, errmsg, sizeof(errmsg));
PJ_LOG(1,(THIS_FILE,
" Request authentication failed: %s",
errmsg));
rc = -1070;
goto on_return;
}
} else if (PJ_STUN_IS_RESPONSE(msg->hdr.type)) {
pj_status_t status;
status = pj_stun_authenticate_response(buf, len, msg, &key);
if (status != PJ_SUCCESS) {
char errmsg[PJ_ERR_MSG_SIZE];
pj_strerror(status, errmsg, sizeof(errmsg));
PJ_LOG(1,(THIS_FILE,
" Response authentication failed: %s",
errmsg));
rc = -1080;
goto on_return;
}
}
}
}
on_return:
pj_pool_release(pool);
return rc;
}
