当前位置：首页 > 范文大全 > 实用文>GO语言实现的端口扫描器

GO语言实现的端口扫描器

2023-09-18 08:37:17 收藏本文下载本文

“NIGAZ”通过精心收集，向本站投稿了6篇GO语言实现的端口扫描器，以下是小编为大家准备的GO语言实现的端口扫描器，仅供参考，欢迎大家阅读。

GO语言实现的端口扫描器

篇1：GO语言实现的端口扫描器

这篇文章主要介绍了GO语言实现的端口扫描器分享,本文直接给出实现代码,代码中包含大量注释,需要的朋友可以参考下

代码如下:

//GO语言实现端口扫描

//缺陷

//port 无法设置成全局变量不知道怎么设置的

//var l = list.New 这个是数组操作并不是消息队列跟消息队列功能类似

//实现功能

//实现生成 IP段

//实现端口扫描

//实现参数传入

//写入文件到本地

//main.go 58.215.20.30 58.215.201.30 80

//文件名开始IP 结束IP 扫描端口

//QQ29295842 希望认识更多的朋友技术交流

//QQ群367196336 go golang WEB安全开发

package main

import (

“container/list”

“fmt”

“net”

“os”

“strconv”

“strings”

“time”

)

func ip2num(ip string) int {

canSplit := func(c rune) bool { return c == ‘.‘ }

lisit := strings.FieldsFunc(ip, canSplit) //[58 215 20 30]

//fmt.Println(lisit)

ip1_str_int, _ := strconv.Atoi(lisit[0])

ip2_str_int, _ := strconv.Atoi(lisit[1])

ip3_str_int, _ := strconv.Atoi(lisit[2])

ip4_str_int, _ := strconv.Atoi(lisit[3])

return ip1_str_int<<24 | ip2_str_int<<16 | ip3_str_int<<8 | ip4_str_int

}

func num2ip(num int) string {

ip1_int := (num & 0xff000000) >>24

ip2_int := (num & 0x00ff0000) >>16

ip3_int := (num & 0x0000ff00) >>8

ip4_int := num & 0x000000ff

//fmt.Println(ip1_int)

data := fmt.Sprintf(“%d.%d.%d.%d”, ip1_int, ip2_int, ip3_int, ip4_int)

return data

}

