Пример #1
0
/**
 * Invokes an UPDATE message containing an anchor element as a hook to
 * next hash structure to be used when the active one depletes
 *
 * @param   entry the sadb entry for the outbound direction
 * @param   anchors the anchor elements to be sent
 * @param   hash_item_length length of the respective hash item
 * @param   soft_update indicates if HHL-based updates should be used
 * @param   anchor_offset the offset of the anchor element in the link tree
 * @param   link_trees the link trees for the anchor elements, in case of HHL
 * @return  0 on success, -1 on error
 */
int send_trigger_update_to_hipd(const struct hip_sa_entry *entry,
                                const unsigned char *anchors[MAX_NUM_PARALLEL_HCHAINS],
                                const int hash_item_length,
                                const int soft_update,
                                const int *anchor_offset,
                                struct hash_tree *link_trees[MAX_NUM_PARALLEL_HCHAINS])
{
    int                  err           = 0;
    int                  i             = 0;
    struct hip_common   *msg           = NULL;
    int                  hash_length   = 0;
    struct hash_chain   *hchain        = NULL;
    struct hash_tree    *htree         = NULL;
    struct hash_tree    *link_tree     = NULL;
    int                  secret_length = 0;
    int                  branch_length = 0;
    int                  root_length   = 0;
    const unsigned char *secret        = NULL;
    unsigned char       *branch_nodes  = NULL;
    const unsigned char *root          = NULL;

    HIP_ASSERT(entry != NULL);

    HIP_IFEL((hash_length = esp_prot_get_hash_length(entry->esp_prot_transform)) <= 0,
             -1, "error or tried to resolve UNUSED transform\n");

    HIP_IFEL(!(msg = malloc(HIP_MAX_PACKET)), -1,
             "failed to allocate memory\n");

    hip_msg_init(msg);

    HIP_IFEL(hip_build_user_hdr(msg, HIP_MSG_TRIGGER_UPDATE, 0), -1,
             "build hdr failed\n");

    HIP_DEBUG_HIT("src_hit", &entry->inner_src_addr);
    HIP_IFEL(hip_build_param_contents(msg, &entry->inner_src_addr,
                                      HIP_PARAM_HIT, sizeof(struct in6_addr)),
             -1, "build param contents failed\n");

    HIP_DEBUG_HIT("dst_hit", &entry->inner_dst_addr);
    HIP_IFEL(hip_build_param_contents(msg, &entry->inner_dst_addr,
                                      HIP_PARAM_HIT, sizeof(struct in6_addr)),
             -1, "build param contents failed\n");

    HIP_DEBUG("esp_prot_transform: %u\n", entry->esp_prot_transform);
    HIP_IFEL(hip_build_param_contents(msg, &entry->esp_prot_transform,
                                      HIP_PARAM_ESP_PROT_TFM, sizeof(uint8_t)),
             -1, "build param contents failed\n");

    // also send the hchain/htree length for all update items
    HIP_IFEL(hip_build_param_contents(msg, &hash_item_length, HIP_PARAM_INT,
                                      sizeof(int)), -1, "build param contents failed\n");
    HIP_DEBUG("added hash_item_length: %i\n", hash_item_length);

    HIP_DEBUG("num_parallel_hchains: %u\n", num_parallel_hchains);
    HIP_IFEL(hip_build_param_contents(msg, &num_parallel_hchains,
                                      HIP_PARAM_INT, sizeof(long)), -1,
             "build param contents failed\n");

    // add update anchors
    for (i = 0; i < num_parallel_hchains; i++) {
        HIP_HEXDUMP("anchor: ", anchors[i], hash_length);
        HIP_IFEL(hip_build_param_contents(msg, anchors[i],
                                          HIP_PARAM_HCHAIN_ANCHOR,
                                          hash_length), -1,
                 "build param contents failed\n");
    }

