def test_encryption_of_multiple_keys_to_files():
"Encrypt bytes to a file using multiple keys"
output = "/tmp/multiple-enc.asc"
if os.path.exists(output):
os.remove(output)
certs = []
for keyfilename in [
"tests/files/public.asc", "tests/files/hellopublic.asc"
]:
certs.append(_get_cert_data(keyfilename))
jce.encrypt_bytes_to_file(
certs,
DATA.encode("utf-8"),
output.encode("utf-8"),
armor=True,
)
assert os.path.exists(output)
# Now let us decrypt it via first secret key
with open(output, "rb") as f:
enc = f.read()
jp = jce.Johnny(_get_cert_data("tests/files/hellosecret.asc"))
result = jp.decrypt_bytes(enc, "redhat")
assert DATA == result.decode("utf-8")
jp = jce.Johnny(_get_cert_data("tests/files/secret.asc"))
result = jp.decrypt_bytes(enc, "redhat")
assert DATA == result.decode("utf-8")
def test_encryption_of_multiple_keys_of_a_file():
"Encrypt bytes to a file using multiple keys"
inputfile = "tests/files/text.txt"
output = "/tmp/text-encrypted.pgp"
decrypted_output = "/tmp/text.txt"
clean_outputfiles(output, decrypted_output)
certs = []
for keyfilename in [
"tests/files/public.asc", "tests/files/hellopublic.asc"
]:
certs.append(_get_cert_data(keyfilename))
jce.encrypt_file_internal(
certs,
inputfile.encode("utf-8"),
output.encode("utf-8"),
armor=True,
)
assert os.path.exists(output)
# Now let us decrypt it via second secret key
jp = jce.Johnny(_get_cert_data("tests/files/hellosecret.asc"))
assert jp.decrypt_file(output.encode("utf-8"),
decrypted_output.encode("utf-8"), "redhat")
verify_files(inputfile, decrypted_output)
# Now remove it for next step
os.remove(decrypted_output)
# Via first secret key
jp = jce.Johnny(_get_cert_data("tests/files/secret.asc"))
assert jp.decrypt_file(output.encode("utf-8"),
decrypted_output.encode("utf-8"), "redhat")
verify_files(inputfile, decrypted_output)
def test_encrypt_decrypt_bytes():
"Tests raw bytes as output"
jp = jce.Johnny(_get_cert_data("tests/files/public.asc"))
enc = jp.encrypt_bytes(DATA.encode("utf-8"))
jp = jce.Johnny(_get_cert_data("tests/files/secret.asc"))
result = jp.decrypt_bytes(enc, "redhat")
assert DATA == result.decode("utf-8")
def test_verify_bytes_must_fail():
j = jce.Johnny(_get_cert_data("tests/files/secret.asc"))
signature = j.sign_bytes_detached(DATA.encode("utf-8"), "redhat")
jp = jce.Johnny(_get_cert_data("tests/files/public.asc"))
data2 = DATA + " "
assert not jp.verify_bytes(data2.encode("utf-8"),
signature.encode("utf-8"))
def test_encrypt_decrypt_bytes_armored():
"Tests ascii-armored output"
j = jce.Johnny(_get_cert_data("tests/files/public.asc"))
enc = j.encrypt_bytes(DATA.encode("utf-8"), armor=True)
assert enc.startswith(b"-----BEGIN PGP MESSAGE-----")
jp = jce.Johnny(_get_cert_data("tests/files/secret.asc"))
result = jp.decrypt_bytes(enc, "redhat")
assert DATA == result.decode("utf-8")
def test_encrypt_decrypt_files():
"Tests encrypt/decrypt file in binary format"
inputfile = "tests/files/text.txt"
output = "/tmp/text-encrypted.pgp"
decrypted_output = "/tmp/text.txt"
clean_outputfiles(output, decrypted_output)
# Now encrypt and then decrypt
j = jce.Johnny(_get_cert_data("tests/files/public.asc"))
assert j.encrypt_file(inputfile.encode("utf-8"), output.encode("utf-8"))
jp = jce.Johnny(_get_cert_data("tests/files/secret.asc"))
assert jp.decrypt_file(output.encode("utf-8"),
decrypted_output.encode("utf-8"), "redhat")
verify_files(inputfile, decrypted_output)
def test_encryption_of_multiple_keys_to_bytes():
"Encrypt bytes using multiple keys"
encrypted = jce.encrypt_bytes_to_bytes(
["tests/files/public.asc", "tests/files/hellopublic.asc"],
DATA.encode("utf-8"),
armor=True,
)
# Now let us decrypt it via first secret key
jp = jce.Johnny("tests/files/hellosecret.asc")
result = jp.decrypt_bytes(encrypted, "redhat")
assert DATA == result.decode("utf-8")
jp = jce.Johnny("tests/files/secret.asc")
result = jp.decrypt_bytes(encrypted, "redhat")
assert DATA == result.decode("utf-8")
def test_decrypt_multiple_recipient_data():
with open("tests/files/double_recipient.asc", "rb") as f:
data = f.read()
jp = jce.Johnny(_get_cert_data("tests/files/secret.asc"))
cleartext = jp.decrypt_bytes(data, "redhat")
assert cleartext == b"Hello World! for 2.\n"
def test_encrypt_decrypt_files_armored():
inputfile = "tests/files/text.txt"
output = "/tmp/text-encrypted.asc"
decrypted_output = "/tmp/text.txt"
clean_outputfiles(output, decrypted_output)
# Now encrypt and then decrypt
j = jce.Johnny("tests/files/public.asc")
assert j.encrypt_file(inputfile.encode("utf-8"), output.encode("utf-8"), armor=True)
jp = jce.Johnny("tests/files/secret.asc")
assert jp.decrypt_file(
output.encode("utf-8"), decrypted_output.encode("utf-8"), "redhat"
)
with open(output) as f:
line = f.readline().strip("\n")
assert line == "-----BEGIN PGP MESSAGE-----"
verify_files(inputfile, decrypted_output)
def test_encryption_of_multiple_keys_to_bytes():
"Encrypt bytes using multiple keys"
certs = []
for keyfilename in [
"tests/files/public.asc", "tests/files/hellopublic.asc"
]:
certs.append(_get_cert_data(keyfilename))
encrypted = jce.encrypt_bytes_to_bytes(
certs,
DATA.encode("utf-8"),
armor=True,
)
# Now let us decrypt it via first secret key
jp = jce.Johnny(_get_cert_data("tests/files/hellosecret.asc"))
result = jp.decrypt_bytes(encrypted, "redhat")
assert DATA == result.decode("utf-8")
jp = jce.Johnny(_get_cert_data("tests/files/secret.asc"))
result = jp.decrypt_bytes(encrypted, "redhat")
assert DATA == result.decode("utf-8")
def test_sign():
j = jce.Johnny(_get_cert_data("tests/files/secret.asc"))
signature = j.sign_bytes_detached(DATA.encode("utf-8"), "redhat")
assert signature
def test_sign_fail():
j = jce.Johnny(_get_cert_data("tests/files/public.asc"))
with pytest.raises(jce.CryptoError):
signature = j.sign_bytes_detached(DATA.encode("utf-8"), "redhat")
