|
|
import argparse |
|
|
import base64 |
|
|
import hashlib |
|
|
import json |
|
|
from pathlib import Path |
|
|
from typing import Iterable, List, Optional |
|
|
|
|
|
|
|
|
def derive_key(password: str, length: int) -> bytes: |
|
|
hasher = hashlib.sha256() |
|
|
hasher.update(password.encode()) |
|
|
key = hasher.digest() |
|
|
return key * (length // len(key)) + key[: length % len(key)] |
|
|
|
|
|
|
|
|
def xor_decrypt(ciphertext_b64: str, password: str) -> str: |
|
|
if ciphertext_b64 is None: |
|
|
return ciphertext_b64 |
|
|
if not ciphertext_b64: |
|
|
return "" |
|
|
encrypted = base64.b64decode(ciphertext_b64) |
|
|
key = derive_key(password, len(encrypted)) |
|
|
decrypted = bytes(a ^ b for a, b in zip(encrypted, key)) |
|
|
return decrypted.decode("utf-8") |
|
|
|
|
|
|
|
|
def parse_fields(value: str) -> List[str]: |
|
|
return [item.strip() for item in value.split(",") if item.strip()] |
|
|
|
|
|
|
|
|
def iter_jsonl(path: Path) -> Iterable[dict]: |
|
|
with path.open("r", encoding="utf-8") as fh: |
|
|
for lineno, line in enumerate(fh, start=1): |
|
|
line = line.strip() |
|
|
if not line: |
|
|
continue |
|
|
try: |
|
|
yield json.loads(line) |
|
|
except json.JSONDecodeError as exc: |
|
|
raise ValueError(f"Invalid JSON on line {lineno}: {exc}") from exc |
|
|
|
|
|
|
|
|
def write_jsonl(path: Path, records: Iterable[dict]) -> None: |
|
|
with path.open("w", encoding="utf-8") as fh: |
|
|
for record in records: |
|
|
json.dump(record, fh, ensure_ascii=True, separators=(",", ":")) |
|
|
fh.write("\n") |
|
|
|
|
|
|
|
|
def decrypt_dataset( |
|
|
input_path: Path, |
|
|
output_path: Path, |
|
|
fields: List[str], |
|
|
canary_field: str, |
|
|
override_canary: Optional[str], |
|
|
drop_canary: bool, |
|
|
) -> None: |
|
|
decrypted_records = [] |
|
|
for record in iter_jsonl(input_path): |
|
|
token = override_canary if override_canary is not None else record.get(canary_field) |
|
|
if not token: |
|
|
raise ValueError( |
|
|
f"Missing canary token for record (id={record.get('id')}). " |
|
|
f"Set --canary-value if the column is absent." |
|
|
) |
|
|
|
|
|
for field in fields: |
|
|
if field not in record: |
|
|
continue |
|
|
value = record[field] |
|
|
if value is None: |
|
|
continue |
|
|
record[field] = xor_decrypt(value, token) |
|
|
if drop_canary: |
|
|
record.pop(canary_field, None) |
|
|
decrypted_records.append(record) |
|
|
|
|
|
write_jsonl(output_path, decrypted_records) |
|
|
|
|
|
|
|
|
def main() -> None: |
|
|
parser = argparse.ArgumentParser( |
|
|
description="Decrypt InteractComp JSONL encrypted with a shared canary token." |
|
|
) |
|
|
parser.add_argument("--input", required=True, help="Path to the encrypted JSONL.") |
|
|
parser.add_argument("--output", required=True, help="Path for the decrypted JSONL.") |
|
|
parser.add_argument( |
|
|
"--fields", |
|
|
default="domain,question,answer,context", |
|
|
help="Comma-separated fields to decrypt (default: domain,question,answer,context).", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--canary-field", |
|
|
default="canary", |
|
|
help="Field name storing the canary token in the encrypted JSONL (default: canary).", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--canary-value", |
|
|
help="Optional explicit canary token. Use when the encrypted file omits the canary column.", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--keep-canary", |
|
|
action="store_true", |
|
|
help="Keep the canary field in the decrypted output.", |
|
|
) |
|
|
args = parser.parse_args() |
|
|
|
|
|
input_path = Path(args.input) |
|
|
output_path = Path(args.output) |
|
|
fields = parse_fields(args.fields) if args.fields else [] |
|
|
|
|
|
if not fields: |
|
|
raise ValueError("At least one field must be specified for decryption.") |
|
|
|
|
|
decrypt_dataset( |
|
|
input_path, |
|
|
output_path, |
|
|
fields, |
|
|
args.canary_field, |
|
|
args.canary_value, |
|
|
drop_canary=not args.keep_canary, |
|
|
) |
|
|
|
|
|
|
|
|
if __name__ == "__main__": |
|
|
main() |
|
|
|
