use std::io::Write;
use aes::cipher::{block_padding::NoPadding, BlockEncrypt, BlockEncryptMut, KeyInit, KeyIvInit};
use aes::{Aes128, Aes256};
use sha2::{Digest, Sha256, Sha384, Sha512};
const USER_PASSWORD: &[u8] = b"user";
const OWNER_PASSWORD: &[u8] = b"owner";
const USER_VALIDATION_SALT: &[u8; 8] = b"uvsalt01";
const USER_KEY_SALT: &[u8; 8] = b"uksalt01";
const OWNER_VALIDATION_SALT: &[u8; 8] = b"ovsalt01";
const OWNER_KEY_SALT: &[u8; 8] = b"oksalt01";
const CONTENT: &[u8] = b"BT /F1 24 Tf 72 700 Td (Encrypted hello) Tj ET";
const XMP: &[u8] = concat!(
"<?xpacket begin=\"\u{feff}\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?>\n",
"<x:xmpmeta xmlns:x=\"adobe:ns:meta/\"><rdf:RDF ",
"xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"/></x:xmpmeta>\n",
"<?xpacket end=\"w\"?>"
)
.as_bytes();
fn hex(text: &str) -> Vec<u8> {
text.as_bytes()
.chunks(2)
.map(|pair| u8::from_str_radix(std::str::from_utf8(pair).expect("hex"), 16).expect("hex"))
.collect()
}
fn hash_r6(password: &[u8], salt: &[u8], udata: &[u8]) -> [u8; 32] {
let mut hasher = Sha256::new();
hasher.update(password);
hasher.update(salt);
hasher.update(udata);
let mut k = hasher.finalize().to_vec();
let mut round = 0_u32;
loop {
let mut unit = password.to_vec();
unit.extend_from_slice(&k);
unit.extend_from_slice(udata);
let mut k1 = Vec::new();
for _ in 0..64 {
k1.extend_from_slice(&unit);
}
let length = k1.len();
let e = cbc::Encryptor::<Aes128>::new_from_slices(&k[..16], &k[16..32])
.expect("aes128")
.encrypt_padded_mut::<NoPadding>(&mut k1, length)
.expect("encrypt")
.to_vec();
let sum: u32 = e[..16].iter().map(|byte| u32::from(*byte)).sum();
k = match sum % 3 {
0 => Sha256::digest(&e).to_vec(),
1 => Sha384::digest(&e).to_vec(),
_ => Sha512::digest(&e).to_vec(),
};
round += 1;
if round >= 64 && u32::from(e[e.len() - 1]) <= round - 32 {
break;
}
}
let mut key = [0_u8; 32];
key.copy_from_slice(&k[..32]);
key
}
fn encrypt_payload(key: &[u8; 32], iv: &[u8; 16], plaintext: &[u8]) -> Vec<u8> {
let padding = 16 - plaintext.len() % 16;
let mut buffer = plaintext.to_vec();
buffer.extend(std::iter::repeat_n(padding as u8, padding));
let length = buffer.len();
let encrypted = cbc::Encryptor::<Aes256>::new_from_slices(key, iv)
.expect("aes256")
.encrypt_padded_mut::<NoPadding>(&mut buffer, length)
.expect("encrypt")
.to_vec();
let mut out = iv.to_vec();
out.extend_from_slice(&encrypted);
out
}
fn encrypt_key(key: &[u8; 32], plaintext: &[u8; 32]) -> [u8; 32] {
let mut buffer = *plaintext;
let encrypted = cbc::Encryptor::<Aes256>::new_from_slices(key, &[0_u8; 16])
.expect("aes256")
.encrypt_padded_mut::<NoPadding>(&mut buffer, 32)
.expect("encrypt");
let mut out = [0_u8; 32];
out.copy_from_slice(encrypted);
out
}
fn hex_string(bytes: &[u8]) -> String {
bytes.iter().map(|byte| format!("{byte:02X}")).collect()
}
struct Builder {
out: Vec<u8>,
offsets: Vec<(u32, usize)>,
}
impl Builder {
fn new() -> Self {
let mut out = Vec::new();
out.extend_from_slice(b"%PDF-2.0\n");
Self {
out,
offsets: Vec::new(),
}
}
fn obj(&mut self, number: u32, body: &[u8]) {
self.offsets.push((number, self.out.len()));
self.out
.extend_from_slice(format!("{number} 0 obj\n").as_bytes());
self.out.extend_from_slice(body);
self.out.extend_from_slice(b"\nendobj\n");
}
fn stream(&mut self, number: u32, entries: &str, data: &[u8]) {
self.offsets.push((number, self.out.len()));
self.out
.extend_from_slice(format!("{number} 0 obj\n").as_bytes());
self.out.extend_from_slice(
format!("<< /Length {} {entries} >>\nstream\n", data.len()).as_bytes(),
);
self.out.extend_from_slice(data);
self.out.extend_from_slice(b"\nendstream\nendobj\n");
}
fn finish(mut self, trailer_extra: &str) -> Vec<u8> {
let xref = self.out.len();
let size = self.offsets.len() + 1;
self.out
.extend_from_slice(format!("xref\n0 {size}\n").as_bytes());
self.out.extend_from_slice(b"0000000000 65535 f \n");
for (_, offset) in &self.offsets {
self.out
.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
}
self.out.extend_from_slice(
format!(
"trailer\n<< /Size {size} /Root 1 0 R {trailer_extra} /ID \
[<00112233445566778899AABBCCDDEEFF><00112233445566778899AABBCCDDEEFF>] >>\n"
)
.as_bytes(),
);
self.out
.extend_from_slice(format!("startxref\n{xref}\n%%EOF\n").as_bytes());
self.out
}
}
fn main() -> std::io::Result<()> {
let mut user = Vec::new();
user.extend_from_slice(&hash_r6(USER_PASSWORD, USER_VALIDATION_SALT, &[]));
user.extend_from_slice(USER_VALIDATION_SALT);
user.extend_from_slice(USER_KEY_SALT);
assert_eq!(user.len(), 48);
let mut owner = Vec::new();
owner.extend_from_slice(&hash_r6(OWNER_PASSWORD, OWNER_VALIDATION_SALT, &user));
owner.extend_from_slice(OWNER_VALIDATION_SALT);
owner.extend_from_slice(OWNER_KEY_SALT);
let file_key = hash_r6(USER_PASSWORD, USER_KEY_SALT, &[]);
let owner_key = hash_r6(OWNER_PASSWORD, OWNER_KEY_SALT, &user);
let user_encrypted_key = encrypt_key(&file_key, &file_key);
let owner_encrypted_key = encrypt_key(&owner_key, &file_key);
let mut perms = Vec::new();
perms.extend_from_slice(&(-1_i32).to_le_bytes());
perms.extend_from_slice(&[0xFF; 4]);
perms.push(b'T');
perms.extend_from_slice(b"adb");
perms.extend_from_slice(&hex("deadbeef"));
let mut perms_block = [0_u8; 16];
perms_block.copy_from_slice(&perms);
Aes256::new_from_slice(&file_key)
.expect("key")
.encrypt_block((&mut perms_block).into());
let perms_encrypted = perms_block;
let encrypt_dict = format!(
"<< /Filter /Standard /V 5 /R 6 /Length 256 \
/CF << /StdCF << /CFM /AESV3 /Length 32 >> >> /StmF /StdCF /StrF /StdCF \
/U <{u}> /O <{o}> /UE <{ue}> /OE <{oe}> /Perms <{perms}> /P -1 /EncryptMetadata true >>",
u = hex_string(&user),
o = hex_string(&owner),
ue = hex_string(&user_encrypted_key),
oe = hex_string(&owner_encrypted_key),
perms = hex_string(&perms_encrypted),
);
let catalog =
|lang: &str| format!("<< /Type /Catalog /Pages 2 0 R /Lang {lang} /Metadata 6 0 R >>");
let pages = "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_string();
let page = "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R \
/Resources << /Font << /F1 5 0 R >> >> >>"
.to_string();
let font = "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>"
.to_string();
let mut plain = Builder::new();
plain.obj(1, catalog("(en-US)").as_bytes());
plain.obj(2, pages.as_bytes());
plain.obj(3, page.as_bytes());
plain.stream(4, "", CONTENT);
plain.obj(5, font.as_bytes());
plain.stream(6, "/Type /Metadata /Subtype /XML", XMP);
let plain = plain.finish("");
let lang = encrypt_payload(
&file_key,
&hex("000102030405060708090a0b0c0d0e0f")[..16]
.try_into()
.expect("iv"),
b"en-US",
);
let content = encrypt_payload(
&file_key,
&hex("101112131415161718191a1b1c1d1e1f")[..16]
.try_into()
.expect("iv"),
CONTENT,
);
let metadata = encrypt_payload(
&file_key,
&hex("202122232425262728292a2b2c2d2e2f")[..16]
.try_into()
.expect("iv"),
XMP,
);
let mut encrypted = Builder::new();
encrypted.obj(1, catalog(&format!("<{}>", hex_string(&lang))).as_bytes());
encrypted.obj(2, pages.as_bytes());
encrypted.obj(3, page.as_bytes());
encrypted.stream(4, "", &content);
encrypted.obj(5, font.as_bytes());
encrypted.stream(6, "/Type /Metadata /Subtype /XML", &metadata);
encrypted.obj(7, encrypt_dict.as_bytes());
let encrypted = encrypted.finish("/Encrypt 7 0 R");
let mut plain_file = std::fs::File::create("tests/fixtures/plain-twin.pdf")?;
plain_file.write_all(&plain)?;
let mut encrypted_file = std::fs::File::create("tests/fixtures/encrypted-r6.pdf")?;
encrypted_file.write_all(&encrypted)?;
println!(
"plain-twin.pdf: {} bytes, encrypted-r6.pdf: {} bytes (user password \"user\")",
plain.len(),
encrypted.len()
);
Ok(())
}