Exemple #1
0
static CK_OBJECT_HANDLE
find_anchor (CK_FUNCTION_LIST *module,
             CK_SESSION_HANDLE session,
             CK_ATTRIBUTE *attrs)
{
	CK_OBJECT_HANDLE object = 0UL;
	CK_ATTRIBUTE *attr;
	p11_kit_iter *iter;

	attr = p11_attrs_find_valid (attrs, CKA_CLASS);
	return_val_if_fail (attr != NULL, 0);

	iter = p11_kit_iter_new (NULL, 0);
	return_val_if_fail (iter != NULL, 0);

	if (iter_match_anchor (iter, attrs)) {
		p11_kit_iter_begin_with (iter, module, 0, session);
		if (p11_kit_iter_next (iter) == CKR_OK)
			object = p11_kit_iter_get_object (iter);
	}

	p11_kit_iter_free (iter);

	return object;
}
Exemple #2
0
		{ CKA_TRUST_SERVER_AUTH, },
		{ CKA_TRUST_EMAIL_PROTECTION, },
		{ CKA_TRUST_CODE_SIGNING, },
		{ CKA_TRUST_STEP_UP_APPROVED, },
		{ CKA_INVALID, }
	};

	CK_ULONG count = p11_attrs_count (template);

	module = p11_kit_module_load (path, 0);
	return_val_if_fail (module != NULL, 1);

	rv = p11_kit_module_initialize (module);
	return_val_if_fail (rv == CKR_OK, 1);

	iter = p11_kit_iter_new (NULL, 0);
	p11_kit_iter_add_filter (iter, &match, 1);
	p11_kit_iter_begin_with (iter, module, 0, 0);

	while ((rv = p11_kit_iter_next (iter)) == CKR_OK) {
		attrs = p11_attrs_dup (template);
		rv = p11_kit_iter_load_attributes (iter, attrs, count);
		return_val_if_fail (rv == CKR_OK || rv == CKR_ATTRIBUTE_VALUE_INVALID, 1);
		p11_attrs_purge (attrs);
		dump_object (iter, attrs);
		p11_attrs_free (attrs);
	}

	return_val_if_fail (rv == CKR_CANCEL, 1);

	p11_kit_module_finalize (module);
Exemple #3
0
static p11_array *
uris_or_files_to_iters (int argc,
                        char *argv[],
                        int behavior)
{
	int flags = P11_KIT_URI_FOR_OBJECT_ON_TOKEN_AND_MODULE;
	p11_parser *parser = NULL;
	p11_array *iters;
	p11_array *parsed;
	p11_kit_uri *uri;
	p11_kit_iter *iter;
	int ret;
	int i, j;

	iters = p11_array_new ((p11_destroyer)p11_kit_iter_free);
	return_val_if_fail (iters != NULL, NULL);

	for (i = 0; i < argc; i++) {

		/* A PKCS#11 URI */
		if (strncmp (argv[i], "pkcs11:", 7) == 0) {
			uri = p11_kit_uri_new ();
			if (p11_kit_uri_parse (argv[i], flags, uri) != P11_KIT_URI_OK) {
				p11_message ("invalid PKCS#11 uri: %s", argv[i]);
				p11_kit_uri_free (uri);
				break;
			}

			iter = p11_kit_iter_new (uri, behavior);
			return_val_if_fail (iter != NULL, NULL);
			p11_kit_uri_free (uri);

			if (!p11_array_push (iters, iter))
				return_val_if_reached (NULL);

		} else {
			if (parser == NULL)
				parser = create_arg_file_parser ();

			ret = p11_parse_file (parser, argv[i], NULL, P11_PARSE_FLAG_ANCHOR);
			switch (ret) {
			case P11_PARSE_SUCCESS:
				p11_debug ("parsed file: %s", argv[i]);
				break;
			case P11_PARSE_UNRECOGNIZED:
				p11_message ("unrecognized file format: %s", argv[i]);
				break;
			default:
				p11_message ("failed to parse file: %s", argv[i]);
				break;
			}

			if (ret != P11_PARSE_SUCCESS)
				break;

			parsed = p11_parser_parsed (parser);
			for (j = 0; j < parsed->num; j++) {
				iter = p11_kit_iter_new (NULL, behavior);
				return_val_if_fail (iter != NULL, NULL);

				iter_match_anchor (iter, parsed->elem[j]);
				if (!p11_array_push (iters, iter))
					return_val_if_reached (NULL);
			}
		}
	}

	if (parser)
		p11_parser_free (parser);

	if (argc != i) {
		p11_array_free (iters);
		return NULL;
	}

	return iters;
}