Example #1
0
    def test_decrypt_wrong_associated_data_fails(self):
        primitive, key = self.new_primitive_key_pair(1234, tink_pb2.TINK)
        pset = core.new_primitive_set(aead.Aead)
        entry = pset.add_primitive(primitive, key)
        pset.set_primary(entry)
        wrapped_aead = aead.AeadWrapper().wrap(pset)

        ciphertext = wrapped_aead.encrypt(b'plaintext', b'associated_data')
        with self.assertRaisesRegex(core.TinkError, 'Decryption failed'):
            wrapped_aead.decrypt(ciphertext, b'wrong_associated_data')
Example #2
0
def _register_primitive_wrappers():
    """Registers all primitive wrappers."""
    register_primitive_wrapper = core.Registry.register_primitive_wrapper
    register_primitive_wrapper(aead.AeadWrapper())
    register_primitive_wrapper(daead.DeterministicAeadWrapper())
    register_primitive_wrapper(hybrid.HybridDecryptWrapper())
    register_primitive_wrapper(hybrid.HybridEncryptWrapper())
    register_primitive_wrapper(mac.MacWrapper())
    register_primitive_wrapper(signature.PublicKeySignWrapper())
    register_primitive_wrapper(signature.PublicKeyVerifyWrapper())
Example #3
0
    def test_encrypt_decrypt(self):
        primitive, key = self.new_primitive_key_pair(1234, tink_pb2.TINK)
        pset = core.new_primitive_set(aead.Aead)
        entry = pset.add_primitive(primitive, key)
        pset.set_primary(entry)

        wrapped_aead = aead.AeadWrapper().wrap(pset)

        plaintext = b'plaintext'
        associated_data = b'associated_data'
        ciphertext = wrapped_aead.encrypt(plaintext, associated_data)
        self.assertEqual(wrapped_aead.decrypt(ciphertext, associated_data),
                         plaintext)
Example #4
0
    def test_decrypt_unknown_ciphertext_fails(self):
        unknown_primitive = helper.FakeAead('unknownFakeAead')
        unknown_ciphertext = unknown_primitive.encrypt(b'plaintext',
                                                       b'associated_data')

        pset = core.new_primitive_set(aead.Aead)
        primitive, raw_key = self.new_primitive_key_pair(1234, tink_pb2.RAW)
        new_primitive, new_key = self.new_primitive_key_pair(
            5678, tink_pb2.TINK)
        pset.add_primitive(primitive, raw_key)
        new_entry = pset.add_primitive(new_primitive, new_key)
        pset.set_primary(new_entry)
        wrapped_aead = aead.AeadWrapper().wrap(pset)

        with self.assertRaisesRegex(core.TinkError, 'Decryption failed'):
            wrapped_aead.decrypt(unknown_ciphertext, b'associated_data')
Example #5
0
    def test_encrypt_decrypt_with_key_rotation(self):
        primitive, key = self.new_primitive_key_pair(1234, tink_pb2.TINK)
        pset = core.new_primitive_set(aead.Aead)
        entry = pset.add_primitive(primitive, key)
        pset.set_primary(entry)
        wrapped_aead = aead.AeadWrapper().wrap(pset)
        ciphertext = wrapped_aead.encrypt(b'plaintext', b'associated_data')

        new_primitive, new_key = self.new_primitive_key_pair(
            5678, tink_pb2.TINK)
        new_entry = pset.add_primitive(new_primitive, new_key)
        pset.set_primary(new_entry)
        new_ciphertext = wrapped_aead.encrypt(b'new_plaintext',
                                              b'new_associated_data')

        self.assertEqual(wrapped_aead.decrypt(ciphertext, b'associated_data'),
                         b'plaintext')
        self.assertEqual(
            wrapped_aead.decrypt(new_ciphertext, b'new_associated_data'),
            b'new_plaintext')
Example #6
0
    def test_encrypt_decrypt_two_raw_keys(self):
        primitive1, raw_key1 = self.new_primitive_key_pair(1234, tink_pb2.RAW)
        primitive2, raw_key2 = self.new_primitive_key_pair(5678, tink_pb2.RAW)
        raw_ciphertext1 = primitive1.encrypt(b'plaintext1',
                                             b'associated_data1')
        raw_ciphertext2 = primitive2.encrypt(b'plaintext2',
                                             b'associated_data2')

        pset = core.new_primitive_set(aead.Aead)
        pset.add_primitive(primitive1, raw_key1)
        pset.set_primary(pset.add_primitive(primitive2, raw_key2))
        wrapped_aead = aead.AeadWrapper().wrap(pset)

        self.assertEqual(
            wrapped_aead.decrypt(raw_ciphertext1, b'associated_data1'),
            b'plaintext1')
        self.assertEqual(
            wrapped_aead.decrypt(raw_ciphertext2, b'associated_data2'),
            b'plaintext2')
        self.assertEqual(
            wrapped_aead.decrypt(
                wrapped_aead.encrypt(b'plaintext', b'associated_data'),
                b'associated_data'), b'plaintext')