349 lines
12 KiB
Java
349 lines
12 KiB
Java
/*
|
|
* Copyright © 2018 Samuel Holland <samuel@sholland.org>
|
|
* Copyright © 2018 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
package com.wireguard.config;
|
|
|
|
import android.databinding.BaseObservable;
|
|
import android.databinding.Bindable;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
|
|
import com.android.databinding.library.baseAdapters.BR;
|
|
import com.wireguard.crypto.KeyEncoding;
|
|
|
|
import java.net.Inet6Address;
|
|
import java.net.InetSocketAddress;
|
|
import java.net.URI;
|
|
import java.net.URISyntaxException;
|
|
import java.net.UnknownHostException;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
|
|
/**
|
|
* Represents the configuration for a WireGuard peer (a [Peer] block).
|
|
*/
|
|
|
|
public class Peer {
|
|
private final List<InetNetwork> allowedIPsList;
|
|
private InetSocketAddress endpoint;
|
|
private int persistentKeepalive;
|
|
private String preSharedKey;
|
|
private String publicKey;
|
|
|
|
public Peer() {
|
|
allowedIPsList = new ArrayList<>();
|
|
}
|
|
|
|
private void addAllowedIPs(final String[] allowedIPs) {
|
|
if (allowedIPs != null && allowedIPs.length > 0) {
|
|
for (final String allowedIP : allowedIPs) {
|
|
allowedIPsList.add(new InetNetwork(allowedIP));
|
|
}
|
|
}
|
|
}
|
|
|
|
public InetNetwork[] getAllowedIPs() {
|
|
return allowedIPsList.toArray(new InetNetwork[allowedIPsList.size()]);
|
|
}
|
|
|
|
private String getAllowedIPsString() {
|
|
if (allowedIPsList.isEmpty())
|
|
return null;
|
|
return Attribute.iterableToString(allowedIPsList);
|
|
}
|
|
|
|
public InetSocketAddress getEndpoint() {
|
|
return endpoint;
|
|
}
|
|
|
|
private String getEndpointString() {
|
|
if (endpoint == null)
|
|
return null;
|
|
return String.format(Locale.getDefault(), "%s:%d", endpoint.getHostString(), endpoint.getPort());
|
|
}
|
|
|
|
public int getPersistentKeepalive() {
|
|
return persistentKeepalive;
|
|
}
|
|
|
|
private String getPersistentKeepaliveString() {
|
|
if (persistentKeepalive == 0)
|
|
return null;
|
|
return Integer.valueOf(persistentKeepalive).toString();
|
|
}
|
|
|
|
public String getPreSharedKey() {
|
|
return preSharedKey;
|
|
}
|
|
|
|
public String getPublicKey() {
|
|
return publicKey;
|
|
}
|
|
|
|
public String getResolvedEndpointString() throws UnknownHostException {
|
|
if (endpoint == null)
|
|
throw new UnknownHostException("{empty}");
|
|
if (endpoint.isUnresolved())
|
|
endpoint = new InetSocketAddress(endpoint.getHostString(), endpoint.getPort());
|
|
if (endpoint.isUnresolved())
|
|
throw new UnknownHostException(endpoint.getHostString());
|
|
if (endpoint.getAddress() instanceof Inet6Address)
|
|
return String.format(Locale.getDefault(),
|
|
"[%s]:%d",
|
|
endpoint.getAddress().getHostAddress(),
|
|
endpoint.getPort());
|
|
return String.format(Locale.getDefault(),
|
|
"%s:%d",
|
|
endpoint.getAddress().getHostAddress(),
|
|
endpoint.getPort());
|
|
}
|
|
|
|
public void parse(final String line) {
|
|
final Attribute key = Attribute.match(line);
|
|
switch (key) {
|
|
case ALLOWED_IPS:
|
|
addAllowedIPs(key.parseList(line));
|
|
break;
|
|
case ENDPOINT:
|
|
setEndpointString(key.parse(line));
|
|
break;
|
|
case PERSISTENT_KEEPALIVE:
|
|
setPersistentKeepaliveString(key.parse(line));
|
|
break;
|
|
case PRESHARED_KEY:
|
|
setPreSharedKey(key.parse(line));
|
|
break;
|
|
case PUBLIC_KEY:
|
|
setPublicKey(key.parse(line));
|
|
break;
|
|
default:
|
|
throw new IllegalArgumentException(line);
|
|
}
|
|
}
|
|
|
|
private void setAllowedIPsString(final String allowedIPsString) {
|
|
allowedIPsList.clear();
|
|
addAllowedIPs(Attribute.stringToList(allowedIPsString));
|
|
}
|
|
|
|
private void setEndpoint(final InetSocketAddress endpoint) {
|
|
this.endpoint = endpoint;
|
|
}
|
|
|
|
private void setEndpointString(final String endpoint) {
|
|
if (endpoint != null && !endpoint.isEmpty()) {
|
|
final InetSocketAddress constructedEndpoint;
|
|
if (endpoint.indexOf('/') != -1 || endpoint.indexOf('?') != -1 || endpoint.indexOf('#') != -1)
|
|
throw new IllegalArgumentException("Forbidden characters in endpoint");
|
|
final URI uri;
|
|
try {
|
|
uri = new URI("wg://" + endpoint);
|
|
} catch (final URISyntaxException e) {
|
|
throw new IllegalArgumentException(e);
|
|
}
|
|
constructedEndpoint = InetSocketAddress.createUnresolved(uri.getHost(), uri.getPort());
|
|
setEndpoint(constructedEndpoint);
|
|
} else
|
|
setEndpoint(null);
|
|
}
|
|
|
|
private void setPersistentKeepalive(final int persistentKeepalive) {
|
|
this.persistentKeepalive = persistentKeepalive;
|
|
}
|
|
|
|
private void setPersistentKeepaliveString(final String persistentKeepalive) {
|
|
if (persistentKeepalive != null && !persistentKeepalive.isEmpty())
|
|
setPersistentKeepalive(Integer.parseInt(persistentKeepalive, 10));
|
|
else
|
|
setPersistentKeepalive(0);
|
|
}
|
|
|
|
private void setPreSharedKey(String preSharedKey) {
|
|
if (preSharedKey != null && preSharedKey.isEmpty())
|
|
preSharedKey = null;
|
|
if (preSharedKey != null)
|
|
KeyEncoding.keyFromBase64(preSharedKey);
|
|
this.preSharedKey = preSharedKey;
|
|
}
|
|
|
|
private void setPublicKey(String publicKey) {
|
|
if (publicKey != null && publicKey.isEmpty())
|
|
publicKey = null;
|
|
if (publicKey != null)
|
|
KeyEncoding.keyFromBase64(publicKey);
|
|
this.publicKey = publicKey;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
final StringBuilder sb = new StringBuilder().append("[Peer]\n");
|
|
if (!allowedIPsList.isEmpty())
|
|
sb.append(Attribute.ALLOWED_IPS.composeWith(allowedIPsList));
|
|
if (endpoint != null)
|
|
sb.append(Attribute.ENDPOINT.composeWith(getEndpointString()));
|
|
if (persistentKeepalive != 0)
|
|
sb.append(Attribute.PERSISTENT_KEEPALIVE.composeWith(persistentKeepalive));
|
|
if (preSharedKey != null)
|
|
sb.append(Attribute.PRESHARED_KEY.composeWith(preSharedKey));
|
|
if (publicKey != null)
|
|
sb.append(Attribute.PUBLIC_KEY.composeWith(publicKey));
|
|
return sb.toString();
|
|
}
|
|
|
|
public static class Observable extends BaseObservable implements Parcelable {
|
|
public static final Creator<Observable> CREATOR = new Creator<Observable>() {
|
|
@Override
|
|
public Observable createFromParcel(final Parcel in) {
|
|
return new Observable(in);
|
|
}
|
|
|
|
@Override
|
|
public Observable[] newArray(final int size) {
|
|
return new Observable[size];
|
|
}
|
|
};
|
|
private String allowedIPs;
|
|
private String endpoint;
|
|
private String persistentKeepalive;
|
|
private String preSharedKey;
|
|
private String publicKey;
|
|
|
|
public Observable(final Peer parent) {
|
|
loadData(parent);
|
|
}
|
|
|
|
private Observable(final Parcel in) {
|
|
allowedIPs = in.readString();
|
|
endpoint = in.readString();
|
|
persistentKeepalive = in.readString();
|
|
preSharedKey = in.readString();
|
|
publicKey = in.readString();
|
|
}
|
|
|
|
public static Observable newInstance() {
|
|
return new Observable(new Peer());
|
|
}
|
|
|
|
public void commitData(final Peer parent) {
|
|
parent.setAllowedIPsString(allowedIPs);
|
|
parent.setEndpointString(endpoint);
|
|
parent.setPersistentKeepaliveString(persistentKeepalive);
|
|
parent.setPreSharedKey(preSharedKey);
|
|
parent.setPublicKey(publicKey);
|
|
if (parent.getPublicKey() == null)
|
|
throw new IllegalArgumentException("Peer public key may not be empty");
|
|
loadData(parent);
|
|
notifyChange();
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
private static final String DEFAULT_ROUTE_V4 = "0.0.0.0/0";
|
|
private static final List<String> DEFAULT_ROUTE_MOD_RFC1918_V4 = Arrays.asList("0.0.0.0/5", "8.0.0.0/7", "11.0.0.0/8", "12.0.0.0/6", "16.0.0.0/4", "32.0.0.0/3", "64.0.0.0/2", "128.0.0.0/3", "160.0.0.0/5", "168.0.0.0/6", "172.0.0.0/12", "172.32.0.0/11", "172.64.0.0/10", "172.128.0.0/9", "173.0.0.0/8", "174.0.0.0/7", "176.0.0.0/4", "192.0.0.0/9", "192.128.0.0/11", "192.160.0.0/13", "192.169.0.0/16", "192.170.0.0/15", "192.172.0.0/14", "192.176.0.0/12", "192.192.0.0/10", "193.0.0.0/8", "194.0.0.0/7", "196.0.0.0/6", "200.0.0.0/5", "208.0.0.0/4");
|
|
|
|
public void toggleExcludePrivateIPs() {
|
|
final HashSet<String> ips = new HashSet<>(Arrays.asList(Attribute.stringToList(allowedIPs)));
|
|
final boolean hasDefaultRoute = ips.contains(DEFAULT_ROUTE_V4);
|
|
final boolean hasDefaultRouteModRFC1918 = ips.containsAll(DEFAULT_ROUTE_MOD_RFC1918_V4);
|
|
if (hasDefaultRoute && hasDefaultRouteModRFC1918)
|
|
ips.removeAll(DEFAULT_ROUTE_MOD_RFC1918_V4);
|
|
else if (hasDefaultRoute) {
|
|
ips.remove(DEFAULT_ROUTE_V4);
|
|
ips.addAll(DEFAULT_ROUTE_MOD_RFC1918_V4);
|
|
} else if (hasDefaultRouteModRFC1918) {
|
|
ips.removeAll(DEFAULT_ROUTE_MOD_RFC1918_V4);
|
|
ips.add(DEFAULT_ROUTE_V4);
|
|
}
|
|
setAllowedIPs(Attribute.iterableToString(ips));
|
|
}
|
|
|
|
@Bindable
|
|
public String getAllowedIPs() {
|
|
return allowedIPs;
|
|
}
|
|
|
|
@Bindable
|
|
public boolean getAllowedIPsContainsDefaultRoute() {
|
|
return Arrays.asList(Attribute.stringToList(allowedIPs)).contains(DEFAULT_ROUTE_V4);
|
|
}
|
|
|
|
@Bindable
|
|
public boolean getAllowedIPsContainsDefaultRouteModRFC1918() {
|
|
return Arrays.asList(Attribute.stringToList(allowedIPs)).containsAll(DEFAULT_ROUTE_MOD_RFC1918_V4);
|
|
}
|
|
|
|
@Bindable
|
|
public String getEndpoint() {
|
|
return endpoint;
|
|
}
|
|
|
|
@Bindable
|
|
public String getPersistentKeepalive() {
|
|
return persistentKeepalive;
|
|
}
|
|
|
|
@Bindable
|
|
public String getPreSharedKey() {
|
|
return preSharedKey;
|
|
}
|
|
|
|
@Bindable
|
|
public String getPublicKey() {
|
|
return publicKey;
|
|
}
|
|
|
|
protected void loadData(final Peer parent) {
|
|
allowedIPs = parent.getAllowedIPsString();
|
|
endpoint = parent.getEndpointString();
|
|
persistentKeepalive = parent.getPersistentKeepaliveString();
|
|
preSharedKey = parent.getPreSharedKey();
|
|
publicKey = parent.getPublicKey();
|
|
}
|
|
|
|
public void setAllowedIPs(final String allowedIPs) {
|
|
this.allowedIPs = allowedIPs;
|
|
notifyPropertyChanged(BR.allowedIPs);
|
|
notifyPropertyChanged(BR.allowedIPsContainsDefaultRoute);
|
|
notifyPropertyChanged(BR.allowedIPsContainsDefaultRouteModRFC1918);
|
|
}
|
|
|
|
public void setEndpoint(final String endpoint) {
|
|
this.endpoint = endpoint;
|
|
notifyPropertyChanged(BR.endpoint);
|
|
}
|
|
|
|
public void setPersistentKeepalive(final String persistentKeepalive) {
|
|
this.persistentKeepalive = persistentKeepalive;
|
|
notifyPropertyChanged(BR.persistentKeepalive);
|
|
}
|
|
|
|
public void setPreSharedKey(final String preSharedKey) {
|
|
this.preSharedKey = preSharedKey;
|
|
notifyPropertyChanged(BR.preSharedKey);
|
|
}
|
|
|
|
public void setPublicKey(final String publicKey) {
|
|
this.publicKey = publicKey;
|
|
notifyPropertyChanged(BR.publicKey);
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(final Parcel dest, final int flags) {
|
|
dest.writeString(allowedIPs);
|
|
dest.writeString(endpoint);
|
|
dest.writeString(persistentKeepalive);
|
|
dest.writeString(preSharedKey);
|
|
dest.writeString(publicKey);
|
|
}
|
|
}
|
|
}
|