def test_ccp_proof(
self,
keypair: ElGamalKeyPair,
nonce: ElementModQ,
seed: ElementModQ,
constant: int,
bad_constant: int,
):
# assume() slows down the test-case generation
# so assume(constant != bad_constant)
if constant == bad_constant:
bad_constant = constant + 1
message = get_optional(
elgamal_encrypt(constant, nonce, keypair.public_key))
message_bad = get_optional(
elgamal_encrypt(bad_constant, nonce, keypair.public_key))
proof = make_constant_chaum_pedersen(message, constant, nonce,
keypair.public_key, seed)
self.assertTrue(proof.is_valid(message, keypair.public_key))
proof_bad1 = make_constant_chaum_pedersen(message_bad, constant, nonce,
keypair.public_key, seed)
self.assertFalse(proof_bad1.is_valid(message_bad, keypair.public_key))
proof_bad2 = make_constant_chaum_pedersen(message, bad_constant, nonce,
keypair.public_key, seed)
self.assertFalse(proof_bad2.is_valid(message, keypair.public_key))
proof_bad3 = ConstantChaumPedersenProof(proof.a, proof.b, proof.c,
proof.v, -1)
self.assertFalse(proof_bad3.is_valid(message, keypair.public_key))
def test_encrypt_contest_valid_input_tampered_proof_fails(
self,
contest_description: ContestDescription,
keypair: ElGamalKeyPair,
nonce_seed: ElementModQ,
random_seed: int,
):
# Arrange
_, description = contest_description
random = Random(random_seed)
subject = ballot_factory.get_random_contest_from(description, random)
# Act
result = encrypt_contest(
subject, description, keypair.public_key, ONE_MOD_Q, nonce_seed
)
self.assertTrue(
result.is_valid_encryption(
description.crypto_hash(), keypair.public_key, ONE_MOD_Q
)
)
# tamper with the proof
malformed_proof = deepcopy(result)
altered_a = mult_p(result.proof.pad, TWO_MOD_P)
malformed_disjunctive = ConstantChaumPedersenProof(
altered_a,
malformed_proof.proof.data,
malformed_proof.proof.challenge,
malformed_proof.proof.response,
malformed_proof.proof.constant,
)
malformed_proof.proof = malformed_disjunctive
# remove the proof
missing_proof = deepcopy(result)
missing_proof.proof = None
# Assert
self.assertFalse(
malformed_proof.is_valid_encryption(
description.crypto_hash(), keypair.public_key, ONE_MOD_Q
)
)
self.assertFalse(
missing_proof.is_valid_encryption(
description.crypto_hash(), keypair.public_key, ONE_MOD_Q
)
)