    // now transmit root for each next hash item for tree-based updates, if available
    for (i = 0; i < num_parallel_hchains; i++) {
        if (entry->esp_prot_transform == ESP_PROT_TFM_TREE) {
            htree     = entry->next_hash_items[i];
            link_tree = htree->link_tree;
        } else {
            hchain    = entry->next_hash_items[i];
            link_tree = hchain->link_tree;
        }

        if (link_tree) {
            /* if the next_hchain has got a link_tree, we need its root for
             * the verification of the next_hchain's elements */
            root = htree_get_root(link_tree, &root_length);
        }

        // only transmit root length once
        if (i == 0) {
            HIP_DEBUG("root_length: %i\n", root_length);
            HIP_IFEL(hip_build_param_contents(msg, &root_length,
                                              HIP_PARAM_INT,
                                              sizeof(int)), -1,
                     "build param contents failed\n");
        }

        if (root) {
            HIP_HEXDUMP("root: ", root, root_length);
            HIP_IFEL(hip_build_param_contents(msg, root,
                                              HIP_PARAM_ROOT, root_length), -1,
                     "build param contents failed\n");
        }
    }

    HIP_DEBUG("soft_update: %i\n", soft_update);
    HIP_IFEL(hip_build_param_contents(msg, &soft_update, HIP_PARAM_INT,
                                      sizeof(int)), -1,
             "build param contents failed\n");

    if (soft_update) {
        for (i = 0; i < num_parallel_hchains; i++) {
            secret = htree_get_secret(link_trees[i],
                                      anchor_offset[i], &secret_length);
            HIP_IFEL(!(branch_nodes = htree_get_branch(link_trees[i],
                                                       anchor_offset[i], NULL,
                                                       &branch_length)), -1,
                     "failed to get branch nodes\n");

            HIP_DEBUG("anchor_offset: %i\n", anchor_offset[i]);
            HIP_IFEL(hip_build_param_contents(msg, &anchor_offset[i],
                                              HIP_PARAM_INT,
                                              sizeof(int)), -1,
                     "build param contents failed\n");

            HIP_DEBUG("secret_length: %i\n", secret_length);
            HIP_IFEL(hip_build_param_contents(msg, &secret_length,
                                              HIP_PARAM_INT,
                                              sizeof(int)), -1,
                     "build param contents failed\n");

            HIP_DEBUG("branch_length: %i\n", branch_length);
            HIP_IFEL(hip_build_param_contents(msg, &branch_length,
                                              HIP_PARAM_INT,
                                              sizeof(int)), -1,
                     "build param contents failed\n");

            HIP_HEXDUMP("secret: ", secret, secret_length);
            HIP_IFEL(hip_build_param_contents(msg, secret,
                                              HIP_PARAM_SECRET,
                                              secret_length), -1,
                     "build param contents failed\n");

            HIP_HEXDUMP("branch_nodes: ", branch_nodes, branch_length);
            HIP_IFEL(hip_build_param_contents(msg, branch_nodes,
                                              HIP_PARAM_BRANCH_NODES,
                                              branch_length), -1,
                     "build param contents failed\n");
        }
    }

    HIP_DUMP_MSG(msg);

    /* send msg to hipd and receive corresponding reply */
    HIP_IFEL(hip_send_recv_daemon_info(msg, 1, hip_fw_sock), -1,
             "send_recv msg failed\n");

    /* check error value */
    HIP_IFEL(hip_get_msg_err(msg), -1, "hipd returned error message!\n");

