From 530e56b82f1866bf38a99e86a43d09ffe91e2b4c Mon Sep 17 00:00:00 2001
From: Lizzy Fleckenstein <eliasfleckenstein@web.de>
Date: Sat, 27 May 2023 22:37:33 +0200
Subject: Use mt_auth

---
 src/main.rs | 198 ++++++++++++------------------------------------------------
 1 file changed, 39 insertions(+), 159 deletions(-)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index 53674d0..dc29774 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,27 +1,4 @@
-use futures::future::OptionFuture;
-use mt_net::{CltSender, ReceiverExt, SenderExt, ToCltPkt, ToSrvPkt};
-use rand::RngCore;
-use sha2::Sha256;
-use srp::{client::SrpClient, groups::G_2048};
-use std::{future::Future, time::Duration};
-use tokio::time::{interval, Instant, Interval};
-
-enum AuthState {
-    Init(Interval),
-    Verify(Vec<u8>, SrpClient<'static, Sha256>),
-    Done,
-}
-
-struct Conn {
-    tx: CltSender,
-    auth: AuthState,
-    username: String,
-    password: String,
-}
-
-fn maybe_tick(iv: Option<&mut Interval>) -> OptionFuture<impl Future<Output = Instant> + '_> {
-    OptionFuture::from(iv.map(Interval::tick))
-}
+use mt_net::{ReceiverExt, SenderExt, ToCltPkt, ToSrvPkt};
 
 #[tokio::main]
 async fn main() {
@@ -29,149 +6,48 @@ async fn main() {
         .await
         .unwrap();
 
-    let mut conn = Conn {
-        tx,
-        auth: AuthState::Init(interval(Duration::from_millis(100))),
-        username: "texmodbot".into(),
-        password: "owo".into(),
-    };
-
-    let init_pkt = ToSrvPkt::Init {
-        serialize_version: 29,
-        proto_version: 40..=40,
-        player_name: conn.username.clone(),
-        send_full_item_meta: false,
-    };
-
-    let worker_thread = tokio::spawn(worker.run());
+    let mut auth = mt_auth::Auth::new(tx.clone(), "texmodbot", "owo", "en_US");
+    let worker = tokio::spawn(worker.run());
 
     loop {
         tokio::select! {
             pkt = rx.recv() => match pkt {
                 None => break,
                 Some(Err(e)) => eprintln!("{e}"),
-                Some(Ok(v)) => conn.handle_pkt(v).await,
-            },
-            Some(_) = maybe_tick(match &mut conn.auth {
-                AuthState::Init(iv) => Some(iv),
-                _ => None,
-            }) => {
-                conn.tx.send(&init_pkt).await.unwrap();
-            }
-            _ = tokio::signal::ctrl_c() => {
-                conn.tx.close();
-            }
-        }
-    }
-
-    worker_thread.await.unwrap();
-}
-
-impl Conn {
-    async fn handle_pkt(&mut self, pkt: ToCltPkt) {
-        use ToCltPkt::*;
-
-        match pkt {
-            Hello {
-                auth_methods,
-                username: name,
-                ..
-            } => {
-                use mt_net::AuthMethod;
-
-                if !matches!(self.auth, AuthState::Init(_)) {
-                    return;
-                }
-
-                let srp = SrpClient::<Sha256>::new(&G_2048);
-
-                let mut rand_bytes = vec![0; 32];
-                rand::thread_rng().fill_bytes(&mut rand_bytes);
-
-                if self.username != name {
-                    panic!("username changed");
-                }
-
-                if auth_methods.contains(AuthMethod::FirstSrp) {
-                    let verifier = srp.compute_verifier(
-                        self.username.to_lowercase().as_bytes(),
-                        self.password.as_bytes(),
-                        &rand_bytes,
-                    );
-
-                    self.tx
-                        .send(&ToSrvPkt::FirstSrp {
-                            salt: rand_bytes,
-                            verifier,
-                            empty_passwd: self.password.is_empty(),
-                        })
-                        .await
-                        .unwrap();
-
-                    self.auth = AuthState::Done;
-                } else if auth_methods.contains(AuthMethod::Srp) {
-                    let a = srp.compute_public_ephemeral(&rand_bytes);
-
-                    self.tx
-                        .send(&ToSrvPkt::SrpBytesA { a, no_sha1: true })
-                        .await
-                        .unwrap();
-
-                    self.auth = AuthState::Verify(rand_bytes, srp);
-                } else {
-                    panic!("unsupported auth methods: {auth_methods:?}");
-                }
-            }
-            SrpBytesSaltB { salt, b } => {
-                if let AuthState::Verify(a, srp) = &self.auth {
-                    let m = srp
-                        .process_reply(
-                            a,
-                            self.username.to_lowercase().as_bytes(),
-                            self.password.as_bytes(),
-                            &salt,
-                            &b,
-                        )
-                        .unwrap()
-                        .proof()
-                        .into();
-
-                    self.tx.send(&ToSrvPkt::SrpBytesM { m }).await.unwrap();
-
-                    self.auth = AuthState::Done;
-                }
-            }
-            NodeDefs(defs) => {
-                defs.0
-                    .values()
-                    .flat_map(|def| {
-                        std::iter::empty()
-                            .chain(&def.tiles)
-                            .chain(&def.special_tiles)
-                            .chain(&def.overlay_tiles)
-                    })
-                    .map(|tile| &tile.texture.name)
-                    .for_each(|texture| {
-                        if !texture.is_empty() {
-                            println!("{texture}");
+                Some(Ok(pkt)) => {
+                    use ToCltPkt::*;
+
+                    auth.handle_pkt(&pkt).await;
+
+                    match pkt {
+                        NodeDefs(defs) => {
+                            defs.0
+                                .values()
+                                .flat_map(|def| {
+                                    std::iter::empty()
+                                        .chain(&def.tiles)
+                                        .chain(&def.special_tiles)
+                                        .chain(&def.overlay_tiles)
+                                })
+                                .map(|tile| &tile.texture.name)
+                                .for_each(|texture| {
+                                    if !texture.is_empty() {
+                                        println!("{texture}");
+                                    }
+                                });
                         }
-                    });
-            }
-            Kick(reason) => {
-                eprintln!("kicked: {reason}");
-            }
-            AcceptAuth { .. } => {
-                self.tx
-                    .send(&ToSrvPkt::Init2 {
-                        lang: "en_US".into(),
-                    })
-                    .await
-                    .unwrap();
-
-                self.tx
+                        Kick(reason) => {
+                            eprintln!("kicked: {reason}");
+                        }
+                        _ => {}
+                    }
+                }
+            },
+            _ = auth.poll() => {
+                tx
                     .send(&ToSrvPkt::CltReady {
                         major: 0,
-                        minor: 1,
+                        minor: 0,
                         patch: 0,
                         reserved: 0,
                         version: "https://github.com/LizzyFleckenstein03/texmodbot".into(),
@@ -179,8 +55,12 @@ impl Conn {
                     })
                     .await
                     .unwrap();
+            },
+            _ = tokio::signal::ctrl_c() => {
+                tx.close();
             }
-            _ => {}
         }
     }
+
+    worker.await.unwrap();
 }
-- 
cgit v1.2.3