1use crate::errors::{Service, ServiceRejected};
3use crate::{crypto::*, protobuf as p, MAX_MESSAGE_BYTES};
4use anyhow::{bail, ensure, Result};
5use openssl::{nid::Nid, symm::Mode};
6use zeroize::Zeroize;
7
8pub struct PublicProfile {
9 pub version: u16,
10 pub point: Vec<u8>,
11 pub signature_pem: String,
12}
13pub fn profile_for_region(region: u32) -> Result<PublicProfile> {
14 let version = match region {
15 1 => 10014,
16 2 => 50005,
17 _ => bail!("Unsupported business certificate region"),
18 };
19 let pins: serde_json::Value =
20 serde_json::from_str(include_str!("../fixtures/business-public-keys.json"))?;
21 let pin = pins["profiles"]
22 .as_array()
23 .unwrap()
24 .iter()
25 .find(|p| p["certVersion"].as_u64() == Some(version))
26 .ok_or_else(|| anyhow::anyhow!("Missing business pin"))?;
27 Ok(PublicProfile {
28 version: version as u16,
29 point: hex::decode(pin["ecdhPointHex"].as_str().unwrap())?,
30 signature_pem: pin["ecdsaPEM"].as_str().unwrap().to_string(),
31 })
32}
33pub struct Prelogin {
34 pub request: Vec<u8>,
35 local: Ecdh,
36 plain: Vec<u8>,
37 derived: Vec<u8>,
38 encrypted_payload: Vec<u8>,
39 signature_pem: String,
40 has_auth_key: bool,
41}
42impl Drop for Prelogin {
43 fn drop(&mut self) {
44 self.plain.zeroize();
45 self.derived.zeroize();
46 }
47}
48impl Prelogin {
49 pub fn prepare(plain: &[u8], profile: &PublicProfile, auth_key: &[u8]) -> Result<Self> {
50 ensure!(
51 plain.len() <= MAX_MESSAGE_BYTES,
52 "Prelogin plaintext too large"
53 );
54 ensure!(
55 profile.point.len() == 65 && profile.point[0] == 4,
56 "Invalid business pin"
57 );
58 ensure!(
59 auth_key.is_empty() || auth_key.len() >= 24,
60 "Invalid saved Hybrid auth key"
61 );
62 let local = Ecdh::generate(Nid::X9_62_PRIME256V1)?;
63 let point = local.public()?;
64 let prefix = [b"1415".as_slice(), &point].concat();
65 let aad = sha256(&prefix);
66 let mut shared = sha256(&local.derive(&profile.point)?);
67 let mut random32 = random::<32>()?;
68 let encrypted_random = envelope_seal(&random32, &shared[..24], &aad, random()?)?;
69 shared.zeroize();
70 let auth_block = if auth_key.is_empty() {
71 vec![]
72 } else {
73 envelope_seal(&random32, &auth_key[..24], &aad, random()?)?
74 };
75 let mut extracted = hmac(b"security hdkf expand", &random32)?;
76 let derived = expand(&extracted, &aad, 56)?;
77 random32.zeroize();
78 extracted.zeroize();
79 let payload_aad = sha256(&[prefix, encrypted_random.clone(), auth_block.clone()].concat());
80 let encrypted_payload = envelope_seal(plain, &derived[..24], &payload_aad, random()?)?;
81 let request = p::message(&[
82 p::uint(1, 1),
83 p::bytes(2, &p::message(&[p::uint(1, 415), p::bytes(2, &point)])?),
84 p::bytes(3, &encrypted_random),
85 p::bytes(4, &auth_block),
86 p::bytes(5, &encrypted_payload),
87 ])?;
88 Ok(Self {
89 request,
90 local,
91 plain: plain.to_vec(),
92 derived,
93 encrypted_payload,
94 signature_pem: profile.signature_pem.clone(),
95 has_auth_key: !auth_key.is_empty(),
96 })
97 }
98 pub fn decrypt_reply(&self, reply: &[u8]) -> Result<Vec<u8>> {
99 let f = p::decode(reply)?;
100 let key = p::decode(p::data(&f, 1)?)?;
101 ensure!(p::scalar(&key, 1)? == 415, "Unsupported business curve");
102 let point = p::data(&key, 2)?;
103 let credential = p::scalar(&f, 2)?;
104 ensure!(
105 point.len() == 65
106 && point[0] == 4
107 && [1, 2].contains(&credential)
108 && (credential != 2 || self.has_auth_key),
109 "Unsupported business credential"
110 );
111 let ciphertext = p::data(&f, 3)?;
112 if credential == 1 {
113 verify_signature(
114 &self.signature_pem,
115 &sha256(&[self.encrypted_payload.as_slice(), ciphertext].concat()),
116 p::data(&f, 4)?,
117 )?;
118 }
119 let mut shared = sha256(&self.local.derive(point)?);
120 let aad = sha256(
121 &[
122 &self.derived[24..],
123 &self.plain,
124 b"415",
125 point,
126 credential.to_string().as_bytes(),
127 ]
128 .concat(),
129 );
130 let plain = envelope_open(ciphertext, &shared[..24], &aad);
131 shared.zeroize();
132 plain
133 }
134}
135pub struct PacketPolicy<'a> {
136 pub client_version: u32,
137 pub uin: u32,
138 pub cookie: &'a [u8],
139 pub cgi: u16,
140 pub original_length: usize,
141 pub pre_encryption_length: usize,
142 pub key_version: u16,
143 pub cert_version: u16,
144 pub checksum: u32,
145 pub compression: u8,
146 pub encryption: u8,
147 pub notice_id: u32,
148 pub sequence: u16,
149}
150pub fn pack(policy: PacketPolicy<'_>, encrypted: &[u8]) -> Result<Vec<u8>> {
151 ensure!(
152 policy.cookie.len() <= 15 && policy.compression <= 3 && policy.encryption <= 15,
153 "Invalid business policy"
154 );
155 ensure!(
156 policy.original_length <= MAX_MESSAGE_BYTES
157 && policy.pre_encryption_length <= MAX_MESSAGE_BYTES,
158 "Business payload too large"
159 );
160 let tail = [
161 policy.client_version.to_be_bytes().to_vec(),
162 policy.uin.to_be_bytes().to_vec(),
163 policy.cookie.to_vec(),
164 p::varint(policy.cgi as u64),
165 p::varint(policy.original_length as u64),
166 p::varint(policy.pre_encryption_length as u64),
167 p::varint(policy.key_version as u64),
168 p::varint(policy.cert_version as u64),
169 p::varint(policy.checksum as u64),
170 vec![0xff],
171 p::varint(policy.notice_id as u64),
172 vec![0, 0],
173 p::varint(0),
174 policy.sequence.to_be_bytes().to_vec(),
175 ]
176 .concat();
177 let length = tail.len() + 3;
178 ensure!(length <= 63, "Unsupported extended business header");
179 let flags = ((length as u16) << 2)
180 | policy.compression as u16
181 | ((policy.cookie.len() as u16) << 8)
182 | ((policy.encryption as u16) << 12);
183 Ok([
184 vec![0xbf],
185 flags.to_le_bytes().to_vec(),
186 tail,
187 encrypted.to_vec(),
188 ]
189 .concat())
190}
191pub fn prelogin_packet(
192 prelogin: &Prelogin,
193 cgi: u16,
194 key_version: u16,
195 cookie: &[u8],
196) -> Result<Vec<u8>> {
197 pack(
198 PacketPolicy {
199 client_version: 0,
200 uin: 0,
201 cookie,
202 cgi,
203 original_length: prelogin.plain.len(),
204 pre_encryption_length: prelogin.plain.len(),
205 key_version,
206 cert_version: 0,
207 checksum: 0,
208 compression: 2,
209 encryption: 12,
210 notice_id: crate::notice::notice_id(&prelogin.request)?,
211 sequence: u16::from_be_bytes(random()?),
212 },
213 &prelogin.request,
214 )
215}
216pub struct Envelope {
217 pub return_code: i32,
218 pub cgi: u64,
219 pub original_length: usize,
220 pub pre_encryption_length: usize,
221 pub compression: u8,
222 pub encryption: u8,
223 pub cookie: Vec<u8>,
224 pub payload: Vec<u8>,
225}
226pub fn split(input: &[u8]) -> Result<Envelope> {
227 ensure!(input.len() >= 10, "Truncated business response");
228 let base = usize::from(input[0] == 0xbf);
229 let flags = u16::from_le_bytes(input[base..base + 2].try_into()?);
230 let header = ((flags >> 2) & 63) as usize;
231 let cookie_len = ((flags >> 8) & 15) as usize;
232 let cookie_offset = base + 10;
233 ensure!(
234 header >= cookie_offset + cookie_len && header <= input.len(),
235 "Invalid business boundary"
236 );
237 let return_code = i32::from_be_bytes(input[base + 2..base + 6].try_into()?);
238 let mut offset = cookie_offset + cookie_len;
239 let cgi = p::read_varint(&input[..header], &mut offset)?;
240 let original_length = usize::try_from(p::read_varint(&input[..header], &mut offset)?)?;
241 let pre_encryption_length = usize::try_from(p::read_varint(&input[..header], &mut offset)?)?;
242 p::read_varint(&input[..header], &mut offset)?;
243 p::read_varint(&input[..header], &mut offset)?;
244 if base == 0 {
245 ensure!(offset == header, "Unknown business response extension");
246 }
247 ensure!(
248 original_length <= MAX_MESSAGE_BYTES && pre_encryption_length <= MAX_MESSAGE_BYTES,
249 "Response too large"
250 );
251 Ok(Envelope {
252 return_code,
253 cgi,
254 original_length,
255 pre_encryption_length,
256 compression: (flags & 3) as u8,
257 encryption: (flags >> 12) as u8,
258 cookie: input[cookie_offset..cookie_offset + cookie_len].to_vec(),
259 payload: input[header..].to_vec(),
260 })
261}
262pub fn checksum(uin: u32, payload: &[u8]) -> u32 {
263 let mut input = (payload.len() as u32).to_be_bytes().to_vec();
264 input.extend(md5(&uin.to_be_bytes()));
265 let prefix = md5(&input);
266 let mut a = 1u32;
267 let mut b = 0u32;
268 for byte in prefix.iter().chain(payload) {
269 a = (a + *byte as u32) % 65521;
270 b = (b + a) % 65521;
271 }
272 (b << 16) | a
273}
274pub struct AuthenticatedPacket {
275 pub packet: Vec<u8>,
276 cgi: u16,
277 mode: u8,
278 key: Vec<u8>,
279}
280impl Drop for AuthenticatedPacket {
281 fn drop(&mut self) {
282 self.key.zeroize();
283 }
284}
285impl AuthenticatedPacket {
286 pub fn prepare(state: &crate::AccountState, cgi: u16, plain: &[u8]) -> Result<Self> {
287 state.validate()?;
288 ensure!(
289 plain.len() <= MAX_MESSAGE_BYTES,
290 "Authenticated request too large"
291 );
292 let mode = if !state.request_key.is_empty() && !state.response_key.is_empty() {
293 13
294 } else {
295 5
296 };
297 let zipped = if mode == 5 {
298 deflate(plain)?
299 } else {
300 plain.to_vec()
301 };
302 let compressed = mode == 5 && zipped.len() < plain.len();
303 let body = if compressed { zipped.as_slice() } else { plain };
304 let key = if mode == 13 {
305 ensure!(
306 state.request_key.len() == 24 && state.response_key.len() == 24,
307 "Invalid main session keys"
308 );
309 state.response_key.clone()
310 } else {
311 ensure!(state.session_key.len() == 16, "Invalid origin session key");
312 state.session_key.clone()
313 };
314 let encrypted = if mode == 13 {
315 envelope_seal(body, &state.request_key, b"", random()?)?
316 } else {
317 cbc(body, &key, Mode::Encrypt)?
318 };
319 let packet = pack(
320 PacketPolicy {
321 client_version: state.device.client_version as u32,
322 uin: state.uin,
323 cookie: &state.cookie,
324 cgi,
325 original_length: plain.len(),
326 pre_encryption_length: body.len(),
327 key_version: 0,
328 cert_version: 39,
329 checksum: checksum(state.uin, plain),
330 compression: if compressed { 1 } else { 2 },
331 encryption: mode,
332 notice_id: crate::notice::notice_id(&encrypted)?,
333 sequence: u16::from_be_bytes(random()?),
334 },
335 &encrypted,
336 )?;
337 Ok(Self {
338 packet,
339 cgi,
340 mode,
341 key,
342 })
343 }
344 pub fn decode_verified_transport_reply(&self, input: &[u8]) -> Result<(Vec<u8>, Vec<u8>)> {
346 let envelope = split(input)?;
347 ServiceRejected::check(Service::NativeEnvelope, envelope.return_code)?;
348 ensure!(
349 envelope.cgi == self.cgi as u64
350 && envelope.encryption == self.mode
351 && [1, 2].contains(&envelope.compression),
352 "Unsupported authenticated response policy"
353 );
354 let body = if self.mode == 13 {
355 envelope_open(&envelope.payload, &self.key, b"")?
356 } else {
357 cbc(&envelope.payload, &self.key, Mode::Decrypt)?
358 };
359 ensure!(
360 body.len() == envelope.pre_encryption_length,
361 "Authenticated body length mismatch"
362 );
363 let plain = if envelope.compression == 1 {
364 inflate(&body)?
365 } else {
366 body
367 };
368 ensure!(
369 plain.len() == envelope.original_length,
370 "Authenticated plaintext length mismatch"
371 );
372 Ok((plain, envelope.cookie))
373 }
374}
375pub fn account_keys(inner: &Ecdh, auth: &[u8]) -> Result<(Vec<u8>, Vec<u8>, Vec<u8>)> {
376 let f = p::decode(auth)?;
377 let flags = match p::optional(&f, 19)? {
378 Some(p::Value::Varint(v)) => *v,
379 None => 0,
380 _ => bail!("Invalid auth flags"),
381 };
382 let raw = p::unbuffer(p::data(&f, 3)?)?;
383 let session = if flags & 4 != 0 {
384 let e = p::decode(p::data(&f, 2)?)?;
385 ensure!(p::scalar(&e, 1)? == 713, "Unsupported account curve");
386 let point = p::unbuffer(p::data(&e, 2)?)?;
387 ensure!(point.len() == 57 && point[0] == 4, "Invalid account point");
388 let mut secret = inner.derive(&point)?;
389 ensure!(secret.len() == 28, "Invalid P224 secret");
390 let mut key = md5(&secret);
391 secret.zeroize();
392 let result = cbc(&raw, &key, Mode::Decrypt);
393 key.zeroize();
394 result?
395 } else {
396 raw
397 };
398 ensure!(
399 !session.is_empty() && session.len() <= 65536,
400 "Invalid derived session key"
401 );
402 let get = |n| -> Result<Vec<u8>> {
403 Ok(match p::optional_data(&f, n)? {
404 Some(b) => p::unbuffer(b)?,
405 None => vec![],
406 })
407 };
408 Ok((session, get(23)?, get(24)?))
409}
410
411#[cfg(test)]
412mod tests {
413 use super::*;
414 #[test]
415 fn independent_checksum_vectors() {
416 for (uin, payload, expected) in [
417 (0, vec![], 0x4e970913),
418 (1, b"a".to_vec(), 0x39d20759),
419 (0x12345678, b"abc".to_vec(), 0x69430a30),
420 (u32::MAX, (0..=255).collect(), 0xf74e868e),
421 ] {
422 assert_eq!(checksum(uin, &payload), expected);
423 }
424 }
425 #[test]
426 fn prelogin_profiles_validate() {
427 for region in [1, 2] {
428 let profile = profile_for_region(region).unwrap();
429 assert!(
430 Prelogin::prepare(b"synthetic", &profile, &[])
431 .unwrap()
432 .request
433 .len()
434 > 100
435 );
436 }
437 assert!(profile_for_region(3).is_err());
438 }
439 #[test]
440 fn encrypted_envelope_rejects_aad() {
441 let key = [3; 24];
442 let aad = sha256(b"a");
443 let e = envelope_seal(b"synthetic", &key, &aad, [4; 12]).unwrap();
444 assert_eq!(envelope_open(&e, &key, &aad).unwrap(), b"synthetic");
445 assert!(envelope_open(&e, &key, &sha256(b"b")).is_err());
446 }
447 #[test]
448 fn synthetic_signed_peer_and_saved_credential() {
449 use openssl::{
450 ec::{EcGroup, EcKey},
451 hash::MessageDigest,
452 pkey::PKey,
453 sign::Signer,
454 };
455 let static_key = Ecdh::generate(Nid::X9_62_PRIME256V1).unwrap();
456 let signing = PKey::from_ec_key(
457 EcKey::generate(&EcGroup::from_curve_name(Nid::X9_62_PRIME256V1).unwrap()).unwrap(),
458 )
459 .unwrap();
460 let profile = PublicProfile {
461 version: 1,
462 point: static_key.public().unwrap(),
463 signature_pem: String::from_utf8(signing.public_key_to_pem().unwrap()).unwrap(),
464 };
465 for credential in [1, 2] {
466 let auth = if credential == 2 {
467 vec![11; 380]
468 } else {
469 vec![]
470 };
471 let request = b"synthetic login";
472 let local = Prelogin::prepare(request, &profile, &auth).unwrap();
473 let f = p::decode(&local.request).unwrap();
474 let key = p::decode(p::data(&f, 2).unwrap()).unwrap();
475 let point = p::data(&key, 2).unwrap();
476 let prefix = [b"1415".as_slice(), point].concat();
477 let aad = sha256(&prefix);
478 let random = envelope_open(
479 p::data(&f, 3).unwrap(),
480 &sha256(&static_key.derive(point).unwrap())[..24],
481 &aad,
482 )
483 .unwrap();
484 let derived =
485 expand(&hmac(b"security hdkf expand", &random).unwrap(), &aad, 56).unwrap();
486 assert_eq!(
487 envelope_open(
488 p::data(&f, 5).unwrap(),
489 &derived[..24],
490 &sha256(
491 &[
492 prefix,
493 p::data(&f, 3).unwrap().to_vec(),
494 p::data(&f, 4).unwrap().to_vec()
495 ]
496 .concat()
497 )
498 )
499 .unwrap(),
500 request
501 );
502 if credential == 2 {
503 assert_eq!(
504 envelope_open(p::data(&f, 4).unwrap(), &auth[..24], &aad).unwrap(),
505 random
506 );
507 }
508 let ephemeral = Ecdh::generate(Nid::X9_62_PRIME256V1).unwrap();
509 let server_point = ephemeral.public().unwrap();
510 let response_aad = sha256(
511 &[
512 &derived[24..],
513 request,
514 b"415",
515 &server_point,
516 credential.to_string().as_bytes(),
517 ]
518 .concat(),
519 );
520 let ciphertext = envelope_seal(
521 b"synthetic authenticated reply",
522 &sha256(&ephemeral.derive(point).unwrap())[..24],
523 &response_aad,
524 [4; 12],
525 )
526 .unwrap();
527 let mut fields = vec![
528 p::bytes(
529 1,
530 &p::message(&[p::uint(1, 415), p::bytes(2, &server_point)]).unwrap(),
531 ),
532 p::uint(2, credential),
533 p::bytes(3, &ciphertext),
534 ];
535 if credential == 1 {
536 let mut signer = Signer::new(MessageDigest::sha256(), &signing).unwrap();
537 signer
538 .update(&sha256(&[p::data(&f, 5).unwrap(), &ciphertext].concat()))
539 .unwrap();
540 fields.push(p::bytes(4, &signer.sign_to_vec().unwrap()));
541 }
542 let response = p::message(&fields).unwrap();
543 assert_eq!(
544 local.decrypt_reply(&response).unwrap(),
545 b"synthetic authenticated reply"
546 );
547 let mut corrupt = response;
548 let n = corrupt.len();
549 corrupt[n - 1] ^= 1;
550 assert!(local.decrypt_reply(&corrupt).is_err());
551 }
552 }
553}