func gen_ip(Aip1 int, Aip2 int) {

index := Aip1

for index < Aip2 {

//fmt.Println(num2ip(index))

// 入队, 压栈

ip_data := num2ip(index)

//fmt.Println(ip_data)

l.PushBack(ip_data)

index++

}

func text_add(name string, data string) { //向文件中写入数据 text_add(“file2.txt”, “qqqqqqqqqqqqqqqqqqqqqqq”)

f, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0x644)

if err != nil {

panic(err)

}

defer f.Close()

_, err = f.WriteString(data)

_, err = f.WriteString(“\r\n”)

if err != nil {

panic(err)

}

//text_add(“file2.txt”, “qqqqqqqqqqqqqqqqqqqqqqq”)

var l = list.New()

func socket_ip(host string, port string) bool {

var (

remote = host + “:” + port

)

tcpAddr, _ := net.ResolveTCPAddr(“tcp4”, remote) //转换IP格式

//fmt.Printf(“%s”, tcpAddr)

conn, err := net.DialTCP(“tcp”, nil, tcpAddr) //查看是否连接成功

if err != nil {

fmt.Printf(“no==%s:%s\r\n”, host, port)

return false

}

defer conn.Close()

fmt.Printf(“ok==%s:%s\r\n”, host, port)

return true

}

func for_ip(port string) {

now := time.Now()

year, mon, day := now.UTC().Date()

file_name := fmt.Sprintf(“%d-%d-%d_%s”, year, mon, day, port)

for { //死循环

if l.Len() <= 0 {

fmt.Println(“跳出循环”)

break //#跳出

}

// 出队从前读取

i1 := l.Front()

l.Remove(i1)

IP, _ := i1.Value.(string)

if socket_ip(IP, port) {

//OK

//获取当前日期作为文件名在把IP写入进去

text_add(file_name+“_ok.txt”, IP)

} //else {

// text_add(file_name+“_no.txt”, IP)

// }

time.Sleep(time.Millisecond * 500) //纳秒为单位

}

func main() {

argsLen := len(os.Args)

//fmt.Println(argsLen)

if argsLen != 4 {

fmt.Println(“main.go 58.215.20.30 58.215.201.30 80”)

} else {

gen_ip(ip2num(os.Args[1]), ip2num(os.Args[2]))

for index := 0; index < 200; index++ {

go for_ip(os.Args[3])

}

for {

time.Sleep(1 * time.Second) //纳秒为单位

}

篇2：go语言制作端口扫描器

本文给大家分享的是使用go语言编写的TCP端口扫描器，可以选择IP范围，扫描的端口，以及多线程，有需要的小伙伴可以参考下，

GO语言编写的TCP端口扫描器，本人的第一个GO程序。

Git@OSC：git.oschina.net/youshusoft/GoScanner

使用命令：

Scanner startIp [endIp] port thread

参数说明：

startIp 开始IP

endIp 结束IP,可选,不输入表示只扫描startIp

port 扫描端口,单个端口：3389；多个端口：1433,3389；连续端口：135-3389

thread 最大并发线程数,最高2048

扫描结果保存在同目录下的 result.txt 中，每次启动都会清掉之前的内容。

例子一:

Scanner 58.96.172.22 58.96.172.220 80 512

扫描58.96.172.22到58.96.172.220中的80端口，最大并发线程512。

例子二：

Scanner 58.96.172.22 58.96.172.220 21,5631 512

扫描58.96.172.22到58.96.172.220中的21和5631端口，最大并发线程512。

例子三：

Scanner 58.96.172.22 58.96.172.220 1-520 512

扫描58.96.172.22到58.96.172.220中的1到520端口，最大并发线程512。

例子四：

Scanner 58.96.172.22 1-520 512

扫描58.96.172.22中的1到520端口，最大并发线程512。

package mainimport (“fmt”“strconv”“flag”“strings”“net”“os”)/** 扫描地址*/var ipAddrs chan string = make(chan string)//扫描结果var result chan string = make(chan string)//线程数var thread chan int = make(chan int)var nowThread int;//关闭程序var clo chan bool = make(chan bool)//保存结果func writeResult(){ fileName := “result.txt” fout,err := os.Create(fileName) if err != nil{ //文件创建失败 fmt.Println(fileName + “ create error”) } defer fout.Close() s,ok := <- result for ;ok;{ fout.WriteString(s + “\r\n”) s,ok = <- result } //通知进程退出 clo <- true; }//根据线程参数启动扫描线程func runScan(){ t,ok := <- thread nowThread = t; if ok{ for i := 0;i < nowThread;i++{ go scan(strconv.Itoa(i)) } } //等待线程终止 for;<-thread == 0;{ nowThread-- if nowThread == 0{//全部线程已终止,关闭结果写入,退出程序close(result)break } }}/** 扫描线程*/func scan(threadId string){ s,ok := <-ipAddrs for;ok;{ fmt.Println(“[thread-” + threadId + “] scan:” + s) _,err := net.Dial(“tcp”,s) if err == nil{//端口开放result <- s } s,ok = <-ipAddrs } fmt.Println(“[thread-” + threadId + “] end”) thread <- 0;}//获取下一个IPfunc nextIp(ip string) string{ ips := strings.Split(ip,“.”) var i int; for i = len(ips) - 1;i >= 0;i--{ n,_ := strconv.Atoi(ips[i]) if n >= 255{//进位ips[i] = “1”}else{//+1n++ips[i] = strconv.Itoa(n)break } } if i == -1{ //全部IP段都进行了进位,说明此IP本身已超出范围 return “”; } ip = “” leng := len(ips) for i := 0;i < leng;i++{ if i == leng -1{ip += ips[i] }else{ip += ips[i] + “.” } } return ip}//生成IP地址列表func processIp(startIp,endIp string) []string{ var ips = make([]string,0) for ;startIp != endIp;startIp = nextIp(startIp){ if startIp != “”{ips = append(ips,startIp) } } ips = append(ips,startIp) return ips}//处理参数func processFlag(arg []string){ //开始IP,结束IP var startIp,endIp string //端口 var ports []int = make([]int,0) index := 0 startIp = arg[index] si := net.ParseIP(startIp) if si == nil{ //开始IP不合法 fmt.Println(“‘startIp‘ Setting error”) return } index++ endIp = arg[index] ei := net.ParseIP(endIp) if(ei == nil){ //未指定结束IP,即只扫描一个IP endIp = startIp }else{ index++ } tmpPort := arg[index] if strings.Index(tmpPort,“-”) != -1{ //连续端口 tmpPorts := strings.Split(tmpPort,“-”) var startPort,endPort int var err error startPort,err = strconv.Atoi(tmpPorts[0]) if err != nil || startPort < 1 || startPort >65535{//开始端口不合法return } if len(tmpPorts) >= 2{//指定结束端口endPort,err = strconv.Atoi(tmpPorts[1])if err != nil || endPort < 1 || endPort >65535 || endPort < startPort{ //结束端口不合法 fmt.Println(“‘endPort‘ Setting error”) return} }else{//未指定结束端口endPort = 65535 } for i := 0;startPort + i <= endPort;i++{ports = append(ports,startPort + i) } }else{ //一个或多个端口 ps := strings.Split(tmpPort,“,”) for i := 0;i < len(ps);i++{p,err := strconv.Atoi(ps[i])if err != nil{ //端口不合法 fmt.Println(“‘port‘ Setting error”) return}ports = append(ports,p) } } index++ t,err := strconv.Atoi(arg[index]) if(err != nil){ //线程不合法 fmt.Println(“‘thread‘ Setting error”) return } //最大线程2048 if t < 1{ t = 1; }else if t >2048{ t = 2048; } //传送启动线程数 thread <- t //生成扫描地址列表 ips := processIp(startIp,endIp) il := len(ips) for i := 0; i < il;i++{ pl := len(ports) for j := 0;j < pl;j++{ipAddrs <- ips[i] + “:” + strconv.Itoa(ports[j]) } } close(ipAddrs)}func main(){ flag.Parse() if flag.NArg() != 3 && flag.NArg() != 4{ //参数不合法 fmt.Println(“Parameter error”) return } //获取参数 args := make([]string,0,4) for i := 0;i < flag.NArg();i++{ args = append(args,flag.Arg(i)) } //启动扫描线程 go runScan() //启动结果写入线程 go writeResult() //参数处理 processFlag(args) //等待退出指令 <- clo; fmt.Println(“Exit”)}

以上所述就是本文的全部内容了，希望大家能够喜欢，

篇3：Go语言实现socket实例

作者：不吃皮蛋字体：[增加减小] 类型：

用golang不用他的net包还有什么意义,这里提供一个测试代码：

server.go 服务端:

代码如下:

package main

import (

“fmt”

“log”

“net”

“bufio”

)

func handleConnection(conn net.Conn) {

data, err := bufio.NewReader(conn).ReadString(‘\n‘)

if err != nil {

log.Fatal(“get client data error: ”, err)

}

fmt.Printf(“%#v\n”, data)

fmt.Fprintf(conn, “hello client\n”)

conn.Close

}

func main() {

ln, err := net.Listen(“tcp”, “:6010”)

if err != nil {

panic(err)

}

for {

conn, err := ln.Accept()

if err != nil {

log.Fatal(“get client connection error: ”, err)

}

go handleConnection(conn)

}

client.go 客户端:

代码如下:

package main

import (

“fmt”

“net”

“bufio”

)

func main() {

conn, err := net.Dial(“tcp”, “:6010”)

if err != nil {

panic(err)

}

fmt.Fprintf(conn, “hello server\n”)

data, err := bufio.NewReader(conn).ReadString(‘\n‘)

if err != nil {

panic(err)

}

fmt.Printf(“%#v\n”, data)

}

希望本文所述对大家的Go语言程序设计有所帮助，

篇4：GO语言实现文件上传代码

本文给大家分享的是一则使用golang实现文件上传的代码，主要是使用os.Create创建文件，io.Copy来保存文件，思路非常清晰，这里推荐给大家，有需要的小伙伴参考下吧，

功能很简单，代码也很简洁，这里就不多废话了。

代码如下:

package main

import (

“fmt”

“io”

“net/http”

“os”

)

const (

upload_path string = “./upload/”

)

func helloHandle(w http.ResponseWriter, r *http.Request) {

io.WriteString(w, “hello world!”)

}

//上传

func uploadHandle(w http.ResponseWriter, r *http.Request) {

//从请求当中判断方法

if r.Method == “GET” {

io.WriteString(w, “我的第一个页面上传图片

”)

} else {

//获取文件内容要这样获取

file, head, err := r.FormFile(“file”)

if err != nil {

fmt.Println(err)

return

}

defer file.Close()

//创建文件

fW, err := os.Create(upload_path + head.Filename)

if err != nil {

fmt.Println(“文件创建失败”)

return

}

defer fW.Close()

_, err = io.Copy(fW, file)

if err != nil {

fmt.Println(“文件保存失败”)

return

}

//io.WriteString(w, head.Filename+“ 保存成功”)

http.Redirect(w, r, “/hello”, http.StatusFound)

//io.WriteString(w, head.Filename)

}

func main() {

//启动一个http 服务器

http.HandleFunc(“/hello”, helloHandle)

//上传

http.HandleFunc(“/image”, uploadHandle)

err := http.ListenAndServe(“:8080”, nil)

if err != nil {

fmt.Println(“服务器启动失败”)

return

}

fmt.Println(“服务器启动成功”)

}

以上所述就是本文的全部内容了，希望大家能够喜欢，能够对大家学习go语言有所帮助，

篇5：Linux C语言写的超级简单端口扫描器linux操作系统

本文章来给各位同学介绍关于 Linux C语言写的超级简单端口扫描器,希望方法对各位同学有帮助，

代码如下复制代码#include

#include

void msg

{

printf(“EP:scan ip startport endportnEP:scan ip 127.0.0.1 20 n”);

}

int main(int argc,char** argv)

{

char *ip;

int startport,endport,sockfd,i;

struct sockaddr_in to;

float costtime;

clock_t start,end;

if(4!=argc)

{

msg();

return 0;

}

ip=argv[1];

startport=atoi(argv[2]);

endport=atoi(argv[3]);

if(startport<1 || endport>65535 || endport

篇6：Go语言单链表实现方法

作者：OSC首席键客字体：[增加减小] 类型：转载

1. singlechain.go代码如下：

代码如下:

//////////

//单链表 -- 线性表

package singlechain

//定义节点

type Node struct {

Data int

Next *Node

}

* 返回第一个节点

* h 头结点

func GetFirst(h *Node) *Node {

if h.Next == nil {

return nil

}

return h.Next

}

* 返回最后一个节点

* h 头结点

func GetLast(h *Node) *Node {

if h.Next == nil {

return nil

}

i := h

for i.Next != nil {

i = i.Next

if i.Next == nil {

return i

}

return nil

}

//取长度

func GetLength(h *Node) int {

var i int = 0

n := h

for n.Next != nil {

i++

n = n.Next

}

return i

}

//插入一个节点

//h: 头结点

//d:要插入的节点

//p:要插入的位置

func Insert(h, d *Node, p int) bool {

if h.Next == nil {

h.Next = d

return true

}

i := 0

n := h

for n.Next != nil {

i++

if i == p {

if n.Next.Next == nil {

n.Next = d

return true

} else {

d.Next = n.Next

n.Next = d.Next

return true

}

n = n.Next

if n.Next == nil {

n.Next = d

return true

}

return false

}

//取出指定节点

func GetLoc(h *Node, p int) *Node {

if p < 0 || p >GetLength(h) {

return nil

}

var i int = 0

n := h

for n.Next != nil {

i++

n = n.Next

if i == p {

return n

}

return nil

}

2. main.go代码如下：

代码如下:

package main

import “fmt”

import “list/singlechain”

func main() {

//初始化一个头结点

var h singlechain.Node

//往链表插入10个元素

for i := 1; i <= 10; i++ {

var d singlechain.Node

d.Data = i

singlechain.Insert(&h, &d, i)

fmt.Println(singlechain.GetLoc(&h, i))

}

fmt.Println(singlechain.GetLength(&h))

fmt.Println(singlechain.GetFirst(&h))

fmt.Println(singlechain.GetLast(&h))

fmt.Println(singlechain.GetLoc(&h, 6))

}

希望本文所述对大家的Go语言程序设计有所帮助，

【GO语言实现的端口扫描器】相关文章：

1.Go语言的Oracle 驱动：gooci8

7.go语言通过管道连接两个命令行进程的方法

8.熟悉常见网络端口用途

9.实现超我

10.go语言对文件按照指定块大小进行分割的方法

《GO语言实现的端口扫描器.doc》

将本文的Word文档下载到电脑，方便收藏和打印

推荐度：

点击下载文档

文档为doc格式

实用文图文推荐

GO语言实现的端口扫描器相关文章