def test_prf_without_primary(self, key_template_name, lang):
"""Unsets the primary key and tries to use a PRF set primitive."""
template = supported_key_types.KEY_TEMPLATE[key_template_name]
keyset = testing_servers.new_keyset(lang, template)
_ = testing_servers.prf_set(lang, keyset).primary().compute(b'foo', 16)
prf_set_without_primary = testing_servers.prf_set(
lang, unset_primary(keyset))
with self.assertRaises(tink.TinkError):
_ = prf_set_without_primary.primary().compute(b'foo', 16)
def test_inc_version_prf(self, key_template_name, lang):
"""Increments the key version by one and checks they can't be used."""
template = supported_key_types.KEY_TEMPLATE[key_template_name]
keyset = testing_servers.new_keyset(lang, template)
_ = testing_servers.prf_set(lang, keyset).primary().compute(b'foo', 16)
for keyset1 in gen_inc_versions(keyset):
prf_set_primitive = testing_servers.prf_set(lang, keyset1)
with self.assertRaises(tink.TinkError):
_ = prf_set_primitive.primary().compute(b'foo', 16)
def test_unsupported(self, key_template_name, supported_langs):
self.assertNotEmpty(supported_langs)
keyset = gen_keyset(key_template_name)
unsupported_languages = [
lang for lang in SUPPORTED_LANGUAGES if lang not in supported_langs
]
for lang in unsupported_languages:
p = testing_servers.prf_set(lang, keyset)
with self.assertRaises(tink.TinkError):
p.primary().compute(b'input_data', output_length=16)
def test_prf(self, lang):
keyset = testing_servers.new_keyset(lang,
prf.prf_key_templates.HMAC_SHA256)
input_data = b'The quick brown fox jumps over the lazy dog'
prf_set_primitive = testing_servers.prf_set(lang, keyset)
output = prf_set_primitive.primary().compute(input_data, output_length=15)
self.assertLen(output, 15)
with self.assertRaises(tink.TinkError):
prf_set_primitive.primary().compute(input_data, output_length=123456)
def test_supported(self, key_template_name, supported_langs):
self.assertNotEmpty(supported_langs)
keyset = gen_keyset(key_template_name)
input_data = b'This is some input data.'
outputs = []
for lang in supported_langs:
p = testing_servers.prf_set(lang, keyset)
outputs.append(p.primary().compute(input_data, 16))
self.assertLen(outputs, len(supported_langs))
self.assertLen(outputs[0], 16)
self.assertLen(set(outputs), 1)
def test_multiple_prfs(self, lang):
keyset = gen_keyset_with_2_prfs()
input_data = b'This is some input data.'
output_length = 15
p = testing_servers.prf_set(lang, keyset)
primary_output = p.primary().compute(input_data, output_length)
primary_id = p.primary_id()
all_outputs = {
key_id: f.compute(input_data, output_length)
for key_id, f in p.all().items()
}
self.assertLen(all_outputs, 2)
self.assertEqual(all_outputs[primary_id], primary_output)
def test_supported(self, key_template_name):
supported_langs = supported_key_types.SUPPORTED_LANGUAGES_BY_TEMPLATE_NAME[
key_template_name]
self.assertNotEmpty(supported_langs)
keyset = gen_keyset(key_template_name)
input_data = b'This is some input data.'
outputs = []
for lang in supported_langs:
p = testing_servers.prf_set(lang, keyset)
outputs.append(p.primary().compute(input_data, 16))
self.assertLen(outputs, len(supported_langs))
self.assertLen(outputs[0], 16)
self.assertLen(set(outputs), 1)
def test_unsupported(self, key_template_name):
supported_langs = supported_key_types.SUPPORTED_LANGUAGES_BY_TEMPLATE_NAME[
key_template_name]
self.assertNotEmpty(supported_langs)
keyset = gen_keyset(key_template_name)
unsupported_languages = [
lang for lang in SUPPORTED_LANGUAGES if lang not in supported_langs
]
for lang in unsupported_languages:
p = testing_servers.prf_set(lang, keyset)
with self.assertRaises(
tink.TinkError,
msg='Language %s supports PRF compute with %s unexpectedly'
% (p.lang, key_template_name)):
p.primary().compute(b'input_data', output_length=16)
def test_compute_consistent_for_output_length(self, key_template_name,
output_length,
supported_langs):
# This test checks that for a given output_length, either all
# implementations fail or all produce the same value.
self.assertNotEmpty(supported_langs)
keyset = gen_keyset(key_template_name)
input_data = b'This is some input data.'
errors = {}
outputs = {}
for lang in supported_langs:
try:
p = testing_servers.prf_set(lang, keyset)
outputs[lang] = p.primary().compute(input_data, output_length)
except tink.TinkError as e:
errors[lang] = e
inconsistent_errors = bool(errors) and bool(outputs)
inconsistent_output_values = len(set(outputs.values())) > 1
if inconsistent_errors or inconsistent_output_values:
self.fail(
'The PRF for template %s and output_length=%d is inconsistent: '
'outputs = %s, errors = %s.' %
(key_template_name, output_length, outputs, errors))
