fbee736e90
* fix(geolocate): no proxy when discovering our IP address The use case of --proxy is that you cannot contact the OONI backend otherwise. It is wrong, though, using the proxy when discovering our IP address. The measurement won't use the proxy anyway. Therefore, we need to use the IP address that is performing the measurement. Not the one of the proxy. What's more, stun is not using a proxy. Therefore, it does not make much sense that http IP resolvers use a proxy. This leads to inconsistencies. So, here's anothe reason why this patch is a good thing (TM). Finally, because knowing the IP address enables us to sanitize the data, it's important we discover the correct IP. Now, up until this point, the `--proxy` option has mostly been a developers toy. But, users have asked us to have the possibility of configuring a proxy. This explains why I have been looking into making `--proxy` right for a couple of hours now. See https://github.com/ooni/probe/issues/1382 * fix(session): properly configure the IP lookupper
123 lines
2.6 KiB
Go
123 lines
2.6 KiB
Go
package geolocate
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"math/rand"
|
|
"net"
|
|
"net/http"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/ooni/probe-cli/v3/internal/engine/internal/multierror"
|
|
"github.com/ooni/probe-cli/v3/internal/engine/netx"
|
|
)
|
|
|
|
var (
|
|
// ErrAllIPLookuppersFailed indicates that we failed with looking
|
|
// up the probe IP for with all the lookuppers that we tried.
|
|
ErrAllIPLookuppersFailed = errors.New("all IP lookuppers failed")
|
|
|
|
// ErrInvalidIPAddress indicates that the code returned to us a
|
|
// string that actually isn't a valid IP address.
|
|
ErrInvalidIPAddress = errors.New("lookupper did not return a valid IP")
|
|
)
|
|
|
|
type lookupFunc func(
|
|
ctx context.Context, client *http.Client,
|
|
logger Logger, userAgent string,
|
|
) (string, error)
|
|
|
|
type method struct {
|
|
name string
|
|
fn lookupFunc
|
|
}
|
|
|
|
var (
|
|
methods = []method{
|
|
{
|
|
name: "avast",
|
|
fn: avastIPLookup,
|
|
},
|
|
{
|
|
name: "ipconfig",
|
|
fn: ipConfigIPLookup,
|
|
},
|
|
{
|
|
name: "ipinfo",
|
|
fn: ipInfoIPLookup,
|
|
},
|
|
{
|
|
name: "stun_ekiga",
|
|
fn: stunEkigaIPLookup,
|
|
},
|
|
{
|
|
name: "stun_google",
|
|
fn: stunGoogleIPLookup,
|
|
},
|
|
{
|
|
name: "ubuntu",
|
|
fn: ubuntuIPLookup,
|
|
},
|
|
}
|
|
|
|
once sync.Once
|
|
)
|
|
|
|
type ipLookupClient struct {
|
|
// Resolver is the resolver to use for HTTP.
|
|
Resolver Resolver
|
|
|
|
// Logger is the logger to use
|
|
Logger Logger
|
|
|
|
// UserAgent is the user agent to use
|
|
UserAgent string
|
|
}
|
|
|
|
func makeSlice() []method {
|
|
r := rand.New(rand.NewSource(time.Now().UnixNano()))
|
|
ret := make([]method, len(methods))
|
|
perm := r.Perm(len(methods))
|
|
for idx, randIdx := range perm {
|
|
ret[idx] = methods[randIdx]
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (c ipLookupClient) doWithCustomFunc(
|
|
ctx context.Context, fn lookupFunc,
|
|
) (string, error) {
|
|
// Implementation note: we MUST use an HTTP client that we're
|
|
// sure IS NOT using any proxy. To this end, we construct a
|
|
// client ourself that we know is not proxied.
|
|
clnt := &http.Client{Transport: netx.NewHTTPTransport(netx.Config{
|
|
Logger: c.Logger,
|
|
FullResolver: c.Resolver,
|
|
})}
|
|
defer clnt.CloseIdleConnections()
|
|
ip, err := fn(ctx, clnt, c.Logger, c.UserAgent)
|
|
if err != nil {
|
|
return DefaultProbeIP, err
|
|
}
|
|
if net.ParseIP(ip) == nil {
|
|
return DefaultProbeIP, fmt.Errorf("%w: %s", ErrInvalidIPAddress, ip)
|
|
}
|
|
c.Logger.Debugf("iplookup: IP: %s", ip)
|
|
return ip, nil
|
|
}
|
|
|
|
func (c ipLookupClient) LookupProbeIP(ctx context.Context) (string, error) {
|
|
union := multierror.New(ErrAllIPLookuppersFailed)
|
|
for _, method := range makeSlice() {
|
|
c.Logger.Infof("iplookup: using %s", method.name)
|
|
ip, err := c.doWithCustomFunc(ctx, method.fn)
|
|
if err == nil {
|
|
return ip, nil
|
|
}
|
|
union.Add(err)
|
|
}
|
|
return DefaultProbeIP, union
|
|
}
|