    HIP_DEBUG("send_recv msg succeeded\n");

out_err:
    free(msg);
    free(branch_nodes);
    return err;
}
Пример #2
0
int main(int argc, char ** argv)
{
	int i;
	char c;
	int err = 0;
	struct timeval start_time;
	struct timeval stop_time;
	hash_chain_t *hchain = NULL;
	hash_tree_t *htree = NULL;
	statistics_data_t creation_stats;
	statistics_data_t verify_stats;
	uint64_t timediff = 0;
	uint32_t num_items = 0;
	double min = 0.0, max = 0.0, avg = 0.0;
	double std_dev = 0.0;
	unsigned char *branch_nodes = NULL;
	int branch_length = 0;
	unsigned char *secret = NULL;
	int secret_length = 0;
	hash_chain_t *hchains[8];
	unsigned char *data = NULL;
	int data_length = 0;
	unsigned char *root = NULL;
	int root_length = 0;

	hash_function = NULL;


	while ((c=getopt(argc, argv, "ctsml:h:v:n:")) != -1)
	{
		switch (c)
		{
			case 'c':
				test_hc = 1;
				break;
			case 't':
				test_ht = 1;
				break;
			case 's':
				hash_function = hash_functions[0];
				break;
			case 'm':
				hash_function = hash_functions[1];
				break;
			case 'l':
				hchain_length = atoi(optarg);
				break;
			case 'h':
				hash_length = atoi(optarg);
				break;
			case 'v':
				verify_length = atoi(optarg);
				break;
			case 'n':
				count = atoi(optarg);
				break;
			case ':':
				printf("Missing argument %c\n", optopt);
				print_usage();
				exit(1);
			case '?':
				printf("Unknown option %c\n", optopt);
				print_usage();
				exit(1);
		}
	}

	if (hash_function == NULL)
	{
		printf("no hash function selected!\n");
		print_usage();
		exit(1);
	}

	hip_set_logdebug(LOGDEBUG_NONE);

	memset(&creation_stats, 0, sizeof(statistics_data_t));
	memset(&verify_stats, 0, sizeof(statistics_data_t));

	print_timeres();

	if (test_hc)
	{
		printf(	"-------------------------------\n"
			"Hash chain performance test\n"
			"-------------------------------\n\n");

		printf("Creating %d hash chains of length %d with element length %d\n",
				count, hchain_length, hash_length);

		for(i = 0; i < count; i++)
		{
			gettimeofday(&start_time, NULL);
			if (hchain = hchain_create(hash_function, hash_length, hchain_length, 0,
					NULL))
			{
				gettimeofday(&stop_time, NULL);
				timediff = calc_timeval_diff(&start_time, &stop_time);
				add_statistics_item(&creation_stats, timediff);
				hchain_free(hchain);
			} else
			{
				printf("ERROR creating hchain!\n");
				exit(1);
			}
		}

		calc_statistics(&creation_stats, &num_items, &min, &max, &avg, &std_dev,
				STATS_IN_MSECS);
		printf("creation statistics - num_data_items: %u, min: %.3fms, max: %.3fms, avg: %.3fms, std_dev: %.3fms\n",
					num_items, min, max, avg, std_dev);

		printf("\n");

		printf("Verifying %d hash chains of length %d with element length %d\n",
				count, verify_length, hash_length);

		for(i = 0; i < count; i++)
		{
			if (!(hchain = hchain_create(hash_function, hash_length, verify_length, 0,
					NULL)))
			{
				printf("ERROR creating hchain!");
				exit(1);
			}

			gettimeofday(&start_time, NULL);
			if(hchain_verify(hchain_get_seed(hchain), hchain_get_anchor(hchain),
					hash_function, hash_length, verify_length, NULL, 0))
			{
				gettimeofday(&stop_time, NULL);
				timediff = calc_timeval_diff(&start_time, &stop_time);
				add_statistics_item(&verify_stats, timediff);
				hchain_free(hchain);
			} else
			{
				printf("ERROR verifying hchain!\n");
				exit(1);
			}
		}

		calc_statistics(&verify_stats, &num_items, &min, &max, &avg, &std_dev,
				STATS_IN_MSECS);
		printf("verification statistics - num_data_items: %u, min: %.3fms, max: %.3fms, avg: %.3fms, std_dev: %.3fms\n",
					num_items, min, max, avg, std_dev);
	}

	if (test_ht)
	{
		printf(	"\n-------------------------------\n"
			"Hash tree performance test\n"
			"-------------------------------\n\n");

		memset(&creation_stats, 0, sizeof(statistics_data_t));
		memset(&verify_stats, 0, sizeof(statistics_data_t));

		printf("Creating %d hash trees of length %d with element length %d\n",
				count, hchain_length, hash_length);

		for(i = 0; i < count; i++)
		{
			HIP_DEBUG("number of leaves: %i\n", hchain_length);
			HIP_DEBUG("hash_length: %i\n", hash_length);
			HIP_DEBUG("data_length: %i\n", hash_length);

			gettimeofday(&start_time, NULL);
			htree = htree_init(hchain_length, hash_length, hash_length, 0, NULL, 0);
			htree_add_random_data(htree, hchain_length);
			htree_calc_nodes(htree, htree_leaf_generator, htree_node_generator, NULL);
			gettimeofday(&stop_time, NULL);
			timediff = calc_timeval_diff(&start_time, &stop_time);
			add_statistics_item(&creation_stats, timediff);

			htree_free(htree);
		}

		calc_statistics(&creation_stats, &num_items, &min, &max, &avg, &std_dev,
				STATS_IN_MSECS);
		printf("creation statistics - num_data_items: %u, min: %.3fms, max: %.3fms, avg: %.3fms, std_dev: %.3fms\n",
					num_items, min, max, avg, std_dev);

		for(i = 0; i < count; i++)
		{
			htree = htree_init(hchain_length, hash_length, hash_length, hash_length, NULL, 0);
			htree_add_random_data(htree, hchain_length);
			htree_add_random_secrets(htree);
			htree_calc_nodes(htree, htree_leaf_generator, htree_node_generator, NULL);

			root = htree_get_root(htree, &root_length);
			branch_nodes = htree_get_branch(htree, i, NULL, &branch_length);
			data = htree_get_data(htree, i, &data_length);
			secret = htree_get_secret(htree, i, &secret_length);

			gettimeofday(&start_time, NULL);
			if (!htree_verify_branch(root, root_length,
					branch_nodes, branch_length,
					data, data_length, i,
					secret, secret_length,
					htree_leaf_generator, htree_node_generator, NULL))
			{
				gettimeofday(&stop_time, NULL);
				timediff = calc_timeval_diff(&start_time, &stop_time);
				add_statistics_item(&verify_stats, timediff);

				HIP_DEBUG("branch verified\n");

			} else
			{
				printf("ERROR verifying htree!\n");
				exit(1);
			}

			htree_free(htree);
		}

		calc_statistics(&verify_stats, &num_items, &min, &max, &avg, &std_dev,
				STATS_IN_MSECS);
		printf("verification statistics - num_data_items: %u, min: %.3fms, max: %.3fms, avg: %.3fms, std_dev: %.3fms\n",
					num_items, min, max, avg, std_dev);



		printf("\n\ntrying out hchain linking...\n");

		// simulate level 0 creation
		htree = htree_init(8, hash_length, hash_length, hash_length, NULL, 0);
		htree_add_random_secrets(htree);

		for (i = 0; i < 8; i++)
		{
			hchains[i] = hchain_create(hash_function, hash_length, hchain_length, 0,
								NULL);
			htree_add_data(htree, hchain_get_anchor(hchains[i]), hash_length);
		}

		htree_calc_nodes(htree, htree_leaf_generator, htree_node_generator, NULL);

		// simulate level 1 creation
		hchain = hchain_create(hash_function, hash_length, hchain_length, 1,
				htree);

		// simulate BEX
		// get hchain anchor
		root = htree_get_root(htree, &root_length);

		// simulate level 1 hchain verification
		if(!hchain_verify(hchain_get_seed(hchain), hchain_get_anchor(hchain),
				hash_function, hash_length, verify_length, root, root_length))
		{
			printf("hchain level 1 verfied\n");

		} else
		{
			printf("ERROR verifying hchain level 1!\n");
			exit(1);
		}

		// simulate update
		branch_nodes = htree_get_branch(htree, 0, NULL, &branch_length);
		secret = htree_get_secret(htree, 0, &secret_length);
		data = htree_get_data(htree, 0, &data_length);

		if (!htree_verify_branch(root, root_length,
				branch_nodes, branch_length,
				data, data_length, i,
				secret, secret_length,
				htree_leaf_generator, htree_node_generator, NULL))
		{
			printf("anchor verified\n");

		} else
		{
			printf("ERROR verifying anchor!\n");
			exit(1);
		}

		if (!memcmp(data, hchain_get_anchor(hchains[0]), hash_length))
		{
			printf("yes, this is the anchor we verified!\n");
		} else
		{
			printf("ERROR no this is not the anchor we verified!\n");
			exit(1);
		}
		hchain_free(hchain);

		// simulate level 0 hchain verification
		if(!hchain_verify(hchain_get_seed(hchains[0]), data,
				hash_function, hash_length, verify_length, NULL, 0))
		{
			printf("hchain level 0 verfied\n");

		} else
		{
			printf("ERROR verifying hchain level 0!\n");
			exit(1);
		}
	}
}