Descubra como usar o Google para localizar sua casa utilizando apenas o seu roteador Wi-Fi!
Tags: go, security, googlecloud, programming
Published: 2023-05-27 22:31:16


![Wifi Google](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ik0lohvs37s1e8ptkefd.png)

Você sabia que o Google possui um mecanismo de busca de localização chamado "Wifi access point object"? Essa funcionalidade é descrita em detalhes na documentação, que você pode conferir clicando [aqui](https://developers.google.com/maps/documentation/geolocation/overview). 

É realmente incrível, não é mesmo? Vamos explorar mais esse recurso!

Você já ouviu falar do **BSSID**? Também conhecido como Basic Service Set Identifier, esse termo pode parecer complicado, mas na verdade é bastante útil para entender como funciona o seu roteador Wi-Fi. O **BSSID** é como um "nome" exclusivo dado ao roteador, permitindo que seus dispositivos o identifiquem na rede.

Imagine que o **BSSID** é como um endereço **MAC** para o seu roteador. Ele desempenha um papel fundamental ao permitir que seus dispositivos se conectem a ele de forma rápida e eficiente. Ao escanear as redes Wi-Fi disponíveis em seu dispositivo, você pode visualizar o **BSSID** como uma combinação de letras e números.

Por que isso é importante? Bem, compreender o **BSSID** pode ser extremamente útil ao configurar ou solucionar problemas em sua rede sem fio. Ele ajuda a identificar o roteador específico ao qual você está se conectando, o que pode ser útil ao ajustar configurações ou solucionar problemas de conexão.

Portanto, da próxima vez que você se deparar com o termo **BSSID**, lembre-se de que ele se refere ao identificador exclusivo do seu roteador Wi-Fi. É um elemento-chave para garantir uma conexão estável e confiável em sua rede doméstica ou local de trabalho.

Se você deseja visualizar os **BSSID** dos roteadores Wi-Fi ao seu redor, temos um comando simples para você. Acompanhe:

Abra o terminal e digite o seguinte comando:

```sh
sudo /System/Library/PrivateFrameworks/Apple80211.framework/Resources/airport -s
```

É importante executar o comando acima com permissões de administrador para garantir que você tenha acesso às informações necessárias. Por motivos de segurança, o BSSID não será exibido se você executar o comando sem as permissões adequadas.

O output do terminal será parecido com esse:

```sh
            SSID BSSID             RSSI CHANNEL HT CC SECURITY (auth/unicast/group)
    "confidencial" XX:5f:67:XX:c5:4d -81  8       Y  -- RSN(PSK/AES/AES) 
    "confidencial" 00:31:92:XX:e7:36 -50  9       Y  -- RSN(PSK/AES/AES) 
    "confidencial" cc:06:XX:db:e2:XX -50  4       Y  -- RSN(PSK/AES/AES) 
        "confidencial" a4:XX:a4:ed:XX:7c -47  2       Y  BR WPA(PSK/AES,TKIP/TKIP) RSN(PSK/AES,TKIP/TKIP) 
"confidencial" cc:06:77:db:e2:84 -66  36,+1   Y  -- RSN(PSK/AES/AES) 
    "confidencial" 00:31:XX:XX:e7:37 -57  48,-1   Y  BR RSN(PSK/AES/AES) 
  "confidencial", fa:XX:ca:86:ca:96 -26  6       Y  -- NONE
      "confidencial" a4:6d:a4:XX:33:XX -49  36      Y  BR WPA(PSK/AES,TKIP/TKIP) RSN(PSK/AES,TKIP/TKIP) 
```

Depois de obter o **BSSID** do roteador Wi-Fi desejado, você pode utilizar a API do Google para obter dados de geolocalização precisa. Veja como fazer isso usando um comando simples no terminal:

```sh
curl --location --request GET 'https://www.googleapis.com/geolocation/v1/geolocate?key=SuaChaveAPIAqui' \
--header 'Content-Type: application/json' \
--data '{
    "wifiAccessPoints":[ 
        {
            "macAddress": "BSSIDDoRoteadorAqui" 
        }
    ]
}'
```
Antes de prosseguir, é importante substituir **"SuaChaveAPIAqui"** pela chave de API do Google que você pode obter ao criar uma conta de desenvolvedor no Google Cloud Platform. Certifique-se de adicionar a chave correta para garantir o acesso adequado à API.

Ao executar o comando, o sistema enviará uma solicitação GET para a API do Google Geolocation, passando o **BSSID** do roteador como parâmetro. Isso permitirá que o Google identifique a localização aproximada do roteador com base em suas informações de geolocalização.

Além disso, ao analisar a estrutura dos exemplos de chamadas, você pode inserir vários endereços **MAC** Wi-Fi juntamente com a intensidade do sinal. Dessa forma, a API utilizará técnicas de triangulação para fornecer uma localização ainda mais precisa.

É interessante destacar que a API de geolocalização também pode encontrar locais com base em IDs de torres de celular. Isso significa que você pode obter informações precisas de localização mesmo quando não está conectado a uma rede Wi-Fi.

Agora vamos criar um código para automatizar esse processo acima usando a linguagem golang.

Segue o código abaixo:

```go
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os/exec"
	"runtime"
	"strings"
)

func getWifiMacAddresses() map[string]map[string]string {
	var results []byte
	var err error

	switch runtime.GOOS {
	case "darwin":
		results, err = exec.Command("/System/Library/PrivateFrameworks/Apple80211.framework/Resources/airport", "-s").Output()
	case "windows":
esults, err = exec.Command("netsh", "wlan", "show", "network").Output()
	case "linux":
		// results, err = exec.Command("iwlist", "scanning").Output()
	}

	if err != nil {
		log.Fatal(err)
	}

	var macAddr = make(map[string]map[string]string)
	lines := strings.Split(strings.TrimSpace(string(results)), "\n")[1:]
	for _, line := range lines {
		fields := strings.Fields(line)
		addr := fields[0]
		db := fields[1]
		// additional fields if needed

		macAddr[addr] = map[string]string{
			"signalStrength": db,
		}
	}

	return macAddr
}

func main() {
	postjson := make(map[string]interface{})
	postjson["wifiAccessPoints"] = []map[string]interface{}{}
	hotspots := getWifiMacAddresses()

	for addr, info := range hotspots {
		signalStrength := info["signalStrength"]
		postjson["wifiAccessPoints"] = append(postjson["wifiAccessPoints"].([]map[string]interface{}), map[string]interface{}{
			"macAddress":     addr,
			"signalStrength": signalStrength,
		})
	}

	googleMapsAPIkey := "your_google_maps_api_key"
	url := "https://www.googleapis.com/geolocation/v1/geolocate?key=" + googleMapsAPIkey

	data, err := json.Marshal(postjson)
	if err != nil {
		log.Fatal(err)
	}

	response, err := http.Post(url, "application/json", bytes.NewBuffer(data))
	if err != nil {
		log.Fatal(err)
	}

	defer response.Body.Close()

	var result map[string]interface{}
	json.NewDecoder(response.Body).Decode(&result)

	fmt.Println(result)
}

```

## Conclusão

Nesta postagem, exploramos como utilizar a linguagem de programação Go para automatizar a obtenção de endereços MAC Wi-Fi e aproveitar a API de geolocalização do Google. Com o código desenvolvido, é possível obter informações precisas sobre roteadores Wi-Fi próximos e enviá-las para a API, obtendo assim uma localização aproximada.

Espero ter ajudado, até a próxima ( :