Beispiel #1
0
def main(unused_argv):
    aead.register()
    daead.register()
    hybrid.register()
    mac.register()
    prf.register()
    signature.register()
    streaming_aead.register()
    jwt.register_jwt_mac()
    fake_kms.register_client()
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=2))
    testing_api_pb2_grpc.add_MetadataServicer_to_server(
        services.MetadataServicer(), server)
    testing_api_pb2_grpc.add_KeysetServicer_to_server(
        services.KeysetServicer(), server)
    testing_api_pb2_grpc.add_AeadServicer_to_server(services.AeadServicer(),
                                                    server)
    testing_api_pb2_grpc.add_DeterministicAeadServicer_to_server(
        services.DeterministicAeadServicer(), server)
    testing_api_pb2_grpc.add_MacServicer_to_server(services.MacServicer(),
                                                   server)
    testing_api_pb2_grpc.add_PrfSetServicer_to_server(
        services.PrfSetServicer(), server)
    testing_api_pb2_grpc.add_HybridServicer_to_server(
        services.HybridServicer(), server)
    testing_api_pb2_grpc.add_SignatureServicer_to_server(
        services.SignatureServicer(), server)
    testing_api_pb2_grpc.add_StreamingAeadServicer_to_server(
        services.StreamingAeadServicer(), server)
    testing_api_pb2_grpc.add_JwtServicer_to_server(jwt_service.JwtServicer(),
                                                   server)
    server.add_secure_port('[::]:%d' % FLAGS.port,
                           grpc.local_server_credentials())
    server.start()
    server.wait_for_termination()
Beispiel #2
0
    def test_generate_encrypt_decrypt_deterministically(self):
        keyset_servicer = services.KeysetServicer()
        daead_servicer = services.DeterministicAeadServicer()

        template_proto = daead.deterministic_aead_key_templates.AES256_SIV
        template = template_proto.SerializeToString()
        gen_request = testing_api_pb2.KeysetGenerateRequest(template=template)
        gen_response = keyset_servicer.Generate(gen_request, self._ctx)
        self.assertEqual(gen_response.WhichOneof('result'), 'keyset')
        keyset = gen_response.keyset
        plaintext = b'The quick brown fox jumps over the lazy dog'
        associated_data = b'associated_data'
        enc_request = testing_api_pb2.DeterministicAeadEncryptRequest(
            keyset=keyset,
            plaintext=plaintext,
            associated_data=associated_data)
        enc_response = daead_servicer.EncryptDeterministically(
            enc_request, self._ctx)
        self.assertEqual(enc_response.WhichOneof('result'), 'ciphertext')
        enc_response2 = daead_servicer.EncryptDeterministically(
            enc_request, self._ctx)
        self.assertEqual(enc_response2.WhichOneof('result'), 'ciphertext')
        self.assertEqual(enc_response2.ciphertext, enc_response.ciphertext)
        ciphertext = enc_response.ciphertext
        dec_request = testing_api_pb2.DeterministicAeadDecryptRequest(
            keyset=keyset,
            ciphertext=ciphertext,
            associated_data=associated_data)
        dec_response = daead_servicer.DecryptDeterministically(
            dec_request, self._ctx)
        self.assertEqual(dec_response.WhichOneof('result'), 'plaintext')
        self.assertEqual(dec_response.plaintext, plaintext)
  def test_generate_decrypt_deterministically_fail(self):
    keyset_servicer = services.KeysetServicer()
    daead_servicer = services.DeterministicAeadServicer()

    template_proto = daead.deterministic_aead_key_templates.AES256_SIV
    template = template_proto.SerializeToString()
    gen_request = testing_api_pb2.KeysetGenerateRequest(template=template)
    gen_response = keyset_servicer.Generate(gen_request, self._ctx)
    self.assertEqual(gen_response.WhichOneof('result'), 'keyset')
    keyset = gen_response.keyset

    ciphertext = b'some invalid ciphertext'
    associated_data = b'associated_data'
    dec_request = testing_api_pb2.DeterministicAeadDecryptRequest(
        keyset=keyset, ciphertext=ciphertext, associated_data=associated_data)
    dec_response = daead_servicer.DecryptDeterministically(dec_request,
                                                           self._ctx)
    self.assertEqual(dec_response.WhichOneof('result'), 'err')
    logging.info('Error in response: %s', dec_response.err)
    self.assertNotEmpty(dec_response.err)