You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
105 lines
2.8 KiB
105 lines
2.8 KiB
package main |
|
|
|
import ( |
|
"reflect" |
|
//"./timer" |
|
"time" |
|
"fmt" |
|
"strings" |
|
"regexp" |
|
"io/ioutil" |
|
"encoding/hex" |
|
) |
|
|
|
|
|
var tcp_data string = read_tcp_file("/proc/net/tcp") |
|
|
|
func main() { |
|
var loops int = 0 |
|
// How to split on space-delimited fields, then colon-delimited fields? |
|
// How to turn this byte into a string? |
|
|
|
// /proc/net/tcp hex addresses need to be reversed two-character-wise |
|
// and then converted byte by byte (2 char at a time) |
|
//fmt.Println(convert_address(reverse_string(reverse_bytes("0100007F")))) |
|
|
|
for _ = range time.Tick(10 * time.Second) { |
|
fmt.Println("Waiting 10 seconds...") |
|
for num, row := range get_tcp_rows(tcp_data) { |
|
row_type := reflect.TypeOf(row) |
|
fmt.Println(num, " ", row_type) |
|
} |
|
// if loops modulo 6 (1min) then |
|
// for address in address_list do |
|
// if (grep address address_list | wc -l >=3) then |
|
// This is a port scan! |
|
// fi |
|
// done |
|
// elseif (wc -l old_tcp_file < wc -l tcp_file) then |
|
// for i in (wc -l tcp_file - wc -l old_tcp_flle) do |
|
// print New Connection! reverse_strng(reverse_bytes(tcp_file[i])) // This oversimplifies row value selection for the sake |
|
// // of pseudocode |
|
// done |
|
// else |
|
// "No new connections. Waiting another 10 seconds..." |
|
// fi |
|
loops++ |
|
} |
|
} |
|
|
|
func check(e error) { |
|
if e != nil { |
|
panic(e) |
|
} |
|
} |
|
|
|
// Aiming for an array of [string]string maps |
|
// Am I looking for a map[string]interface here? |
|
func get_tcp_rows(connections_file string) []string { |
|
tcp_lines := strings.Split(connections_file, "\n") |
|
regexpression := regexp.MustCompile(`[\r\n\t\f\v]+`) |
|
tcp_columns := regexpression.Split(tcp_lines[0], -1) |
|
var tcp_values map[string]string |
|
|
|
for i, line := range tcp_lines[1:] { |
|
trim_line := strings.TrimSpace(line) |
|
values := regexpression.Split(trim_line, -1) |
|
column := tcp_columns[i] |
|
tcp_values[column] = values |
|
} |
|
return tcp_values |
|
} |
|
|
|
// Take a string, create a rune slice, and use a loop to reverse it character-wise. |
|
func reverse_bytes(s string) string { |
|
runes := []rune(s) |
|
for i, j := len(runes)-2, len(runes)-1; j > 0; i, j = i-2, j-2 { |
|
runes[i], runes[j] = runes[j], runes[i] |
|
} |
|
return string(runes) |
|
} |
|
|
|
func reverse_string(s string) string { |
|
runes := []rune(s) |
|
for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 { |
|
runes[i], runes[j] = runes[j], runes[i] |
|
} |
|
return string(runes) |
|
} |
|
// Store data function |
|
// Loads all fields and subfields into storage (memory? where?) |
|
// State check function |
|
// hash each line, use to determine new lines, convert to readable, and print |
|
|
|
|
|
func convert_address(address string) []byte { |
|
output, err := hex.DecodeString(address) |
|
check(err) |
|
return output |
|
} |
|
func read_tcp_file(connections_file_path string) string { |
|
data, err := ioutil.ReadFile(connections_file_path) |
|
check(err) |
|
fmt.Println("Data file read successfully.\n") |
|
return string(data) |
|
}
|
|
|