False positives during asynchronous TCP scanning through the Socks5 Proxy relay

I am learning golang and wanted to build a TCP port scanner with SOCKS5 proxies as a relay for mass scanning.

Although all of the S5 proxies are being checked for every target scan, sometimes there are some False positives - and I cannot find the reason why.

Preparing proxyDialer:

func create_socks5_tcp_dialer(socks5_addr string) proxy.Dialer {
	//socks5_dialer_tcp, err := proxy.SOCKS5("tcp", socks5_addr, nil, proxy.Direct)
	socks5_dialer_tcp, err := proxy.SOCKS5("tcp", socks5_addr, nil, &net.Dialer{Timeout: 5 * time.Second, KeepAlive: 5 * time.Second})
	if err != nil {
		fmt.Println("Error connecting to proxy:", err)
	}
	return socks5_dialer_tcp
}

Validating socks5 address:

func socks5_validator(socks5_addr, vps_opened, vps_closed string) (bool, string) {
	/* 	Check if SOCKS5 proxy is valid.
	   	1. Connect to the open port on the server under my control using proxy.
	   	2. Connect to the closed port on the server under my control using proxy.
	   		- If both checks are true then, SOCKS5 proxy is considered as valid.
	   		- If one of the check is false, SOCKS5 proxy is considered as invalid.
	   	3. Returns true/false and s5_addr.
	*/
	// Create SOCKS5 dialer
	socks5_dialer_tcp := create_socks5_tcp_dialer(socks5_addr)
	// Make connection using SOCKS5 proxy to the opened port on the vps.
	conn_1, err := socks5_dialer_tcp.Dial("tcp", vps_opened)
	// If it was successful and not generate any error then check1 is passed.
	if err == nil {
		//fmt.Println("CHECK 1: PASSED")
		conn_1.Close()
		// If error was generated then check is not passed and do not make check2.
	} else {
		//fmt.Println("CHECK 1: NOT PASSED")
		return false, socks5_addr
	}
	// Make connection using SOCKS5 proxy to the closed port on the vps.
	conn_2, err := socks5_dialer_tcp.Dial("tcp", vps_closed)
	// If it was unsuccessful and error was generated then check2 is passed.
	if err != nil {
		//fmt.Println("CHECK 2: PASSED")
		// If both checks were passed then return false.
		return true, socks5_addr
		// If error was not generated then check2 is not passed.
	} else {
		//fmt.Println("CHECK 2: NOT PASSED")
		conn_2.Close()
		return false, socks5_addr
	}
}

Port scanning

s5_dialer_tcp := create_socks5_tcp_dialer(socks5_addr)
			// Scan target using s5
			conn, err := s5_dialer_tcp.Dial("tcp", target)
			if err != nil {
                //open
            } else {
                //closed
            }

My question is:
Do I correctly scan TCP services through the SOCKS5 proxy and do I validate this proxy properly?

Link to the full code:
https://github.com/Karmaz95/crimson_prober

I don't think that these are actual false positives. Instead you are having the wrong assumptions of how these proxies will work: You assume that if the single check for a specific port open (connect success) and a specific port closed (connect failure) on a specific server at a specific time succeeds, then the proxy can be used to reliably check many arbitrary ports on arbitrary servers at arbitrary times.

This assumption is likely not valid, especially given that you seem to use proxies which are outside of your control.

A common behavior of such proxies is that they provide only restricted access, i.e. common ports like HTTP and HTTPS will work while other ports will be blocked. Proxies might also employ rate limiting, so they will simply deny access through the proxy after a while. And free proxies available in some lists often cease to work after a while.