因此，我正在阅读使用此处指南中的应用程序连接到 VPN 的指南 。我真正想要的是通过使用互联网上的免费 DNS 来制作我自己的 VPN 应用程序。因为我想要 DoH（通过 Https 的 DNS）和完全的安全性。所以，我希望 CleanBrowsing 成为我的 DNS。（我知道已经有一个应用程序，但我想从头开始）。所以我去了这个CleanBrowsing DNS GUIDE。我正在使用他们提供的以下免费过滤器
family-filter-dns.cleanbrowsing.org
所以，我可以将我的隧道连接到服务器，但是当我打开浏览器时它什么也没做。这是此处配置的迷你版。
final SocketAddress serverAddress = new InetSocketAddress("family-filter-dns.cleanbrowsing.org", 53);
VpnService.Builder builder = mService.new Builder();
builder.addAddress("10.1.10.1", 32);
builder.addDnsServer("185.228.168.168");
builder.addDnsServer("9.9.9.9");
builder.addRoute("0.0.0.0", 0);
builder.setMtu(1000);
我的完整文件如下所示
public ToyVpnConnection(final VpnService service, final int connectionId,
final String serverName, final int serverPort, final byte[] sharedSecret,
final String proxyHostName, final int proxyHostPort, boolean allow,
final Set<String> packages) {
mService = service;
mConnectionId = connectionId;
mServerName = serverName;
mServerPort = serverPort;
mSharedSecret = sharedSecret;
if (!TextUtils.isEmpty(proxyHostName)) {
mProxyHostName = proxyHostName;
}
if (proxyHostPort > 0) {
// The port value is always an integer due to the configured inputType.
mProxyHostPort = proxyHostPort;
}
mAllow = allow;
mPackages = packages;
}
/**
* Optionally, set an intent to configure the VPN. This is {@code null} by default.
*/
public void setConfigureIntent(PendingIntent intent) {
mConfigureIntent = intent;
}
public void setOnEstablishListener(OnEstablishListener listener) {
mOnEstablishListener = listener;
}
@Override
public void run() {
try {
Log.i(getTag(), "Starting");
// If anything needs to be obtained using the network, get it now.
// This greatly reduces the complexity of seamless handover, which
// tries to recreate the tunnel without shutting down everything.
// In this demo, all we need to know is the server address.
final SocketAddress serverAddress = new InetSocketAddress("family-filter-dns.cleanbrowsing.org", 53);
// We try to create the tunnel several times.
// TODO: The better way is to work with ConnectivityManager, trying only when the
// network is available.
// Here we just use a counter to keep things simple.
// for (int attempt = 0; attempt < 10; ++attempt) {
// Reset the counter if we were connected.
if (run(serverAddress)) {
// attempt = 0;
}
// Sleep for a while. This also checks if we got interrupted.
// Thread.sleep(3000);
// }
Log.i(getTag(), "Giving up");
} catch (IOException | InterruptedException | IllegalArgumentException e) {
Log.e(getTag(), "Connection failed, exiting", e);
}
}
private static final String TAG = "ToyVpnConnection";
private boolean run(SocketAddress server)
throws IOException, InterruptedException, IllegalArgumentException {
ParcelFileDescriptor iface = null;
boolean connected = false;
// Create a DatagramChannel as the VPN tunnel.
try (DatagramChannel tunnel = DatagramChannel.open()) {
// Protect the tunnel before connecting to avoid loopback.
if (!mService.protect(tunnel.socket())) {
throw new IllegalStateException("Cannot protect the tunnel");
}
// Connect to the server.
tunnel.connect(server);
Log.d(TAG, "run: connected to the tunnel");
// For simplicity, we use the same thread for both reading and
// writing. Here we put the tunnel into non-blocking mode.
tunnel.configureBlocking(false);
// Authenticate and configure the virtual network interface.
iface = configure("");
// Now we are connected. Set the flag.
connected = true;
// Packets to be sent are queued in this input stream.
FileInputStream in = new FileInputStream(iface.getFileDescriptor());
// Packets received need to be written to this output stream.
FileOutputStream out = new FileOutputStream(iface.getFileDescriptor());
// Allocate the buffer for a single packet.
ByteBuffer packet = ByteBuffer.allocate(MAX_PACKET_SIZE);
// Timeouts:
// - when data has not been sent in a while, send empty keepalive messages.
// - when data has not been received in a while, assume the connection is broken.
long lastSendTime = System.currentTimeMillis();
long lastReceiveTime = System.currentTimeMillis();
// We keep forwarding packets till something goes wrong.
while (true) {
// Assume that we did not make any progress in this iteration.
boolean idle = true;
// Read the outgoing packet from the input stream.
int length = in.read(packet.array());
if (length > 0) {
// Write the outgoing packet to the tunnel.
packet.limit(length);
tunnel.write(packet);
packet.clear();
// There might be more outgoing packets.
idle = false;
lastReceiveTime = System.currentTimeMillis();
}
// Read the incoming packet from the tunnel.
length = tunnel.read(packet);
if (length > 0) {
// Ignore control messages, which start with zero.
if (packet.get(0) != 0) {
// Write the incoming packet to the output stream.
out.write(packet.array(), 0, length);
}
packet.clear();
// There might be more incoming packets.
idle = false;
lastSendTime = System.currentTimeMillis();
}
// If we are idle or waiting for the network, sleep for a
// fraction of time to avoid busy looping.
if (idle) {
Thread.sleep(IDLE_INTERVAL_MS);
final long timeNow = System.currentTimeMillis();
if (lastSendTime + KEEPALIVE_INTERVAL_MS <= timeNow) {
// We are receiving for a long time but not sending.
// Send empty control messages.
packet.put((byte) 0).limit(1);
for (int i = 0; i < 3; ++i) {
packet.position(0);
tunnel.write(packet);
}
packet.clear();
lastSendTime = timeNow;
} else if (lastReceiveTime + RECEIVE_TIMEOUT_MS <= timeNow) {
// We are sending for a long time but not receiving.
throw new IllegalStateException("Timed out");
}
}
}
} catch (SocketException e) {
Log.e(getTag(), "Cannot use socket", e);
} finally {
if (iface != null) {
try {
iface.close();
} catch (IOException e) {
Log.e(getTag(), "Unable to close interface", e);
}
}
}
return connected;
}
private ParcelFileDescriptor handshake(DatagramChannel tunnel)
throws IOException, InterruptedException {
// To build a secured tunnel, we should perform mutual authentication
// and exchange session keys for encryption. To keep things simple in
// this demo, we just send the shared secret in plaintext and wait
// for the server to send the parameters.
// Allocate the buffer for handshaking. We have a hardcoded maximum
// handshake size of 1024 bytes, which should be enough for demo
// purposes.
ByteBuffer packet = ByteBuffer.allocate(1024);
// Control messages always start with zero.
packet.put((byte) 0).put(mSharedSecret).flip();
// Send the secret several times in case of packet loss.
for (int i = 0; i < 3; ++i) {
packet.position(0);
tunnel.write(packet);
}
packet.clear();
return configure(new String());
// Wait for the parameters within a limited time.
// for (int i = 0; i < MAX_HANDSHAKE_ATTEMPTS; ++i) {
// Thread.sleep(IDLE_INTERVAL_MS);
//
// // Normally we should not receive random packets. Check that the first
// // byte is 0 as expected.
// int length = tunnel.read(packet);
// if (length > 0 && packet.get(0) == 0) {
//
// }
// }
// throw new IOException("Timed out");
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
private ParcelFileDescriptor configure(String parameters) throws IllegalArgumentException {
// Configure a builder while parsing the parameters.
VpnService.Builder builder = mService.new Builder();
builder.addAddress("10.1.10.1", 32);
// builder.addAddress("185.228.148.168", 32);
// builder.addAddress("192.168.1.1", 24);
builder.addDnsServer("185.228.168.168");
builder.addDnsServer("9.9.9.9");
builder.addRoute("0.0.0.0", 0);
builder.setMtu(1000);
// Create a new interface using the builder and save the parameters.
final ParcelFileDescriptor vpnInterface;
try {
builder.addDisallowedApplication("com.example.android.toyvpn");
} catch (PackageManager.NameNotFoundException e) {
Log.w(getTag(), "Package not available: " + "packageName", e);
}
// for (String packageName : mPackages) {
// try {
// if (mAllow) {
// builder.addAllowedApplication(packageName);
// } else {
//
// }
// } catch (PackageManager.NameNotFoundException e){
//
// }
// }
builder.setSession(mServerName).setConfigureIntent(mConfigureIntent);
if (!TextUtils.isEmpty(mProxyHostName)) {
// builder.setHttpProxy(ProxyInfo.buildDirectProxy(mProxyHostName, mProxyHostPort));
}
synchronized (mService) {
vpnInterface = builder.establish();
if (mOnEstablishListener != null) {
mOnEstablishListener.onEstablish(vpnInterface);
}
}
Log.i(getTag(), "New interface: " + vpnInterface + " (" + parameters + ")");
return vpnInterface;
}
private final String getTag() {
return ToyVpnConnection.class.getSimpleName() + "[" + mConnectionId + "]";
}
}