1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
|
// A program to scan emails for phishing links.
// Copyright (C) 2019 Harald Eilertsen
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
use phisher;
use clap::{clap_app, crate_name, crate_authors, crate_version, crate_description};
use std::boxed::Box;
use std::error::Error;
use std::fs::{ File, remove_file };
use std::io::{ BufRead, BufReader, Write };
use std::os::unix::net::{ UnixListener, UnixStream };
use std::result::Result;
use std::sync::Arc;
use std::thread;
use std::time::SystemTime;
fn main() {
let args = clap_app!(app =>
(name: crate_name!())
(version: crate_version!())
(author: crate_authors!())
(about: crate_description!())
(@arg PHISHTANK: --phishtank +required +takes_value "The phishtank json data file to use.")
).get_matches();
let start_time = SystemTime::now();
let filename = args.value_of("PHISHTANK").unwrap();
if let Ok(file) = File::open(filename) {
let tank = Arc::new(phisher::load_phistank(BufReader::new(file)).unwrap());
println!("Loaded {} phishes in {} seconds!",
tank.phishes.len(),
start_time.elapsed().unwrap().as_secs());
match run_server(tank) {
Ok(_) => println!("Exiting."),
Err(e) => eprintln!("Received error: {}, terminating.", e.to_string())
};
}
else {
eprintln!("Could not open file {}.\nIs the filename correct?", filename);
}
}
fn run_server(tank: Arc<phisher::PhishTank>) -> Result<(), Box<dyn Error>> {
let listener = UnixListener::bind("/tmp/phisher")?;
for stream in listener.incoming() {
match stream {
Ok(stream) => {
let t = Arc::clone(&tank);
thread::spawn(move || handle_connection(stream, t));
}
Err(e) => {
eprintln!("Received error: {}", e.to_string());
break;
}
}
}
Ok(remove_file("/tmp/phisher")?)
}
// Handle a connected client.
//
// Once a client is connected, it can request the status of multiple
// URLs before closing the connection. Each URL must be passed in on
// a separate line, and the results are returned in the same order
// as the URLs were passed in.
//
fn handle_connection(mut stream: UnixStream, tank: Arc<phisher::PhishTank>) {
// Clone the stream so we get another ref to the underlying socket,
// then wrap it in a BufReader, so we can use read_line on it.
let mut bufreader = BufReader::new(stream.try_clone().unwrap());
loop {
let mut buffer = String::new();
bufreader.read_line(&mut buffer).unwrap();
if tank.is_phish(buffer.trim_end()) {
stream.write(b"it's a phish!\n").unwrap();
}
else {
stream.write(b"good url.\n").unwrap();
}
}
}
|
