From 84dd54bb0829e04d2f2c322a51f1a56c8a7da30a Mon Sep 17 00:00:00 2001 From: mux Date: Thu, 7 Aug 2025 13:44:24 +0200 Subject: [PATCH] jz aber xd --- src/.socket.rs.swp | Bin 0 -> 20480 bytes src/socket.rs | 212 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 212 insertions(+) create mode 100644 src/.socket.rs.swp create mode 100644 src/socket.rs diff --git a/src/.socket.rs.swp b/src/.socket.rs.swp new file mode 100644 index 0000000000000000000000000000000000000000..7c9de9c5e313a9c0e4fab59e5091d13b59e5dbbd GIT binary patch literal 20480 zcmeI2dyE}b9mkKfilw$RH2xt{a(ao&TwP}G-AB7Su#M1EA!&7GX#=gz&D=ZZ?j5=J z&h0$58)$7}q6Up`jMPU=D#izd!~_i(P>IBbKQuKG^$&$;A}Ja*L5ms#`2C%kbLZUG zZkymAo1AGsd+wa)?|jc|X3nXW4&8Qu&)Fr0Ya3&a-S~yZHy5vEul|^^RH$=l>&6fg=H1&jhl0i%FXz$jo8Fbb>-1>(*|b_$kWmRbAO%zZ!e89@2_U;*3$X2EW7VGCn_1P_7+I1CoR`@web{971%2z0;#7zdlcxy_870V}`- zGvFHV?<*L40sI#H6g&j(2Q9D{Sm0W)1H7<_vG0JdgVW#va0&=;JD3MHu)y_TD|q?M zj6DZ_1|9*Q1NVR`cptbGycfI+YyuZ9haKRvpbi|c4gBd%&e;F&1(%&yE_f6 zL_)MJ`jg&A+~H%lx=~|M#5X0oruU3<<5x7`k6s!nveB!WE-iAA8gg8=I2tU?Lv@(+PW3J|-g`{-Tb*V$)2JSs z_s{&7l$z0B{ZctcqFJYzz!P?@8MKAfJHRQ4GD$|2-7||h*fv=ozKEDg2^m%1sPYGM z&195O>Gvuzvpz?ogDR%_AYUU1+O#JL?uVyXM6Uc^&Xklie@ofMs606*r%_}K*+P3M zoY#YJWLv4WKr44MR-&gfTCPc^aKE>bQ}0;ayht;LcY9&(-!nqCu@ z@p*BgowTyT7HOoUGswjhm={eZ%E6ef3ABtz>yu7Q}UGI`ks| z+RFliUXJ{RSgClTCX=S)RW`WHUyVR2u(x>fu|E{}ZL45wnUgnNb}eW&vEDk)P1HhZ z!|vHLWE|Qpw_}}HIl)(GvI~y4g@^T!$y~HQb|{vIrS@YH_W5IWJC?X!)RV`c^@BcC zTs5iJu~gB5ZY}pM%M^Z+i)JLWX_Y+Hl_u6!Y?^F`WJ2*rc&n^dpZQfRa(i2Pa!6yS z*cgce9cC=GS@s#GBI>SEGnHg$l(jVT>)hw>;FElQo|pTiqZ!2V$N6#*4;!@dWUH}V zYq()#p&w(sh!6wCD)uE+Pf5zcbTY`g8X93))OH>@+WUy8(xfIk*`w9y7Sjd`icv!) zH&YuhX~CmM%wT_`;Rh2i#X8Q=AxY&?q+&j!sHV|P=*>a1lhXU0zSMosEvR8N@tasJ-O2{7rdbZ%zR+8<-aE24t!HWVN~ntE$@5oB*#9N!wq+7{spw*}KQSl{oF9-FOsA zuP2r63&KEzK96j&^@BE&W^Yz`lu#@Q6nZ;3sV{2UwTK+!e62|<}wNx1&jhl0i%FXz$jo8FbWt2i~>dhqrm!5Abs!8-~QbQ8&q*c z9NTFXCTC`B4W~Reh5x){%YV*nX|_}t=aJkDjgCwnRo~S0Pj=eZJw5C49I`Hz?YWXY zx7(SWozAnJo}SWjEniBmb5r*0lwICcvdfdsWO-_OrfcjwwLD9s@}&2FABX*CurEyS z|E;VIY5)K4;92k#_%uks5;zJz2(AW~gJ2Z44!#VIf%kyx!P~%5z&Vnbw6QB)b`>l`hxBjh6KM Peer { + Peer { + ip_address: "0.0.0.0".to_string(), + port: 0, + } + } + + fn build_from_hex(hex_ip: &str, hex_port: &str) -> Peer { + Peer { + ip_address: Self::convert_ip_hex_dec(hex_ip), + port: Self::convert_port_hex_dec(hex_port), + } + } + + fn convert_ip_hex_dec(ip_address: &str) -> String { + let mut buffer: String = String::new(); + let mut ip_quads: Vec = vec![]; + for (i, v) in ip_address.chars().enumerate() { + if i % 2 == 1 { + buffer.push(v); + ip_quads.push( + u64::from_str_radix(&buffer, 16) + .expect("upsi 2") + .to_string(), + ); + buffer = String::new(); + } else { + buffer.push(v); + } + } + ip_quads + .iter() + .rev() + .map(|x| x.to_owned()) + .collect::>() + .join(".") + } + + fn convert_port_hex_dec(port: &str) -> usize { + usize::from_str_radix(port, 16).expect("upsi 3") + } + } + + #[derive(PartialEq)] + pub enum SocketState{ + Listening, + Established, + Closed + } + + #[derive(PartialEq)] + pub struct Socket { + peer_loc: Peer, + peer_rem: Peer, + pids: Vec, + state : SocketState, + user : String, + group : String, + inode : u64 + } + + impl Clone for Socket { + fn clone(&self) -> Self { + Self { + peer_loc : self.peer_loc.clone(), + peer_rem : self.peer_rem .clone(), + pids : self.pids.clone(), + state : self.state.clone(), + user : self.user.clone(), + group : self.user.clone(), + inode : self.inode.clone() + } + } + } + + impl Socket { + pub fn new(ip_loc: &str, port_loc: usize, ip_rem: &str, port_rem: usize, pids : Vec, state : SocketState, user : &str, group : &str, inode : u64) -> Socket { + Socket { + peer_loc: Peer { + ip_address: ip_loc.to_string(), + port: port_loc, + }, + peer_rem: Peer { + ip_address: ip_rem.to_string(), + port: port_rem, + }, + pids : pids, + state : state, + user : user.to_string(), + group : group.to_string(), + inode : inode, + } + } + + fn get_tcp_file_inode(pid: u64) -> u64 { + let mut path = String::from("/proc/"); + path.push_str(&pid.to_string()); + path.push_str("/net/tcp"); + + let inode = fs::metadata(&path) + .expect("Cannot read metadata") + .ino(); + return inode; + } + + fn check_inode_seen(seen_inodes : &HashSet, pid : u64) -> bool { + let inode = Socket::get_tcp_file_inode(pid); + return seen_inodes.contains(&inode); + } + + fn add_inode(seen_inodes : &mut HashSet, pid: u64){ + let inode = Socket::get_tcp_file_inode(pid); + seen_inodes.insert(inode); + } + + pub fn to_string (self) -> String { + let mut ret_str = String::from(""); + ret_str.push_str(&self.peer_loc.ip_address); + ret_str.push(':'); + let loc_port_str = self.peer_loc.port.clone().to_string(); + ret_str.push_str(if self.peer_loc.port == 0 { "*" } else { &loc_port_str }); + ret_str.push(' '); + ret_str.push_str(&self.peer_rem.ip_address); + ret_str.push(':'); + let rem_port_str = self.peer_rem.port.clone().to_string(); + ret_str.push_str(if self.peer_rem.port == 0 { "*" } else { &rem_port_str }); + ret_str.push('\n'); + return ret_str; + } + + fn get_all_unique_socket_infos() -> String { + let pattern = Regex::new(r"^[1-4]?[0-9]{1,6}$").expect("kannst kein regex??"); + let contents = + fs::read_dir("/proc/").expect("upsi 4 (proc kann nicht gelesen werden, Berechtigung?)"); + let mut seen_inodes = HashSet::::new(); + let mut complete_file: String = String::new(); + for dir in contents { + match dir { + Ok(dir) => { + if !pattern.is_match( + &dir.file_name() + .into_string() + .expect("Dateiname ist kein gueltiger Unicode-String")[..], + ) { + continue; + } + let mut path = dir.path().into_os_string().into_string().expect("gehtnd"); + path.push_str("/net/tcp"); + let pid = &path.split("/").nth(2).expect("gesplittert"); + if !Socket::check_inode_seen(&seen_inodes, pid.parse::().unwrap()) { + Socket::add_inode(& mut seen_inodes, pid.parse::().unwrap()); + let test = &fs::read_to_string(path) + .expect("Could not read proc/pid/net/tcp") + .lines() + .skip(1) + // .map(|x| Socket::convert_line(x.to_string())) + .map(|x| x.to_owned()) + .collect::>() + .join("\n"); + complete_file.push_str(test); + } + else{ + continue; + } + }, + Err(_) => continue, + }; + } + // complete_file + complete_file + } + + } +} + +#[cfg(test)] +mod tests { + + use crate::socket::Socket::*; + + fn init_sockets() -> Vec { + let sockets = Vec::::new(); + sockets.push(Socket::new("93.83.160.12", 21345, "0.0.0.0", 0, Vec::::new(), Socket::SocketState::Listening, "root", "root", 123123)); + sockets.push(Socket::new("195.201.90.97", 8843, "0.0.0.0", 443, Vec::::new(), Socket::SocketState::Established, "apache", "apache", 218389)); + sockets.push(Socket::new("255.255.255.255", 193193, "0.0.0.0", 8080, Vec::::new(), Socket::SocketState::Listening, "node", "node", 1301011)); + return sockets; + } + + #[cfg(test)] + pub fn test_to_string() -> (){ + let sockets = init_sockets(); + assert_eq!("93.83.160.12:21345 0.0.0.0:*", sockets[0].clone().to_string()); + assert_eq!("195.201.90.97:8843 0.0.0.0:443", sockets[1].clone().to_string()); + assert_eq!("255.255.255.255:193193 0.0.0.0:8080", sockets[2].clone().to_string()); + } +}