def build_pack(metadata):
asset = os.path.join(os.path.dirname(__file__),
"./assets/pack.zip.enc")
with open(asset, "rb") as f:
zip = crypto.decode(bytes.fromhex(Utils.ZIP_PASSWORD), f.read())
password = bytes.fromhex(Utils.ZIP_PASSWORD)
return crypto.encode(password, zip, metadata.encode())
def crypt_file_main():
parser = argparse.ArgumentParser(
description="(De)Crypt a file according to a given password"
)
parser.add_argument("-d", "--decrypt", action="store_true")
parser.add_argument("-m", "--metadata", help="metadata input file")
parser.add_argument("zip_password", help="hexified zip password")
parser.add_argument("input_file", help="input file", nargs="?", default="-")
parser.add_argument("output_file", help="output file", nargs="?", default="-")
args = parser.parse_args()
input_file = (
open(args.input_file, "rb") if args.input_file != "-" else sys.stdin.buffer
)
metadata_file = open(args.metadata, "rb") if args.metadata is not None else None
output_file = (
open(args.output_file, "wb") if args.output_file != "-" else sys.stdout.buffer
)
zip_password = bytes.fromhex(args.zip_password)
input_data = input_file.read()
if args.decrypt:
assert validate(input_data)
output_file.write(decode(zip_password, input_data))
else:
metadata_in = metadata_file.read() if metadata_file is not None else b""
output_file.write(encode(zip_password, input_data, metadata_in))
def test_encode_decode(self):
for version in range(len(crypto.pack_versions)):
with self.subTest():
password = b"fooobarr"
data = b"#bellavita"
encrypted = crypto.encode(password, data, b"", version=version)
self.assertEqual(data, crypto.decode(password, encrypted))
def crypt_file_main():
parser = argparse.ArgumentParser(
description='(De)Crypt a file according to a given password')
parser.add_argument('-d', '--decrypt', action='store_true')
parser.add_argument('-m', '--metadata', help='metadata input file')
parser.add_argument('zip_password', help='hexified zip password')
parser.add_argument('input_file',
help='input file',
nargs='?',
default='-')
parser.add_argument('output_file',
help='output file',
nargs='?',
default='-')
args = parser.parse_args()
input_file = open(args.input_file,
'rb') if args.input_file != '-' else sys.stdin.buffer
metadata_file = open(args.metadata,
'rb') if args.metadata is not None else None
output_file = open(args.output_file,
'wb') if args.output_file != '-' else sys.stdout.buffer
zip_password = bytes.fromhex(args.zip_password)
input_data = input_file.read()
if args.decrypt:
assert validate(input_data)
output_file.write(decode(zip_password, input_data))
else:
metadata_in = metadata_file.read(
) if metadata_file is not None else b""
output_file.write(encode(zip_password, input_data, metadata_in))
def test_encode_metadata_too_long_version_bigger_than_0(self):
password = b"fooobarr"
data = b"#bellavita"
original_metadata = b"A" * 123456
pack = crypto.encode(password, data, original_metadata)
metadata = crypto.metadata(pack)
self.assertEqual(metadata, original_metadata)
def test_validate(self):
for version in range(len(crypto.pack_versions)):
with self.subTest():
password = b"fooobarr"
data = b"#bellavita"
encrypted = crypto.encode(password, data, b"metadata", version=version)
self.assertTrue(crypto.validate(encrypted))
def test_metadata(self):
for version in range(len(crypto.pack_versions)):
with self.subTest():
password = b"fooobarr"
data = b"#bellavita"
encrypted = crypto.encode(password, data, b"metadata", version=version)
metadata = crypto.metadata(encrypted)
self.assertEqual(metadata.strip(b"\x00"), b"metadata")
def test_pack_status(self):
pack = Utils.new_tmp_file()
Config.encrypted_file = pack
encrypted = crypto.encode(b"fooobarr", b"#bellavita", b"foo: bar")
with open(pack, "wb") as f:
f.write(encrypted)
status = self.admin_handler.pack_status()
self.assertTrue(status["uploaded"])
self.assertEqual(status["foo"], "bar")
def test_decode_unsupported_version(self):
password = b"fooobarr"
data = b"#bellavita"
version = len(crypto.pack_versions).to_bytes(1, "big")
pack = crypto.encode(password, data, b"")
offset = crypto.PackVersion.hash_len
pack = pack[:offset] + version + pack[offset + 1 :]
with self.assertRaises(ValueError):
crypto.decode(password, pack)
def test_read_metadata(self):
for version in range(len(crypto.pack_versions)):
with self.subTest():
password = b"fooobarr"
data = b"#bellavita"
encrypted = crypto.encode(password, data, b"metadata", version=version)
pack_file = Utils.new_tmp_file()
with open(pack_file, "wb") as f:
f.write(encrypted)
metadata = crypto.read_metadata(pack_file)
self.assertEqual(metadata.strip(b"\x00"), b"metadata")
def test_read_metadata_unsupported_version(self):
password = b"fooobarr"
data = b"#bellavita"
version = len(crypto.pack_versions).to_bytes(1, "big")
pack = crypto.encode(password, data, b"")
offset = crypto.PackVersion.hash_len
pack = pack[:offset] + version + pack[offset + 1 :]
pack_file = Utils.new_tmp_file()
with open(pack_file, "wb") as f:
f.write(pack)
with self.assertRaises(ValueError):
crypto.read_metadata(pack_file)
def test_extract_bad_zip(self):
self.tempdir = Utils.new_tmp_dir()
enc_path = os.path.join(self.tempdir, "pack.zip.enc")
dec_path = os.path.join(self.tempdir, "pack.zip")
Config.encrypted_file = enc_path
Config.decrypted_file = dec_path
with open(enc_path, "wb") as f:
invalid_zip = b"this is not a zip"
encrypted = crypto.encode(b"fooobar", invalid_zip, b"metadata")
f.write(encrypted)
password = crypto.gen_user_password("XXXXXX", b"YYY", b"fooobar")
with self.assertRaises(Forbidden) as e:
ContestManager.extract_contest(password)
def test_validate(self):
password = b"fooobarr"
data = b"#bellavita"
encrypted = crypto.encode(password, data, b"metadata")
self.assertTrue(crypto.validate(encrypted))
def test_metadata(self):
password = b"fooobarr"
data = b"#bellavita"
encrypted = crypto.encode(password, data, b"metadata")
metadata = crypto.metadata(encrypted)
self.assertEqual(metadata.strip(b"\x00"), b"metadata")
def test_encode_unsupported_version(self):
password = b"fooobarr"
data = b"#bellavita"
version = len(crypto.pack_versions)
with self.assertRaises(ValueError):
crypto.encode(password, data, b"", version=version)
def test_encode_decode(self):
password = b"fooobarr"
data = b"#bellavita"
encrypted = crypto.encode(password, data, b"")
self.assertEqual(data, crypto.decode(password, encrypted))
def test_validate_invalid(self):
password = b"fooobarr"
data = b"#bellavita"
encrypted = crypto.encode(password, data, b"metadata")
encrypted += b'('
self.assertFalse(crypto.validate(encrypted))
def test_encode_metadata_too_long_version0(self):
password = b"fooobarr"
data = b"#bellavita"
with self.assertRaises(ValueError):
crypto.encode(password, data, b"A" * 1025, version=0)