mod util;

use std::error::Error;

use std::io::{self, Read, Write};

fn main() -> Result<(), Box<dyn Error>> {

    let key = util::generate_key(b"\xF0\x9F\xA6\x80")?;

    // [93, 129, 173, 248, 234, 102, 108, 239, 45, 66, 196, 204, 221, 97, 143, 181]

    print!("👉 Enter your flag: ");

    io::stdout().flush()?;

    let mut flag = vec![0u8; 48];

    io::stdin().read_exact(&mut flag)?;

    let enc = util::encrypt_flag(flag, &key)?;

    let enc = util::make_emoji_string(enc);

    println!("{}", enc);

    if util::check_flag(&enc) {

        println!("🥳 You got it!");

    } else {

        println!("🤯 Try again!");

    }

    Ok(())

}

use std::str::Chars;

use openssl::error::ErrorStack;

use openssl::hash::{hash, MessageDigest};

use openssl::symm::{encrypt, Cipher};

struct Target(u8, String);

const BOX: [u8; 64] = [

    18, 15, 40, 10, 41, 36, 62, 23, 34, 12, 58, 57, 39, 46, 17, 7, 47, 44, 30, 26, 31, 14, 4, 19,

    21, 61, 11, 3, 5, 55, 37, 28, 53, 27, 13, 9, 49, 25, 54, 33, 42, 16, 24, 0, 1, 43, 32, 6, 50,

    63, 52, 48, 22, 45, 51, 2, 20, 59, 60, 29, 8, 35, 56, 38,

];

const TARGET_EMOJIS: &str = "😷😯😞😻😞😊😏😡😷😅😉😙😜😤😮😘😑😮😨😭😬😺😒😊😙😳😎😧😜😡😝😜😶😤😤😸😫😳😦😴😿😈😫😹😑😨😽😒😡😦😧😺😷😖😐😶😘😭😞😠😑😁😧😮😣😮😳😄😣😗😦😑😝😭😛😱😯😄😍😒😻😠😝😂😮😳😟😷";

impl Iterator for Target {

    type Item = char;

    #[inline(never)]

    fn next(&mut self) -> Option<Self::Item> {

        let len = self.1.len();

        if self.0 as usize >= len {

            return None;

        }

        let mut new_string: Vec<char> = vec![];

        for c in self.1.chars() {

            new_string.push(

                char::try_from(

                    c as u32 & 0xFFFFFFC0

                        | ((BOX[(c as u32 & 0x3F) as usize] + self.0) as u32 & 0x3F),

                )

                .unwrap(),

            );

        }

        self.1 = String::from_iter(new_string.clone());

        self.0 += 1;

        Some(new_string[(self.0 - 1) as usize])

    }

}

#[inline(never)]

pub fn generate_key(data: &[u8]) -> Result<Vec<u8>, ErrorStack> {

    let mut data = Vec::from(data);

    for _ in 0..202410 {

        data = Vec::from(&*hash(MessageDigest::sha512(), &data)?)

            .chunks(4)

            .map(|x| x[0] ^ x[1] ^ x[2] ^ x[3])

            .collect();

    }

    Ok(data)

}

#[inline(never)]

pub fn encrypt_flag(msg: Vec<u8>, key: &Vec<u8>) -> Result<Vec<u8>, ErrorStack> {

    let mut iv = key.clone();

    iv.reverse();

    encrypt(

        Cipher::sm4_cbc(),

        key,

        Some(&iv),

        &msg,

    )

}

#[inline(never)]

pub fn make_emoji_string(flag: Vec<u8>) -> String {

    let mut v = String::new();

    for d in flag.chunks(3) {

        let d = match d.len() {

            1 => &[d[0], 0, 0],

            2 => &[d[0], d[1], 0],

            _ => d,

        };

        [

            d[0] >> 2,

            d[0] << 6 >> 2 | d[1] >> 4,

            d[1] << 4 >> 2 | d[2] >> 6,

            d[2] << 2 >> 2,

        ].map(|b| v.push(char::try_from(b as u32 & 0x3F | 0x1F600).unwrap()));

    }

    v

}

#[inline(never)]

pub fn check_flag(enc: &String) -> bool {

    let mut iter = enc.chars();

    let mut target = Target(0, String::from(TARGET_EMOJIS));

    let xor =

        |x: &mut Chars, y: &mut Target| x.next().unwrap() as u32 ^ y.next().unwrap() as u32;

    for _ in 0..88 {

        if xor(&mut iter, &mut target) != 0 {

            return false;

        }

    }

    true

}