-
Notifications
You must be signed in to change notification settings - Fork 125
/
CharonVpnService.java
1129 lines (1039 loc) · 44.2 KB
/
CharonVpnService.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* Copyright (C) 2012-2018 Tobias Brunner
* Copyright (C) 2012 Giuliano Grassi
* Copyright (C) 2012 Ralf Sager
* HSR Hochschule fuer Technik Rapperswil
* Copyright (C) 2018-2019 Jason C.H
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*/
package org.strongswan.android.logic;
import android.annotation.TargetApi;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.Service;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.PackageManager;
import android.net.VpnService;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.ParcelFileDescriptor;
import android.security.KeyChain;
import android.security.KeyChainException;
import android.system.OsConstants;
import android.util.Log;
import org.strongswan.android.data.VpnProfile;
import org.strongswan.android.data.VpnProfile.SelectedAppsHandling;
import org.strongswan.android.data.VpnType;
import org.strongswan.android.data.VpnType.VpnTypeFeature;
import org.strongswan.android.logic.VpnStateService.ErrorState;
import org.strongswan.android.logic.VpnStateService.State;
import org.strongswan.android.logic.imc.ImcState;
import org.strongswan.android.logic.imc.RemediationInstruction;
import org.strongswan.android.utils.Constants;
import org.strongswan.android.utils.IPRange;
import org.strongswan.android.utils.IPRangeSet;
import org.strongswan.android.utils.SettingsWriter;
import org.strongswan.android.utils.Utils;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedByInterruptException;
import java.security.PrivateKey;
import java.security.cert.CertificateEncodingException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.SortedSet;
import java.util.UUID;
import androidx.core.app.NotificationCompat;
import androidx.core.content.ContextCompat;
import io.xdea.flutter_vpn.R;
public class CharonVpnService extends VpnService implements Runnable, VpnStateService.VpnStateListener {
private static final String TAG = CharonVpnService.class.getSimpleName();
private static final String VPN_SERVICE_ACTION = "android.net.VpnService";
public static final String DISCONNECT_ACTION = "org.strongswan.android.CharonVpnService.DISCONNECT";
private static final String NOTIFICATION_CHANNEL = "org.strongswan.android.CharonVpnService.VPN_STATE_NOTIFICATION";
public static final String LOG_FILE = "charon.log";
public static final String KEY_IS_RETRY = "retry";
public static final int VPN_STATE_NOTIFICATION_ID = 1;
private String mLogFile;
private String mAppDir;
//private VpnProfileDataSource mDataSource;
private Thread mConnectionHandler;
private VpnProfile mCurrentProfile;
private volatile String mCurrentCertificateAlias;
private volatile String mCurrentUserCertificateAlias;
private VpnProfile mNextProfile;
private volatile boolean mProfileUpdated;
private volatile boolean mTerminate;
private volatile boolean mIsDisconnecting;
private volatile boolean mShowNotification;
private BuilderAdapter mBuilderAdapter = new BuilderAdapter();
private Handler mHandler;
private VpnStateService mService;
private final Object mServiceLock = new Object();
private final ServiceConnection mServiceConnection = new ServiceConnection() {
@Override
public void onServiceDisconnected(ComponentName name) { /* since the service is local this is theoretically only called when the process is terminated */
synchronized (mServiceLock) {
mService = null;
}
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
synchronized (mServiceLock) {
mService = ((VpnStateService.LocalBinder) service).getService();
}
/* we are now ready to start the handler thread */
mService.registerListener(CharonVpnService.this);
mConnectionHandler.start();
}
};
/**
* as defined in charonservice.h
*/
static final int STATE_CHILD_SA_UP = 1;
static final int STATE_CHILD_SA_DOWN = 2;
static final int STATE_AUTH_ERROR = 3;
static final int STATE_PEER_AUTH_ERROR = 4;
static final int STATE_LOOKUP_ERROR = 5;
static final int STATE_UNREACHABLE_ERROR = 6;
static final int STATE_CERTIFICATE_UNAVAILABLE = 7;
static final int STATE_GENERIC_ERROR = 8;
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (intent != null) {
VpnProfile profile = null;
boolean retry = false;
if (VPN_SERVICE_ACTION.equals(intent.getAction()) || !DISCONNECT_ACTION.equals(intent.getAction())) {
Bundle bundle = intent.getExtras();
if (bundle != null) {
profile = new VpnProfile();
profile.setId(1);
profile.setUUID(UUID.randomUUID());
profile.setName(bundle.getString("Name"));
// Global
profile.setMTU(bundle.getInt("MTU", 1400));
// Connection
profile.setGateway(bundle.getString("Server"));
if (bundle.containsKey("Port")) profile.setPort(bundle.getInt("Port"));
profile.setUsername(bundle.getString("Username"));
profile.setPassword(bundle.getString("Password"));
profile.setLocalId(bundle.getString("LocalId"));
profile.setRemoteId(bundle.getString("RemoteId"));
profile.setVpnType(VpnType.fromIdentifier(bundle.getString("VpnType")));
profile.setSelectedAppsHandling(SelectedAppsHandling.SELECTED_APPS_DISABLE);
profile.setFlags(0);
retry = bundle.getBoolean(CharonVpnService.KEY_IS_RETRY, false);
}
}
if (profile != null && !retry) { /* delete the log file if this is not an automatic retry */
deleteFile(LOG_FILE);
}
setNextProfile(profile);
}
return START_NOT_STICKY;
}
@Override
public void onCreate() {
mLogFile = getFilesDir().getAbsolutePath() + File.separator + LOG_FILE;
mAppDir = getFilesDir().getAbsolutePath();
/* handler used to do changes in the main UI thread */
mHandler = new Handler(getMainLooper());
/* use a separate thread as main thread for charon */
mConnectionHandler = new Thread(this);
/* the thread is started when the service is bound */
bindService(new Intent(this, VpnStateService.class),
mServiceConnection, Service.BIND_AUTO_CREATE);
createNotificationChannel();
}
@Override
public void onRevoke() { /* the system revoked the rights grated with the initial prepare() call.
* called when the user clicks disconnect in the system's VPN dialog */
setNextProfile(null);
}
@Override
public void onDestroy() {
mTerminate = true;
setNextProfile(null);
try {
mConnectionHandler.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
if (mService != null) {
mService.unregisterListener(this);
unbindService(mServiceConnection);
}
}
/**
* Set the profile that is to be initiated next. Notify the handler thread.
*
* @param profile the profile to initiate
*/
private void setNextProfile(VpnProfile profile) {
synchronized (this) {
this.mNextProfile = profile;
mProfileUpdated = true;
notifyAll();
}
}
@Override
public void run() {
while (true) {
synchronized (this) {
try {
while (!mProfileUpdated) {
wait();
}
mProfileUpdated = false;
stopCurrentConnection();
if (mNextProfile == null) {
setState(State.DISABLED);
if (mTerminate) {
break;
}
} else {
mCurrentProfile = mNextProfile;
mNextProfile = null;
/* store this in a separate (volatile) variable to avoid
* a possible deadlock during deinitialization */
mCurrentCertificateAlias = mCurrentProfile.getCertificateAlias();
mCurrentUserCertificateAlias = mCurrentProfile.getUserCertificateAlias();
startConnection(mCurrentProfile);
mIsDisconnecting = false;
SimpleFetcher.enable();
addNotification();
mBuilderAdapter.setProfile(mCurrentProfile);
if (initializeCharon(mBuilderAdapter, mLogFile, mAppDir, mCurrentProfile.getVpnType().has(VpnTypeFeature.BYOD),
(mCurrentProfile.getFlags() & VpnProfile.FLAGS_IPv6_TRANSPORT) != 0)) {
Log.i(TAG, "charon started");
if (mCurrentProfile.getVpnType().has(VpnTypeFeature.USER_PASS) &&
mCurrentProfile.getPassword() == null) { /* this can happen if Always-on VPN is enabled with an incomplete profile */
setError(ErrorState.PASSWORD_MISSING);
continue;
}
SettingsWriter writer = new SettingsWriter();
writer.setValue("global.language", Locale.getDefault().getLanguage());
writer.setValue("global.mtu", mCurrentProfile.getMTU());
writer.setValue("global.nat_keepalive", mCurrentProfile.getNATKeepAlive());
writer.setValue("global.rsa_pss", (mCurrentProfile.getFlags() & VpnProfile.FLAGS_RSA_PSS) != 0);
writer.setValue("global.crl", (mCurrentProfile.getFlags() & VpnProfile.FLAGS_DISABLE_CRL) == 0);
writer.setValue("global.ocsp", (mCurrentProfile.getFlags() & VpnProfile.FLAGS_DISABLE_OCSP) == 0);
writer.setValue("connection.type", mCurrentProfile.getVpnType().getIdentifier());
writer.setValue("connection.server", mCurrentProfile.getGateway());
writer.setValue("connection.port", mCurrentProfile.getPort());
writer.setValue("connection.username", mCurrentProfile.getUsername());
writer.setValue("connection.password", mCurrentProfile.getPassword());
writer.setValue("connection.local_id", mCurrentProfile.getLocalId());
writer.setValue("connection.remote_id", mCurrentProfile.getRemoteId());
writer.setValue("connection.certreq", (mCurrentProfile.getFlags() & VpnProfile.FLAGS_SUPPRESS_CERT_REQS) == 0);
writer.setValue("connection.strict_revocation", (mCurrentProfile.getFlags() & VpnProfile.FLAGS_STRICT_REVOCATION) != 0);
writer.setValue("connection.ike_proposal", mCurrentProfile.getIkeProposal());
writer.setValue("connection.esp_proposal", mCurrentProfile.getEspProposal());
initiate(writer.serialize());
} else {
Log.e(TAG, "failed to start charon");
setError(ErrorState.GENERIC_ERROR);
setState(State.DISABLED);
mCurrentProfile = null;
}
}
} catch (InterruptedException ex) {
stopCurrentConnection();
setState(State.DISABLED);
}
}
}
}
/**
* Stop any existing connection by deinitializing charon.
*/
private void stopCurrentConnection() {
synchronized (this) {
if (mNextProfile != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
mBuilderAdapter.setProfile(mNextProfile);
mBuilderAdapter.establishBlocking();
}
if (mCurrentProfile != null) {
setState(State.DISCONNECTING);
mIsDisconnecting = true;
SimpleFetcher.disable();
deinitializeCharon();
Log.i(TAG, "charon stopped");
mCurrentProfile = null;
if (mNextProfile == null) { /* only do this if we are not connecting to another profile */
removeNotification();
mBuilderAdapter.closeBlocking();
}
}
}
}
/**
* Add a permanent notification while we are connected to avoid the service getting killed by
* the system when low on memory.
*/
private void addNotification() {
mHandler.post(new Runnable() {
@Override
public void run() {
mShowNotification = true;
startForeground(VPN_STATE_NOTIFICATION_ID, buildNotification(false));
}
});
}
/**
* Remove the permanent notification.
*/
private void removeNotification() {
mHandler.post(new Runnable() {
@Override
public void run() {
mShowNotification = false;
stopForeground(true);
}
});
}
/**
* Create a notification channel for Android 8+
*/
private void createNotificationChannel() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
NotificationChannel channel;
channel = new NotificationChannel(NOTIFICATION_CHANNEL, getString(R.string.permanent_notification_name),
NotificationManager.IMPORTANCE_LOW);
channel.setDescription(getString(R.string.permanent_notification_description));
channel.setLockscreenVisibility(Notification.VISIBILITY_SECRET);
channel.setShowBadge(false);
NotificationManager notificationManager = getSystemService(NotificationManager.class);
notificationManager.createNotificationChannel(channel);
}
}
/**
* Build a notification matching the current state
*/
private Notification buildNotification(boolean publicVersion) {
VpnProfile profile = mService.getProfile();
State state = mService.getState();
ErrorState error = mService.getErrorState();
String name = "";
boolean add_action = false;
if (profile != null) {
name = profile.getName();
}
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, NOTIFICATION_CHANNEL)
.setSmallIcon(R.drawable.ic_notification)
.setCategory(NotificationCompat.CATEGORY_SERVICE)
.setVisibility(publicVersion ? NotificationCompat.VISIBILITY_PUBLIC
: NotificationCompat.VISIBILITY_PRIVATE);
int s = R.string.state_disabled;
if (error != ErrorState.NO_ERROR) {
s = mService.getErrorText();
builder.setSmallIcon(R.drawable.ic_notification_warning);
builder.setColor(ContextCompat.getColor(this, R.color.error_text));
if (!publicVersion && profile != null) {
int retry = mService.getRetryIn();
if (retry > 0) {
builder.setContentText(getResources().getQuantityString(R.plurals.retry_in, retry, retry));
builder.setProgress(mService.getRetryTimeout(), retry, false);
}
// Intent intent = new Intent(getApplicationContext(), VpnProfileControlActivity.class);
// intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// intent.setAction(VpnProfileControlActivity.START_PROFILE);
// intent.putExtra(VpnProfileControlActivity.EXTRA_VPN_PROFILE_ID, profile.getUUID().toString());
// PendingIntent pending = PendingIntent.getActivity(getApplicationContext(), 0, intent,
// PendingIntent.FLAG_UPDATE_CURRENT);
// builder.addAction(R.drawable.ic_notification_connecting, getString(R.string.retry), pending);
add_action = true;
}
} else {
builder.setProgress(0, 0, false);
switch (state) {
case CONNECTING:
s = R.string.state_connecting;
builder.setSmallIcon(R.drawable.ic_notification_connecting);
builder.setColor(ContextCompat.getColor(this, R.color.warning_text));
add_action = true;
break;
case CONNECTED:
s = R.string.state_connected;
builder.setColor(ContextCompat.getColor(this, R.color.success_text));
builder.setUsesChronometer(true);
add_action = true;
break;
case DISCONNECTING:
s = R.string.state_disconnecting;
break;
}
}
builder.setContentTitle(getString(s));
if (!publicVersion) {
// if (add_action) {
// Intent intent = new Intent(getApplicationContext(), VpnProfileControlActivity.class);
// intent.setAction(VpnProfileControlActivity.DISCONNECT);
// PendingIntent pending = PendingIntent.getActivity(getApplicationContext(), 0, intent,
// PendingIntent.FLAG_UPDATE_CURRENT);
// builder.addAction(R.drawable.ic_notification_disconnect, getString(R.string.disconnect), pending);
// }
if (error == ErrorState.NO_ERROR) {
builder.setContentText(name);
}
builder.setPublicVersion(buildNotification(true));
}
// Intent intent = new Intent(getApplicationContext(), MainActivity.class);
// PendingIntent pending = PendingIntent.getActivity(getApplicationContext(), 0, intent,
// PendingIntent.FLAG_UPDATE_CURRENT);
// builder.setContentIntent(pending);
return builder.build();
}
@Override
public void stateChanged() {
if (mShowNotification) {
NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
manager.notify(VPN_STATE_NOTIFICATION_ID, buildNotification(false));
}
}
/**
* Notify the state service about a new connection attempt.
* Called by the handler thread.
*
* @param profile currently active VPN profile
*/
private void startConnection(VpnProfile profile) {
synchronized (mServiceLock) {
if (mService != null) {
mService.startConnection(profile);
}
}
}
/**
* Update the current VPN state on the state service. Called by the handler
* thread and any of charon's threads.
*
* @param state current state
*/
private void setState(State state) {
synchronized (mServiceLock) {
if (mService != null) {
mService.setState(state);
}
}
}
/**
* Set an error on the state service. Called by the handler thread and any
* of charon's threads.
*
* @param error error state
*/
private void setError(ErrorState error) {
synchronized (mServiceLock) {
if (mService != null) {
mService.setError(error);
}
}
}
/**
* Set the IMC state on the state service. Called by the handler thread and
* any of charon's threads.
*
* @param state IMC state
*/
private void setImcState(ImcState state) {
synchronized (mServiceLock) {
if (mService != null) {
mService.setImcState(state);
}
}
}
/**
* Set an error on the state service. Called by the handler thread and any
* of charon's threads.
*
* @param error error state
*/
private void setErrorDisconnect(ErrorState error) {
synchronized (mServiceLock) {
if (mService != null) {
if (!mIsDisconnecting) {
mService.setError(error);
}
}
}
}
/**
* Updates the state of the current connection.
* Called via JNI by different threads (but not concurrently).
*
* @param status new state
*/
public void updateStatus(int status) {
switch (status) {
case STATE_CHILD_SA_DOWN:
if (!mIsDisconnecting) {
setState(State.CONNECTING);
}
break;
case STATE_CHILD_SA_UP:
setState(State.CONNECTED);
break;
case STATE_AUTH_ERROR:
setErrorDisconnect(ErrorState.AUTH_FAILED);
break;
case STATE_PEER_AUTH_ERROR:
setErrorDisconnect(ErrorState.PEER_AUTH_FAILED);
break;
case STATE_LOOKUP_ERROR:
setErrorDisconnect(ErrorState.LOOKUP_FAILED);
break;
case STATE_UNREACHABLE_ERROR:
setErrorDisconnect(ErrorState.UNREACHABLE);
break;
case STATE_CERTIFICATE_UNAVAILABLE:
setErrorDisconnect(ErrorState.CERTIFICATE_UNAVAILABLE);
break;
case STATE_GENERIC_ERROR:
setErrorDisconnect(ErrorState.GENERIC_ERROR);
break;
default:
Log.e(TAG, "Unknown status code received");
break;
}
}
/**
* Updates the IMC state of the current connection.
* Called via JNI by different threads (but not concurrently).
*
* @param value new state
*/
public void updateImcState(int value) {
ImcState state = ImcState.fromValue(value);
if (state != null) {
setImcState(state);
}
}
/**
* Add a remediation instruction to the VPN state service.
* Called via JNI by different threads (but not concurrently).
*
* @param xml XML text
*/
public void addRemediationInstruction(String xml) {
for (RemediationInstruction instruction : RemediationInstruction.fromXml(xml)) {
synchronized (mServiceLock) {
if (mService != null) {
mService.addRemediationInstruction(instruction);
}
}
}
}
/**
* Function called via JNI to generate a list of DER encoded CA certificates
* as byte array.
*
* @return a list of DER encoded CA certificates
*/
private byte[][] getTrustedCertificates() {
ArrayList<byte[]> certs = new ArrayList<byte[]>();
TrustedCertificateManager certman = TrustedCertificateManager.getInstance().load();
try {
String alias = this.mCurrentCertificateAlias;
if (alias != null) {
X509Certificate cert = certman.getCACertificateFromAlias(alias);
if (cert == null) {
return null;
}
certs.add(cert.getEncoded());
} else {
for (X509Certificate cert : certman.getAllCACertificates().values()) {
certs.add(cert.getEncoded());
}
}
} catch (CertificateEncodingException e) {
e.printStackTrace();
return null;
}
return certs.toArray(new byte[certs.size()][]);
}
/**
* Function called via JNI to get a list containing the DER encoded certificates
* of the user selected certificate chain (beginning with the user certificate).
* <p>
* Since this method is called from a thread of charon's thread pool we are safe
* to call methods on KeyChain directly.
*
* @return list containing the certificates (first element is the user certificate)
* @throws InterruptedException
* @throws KeyChainException
* @throws CertificateEncodingException
*/
private byte[][] getUserCertificate() throws KeyChainException, InterruptedException, CertificateEncodingException {
ArrayList<byte[]> encodings = new ArrayList<byte[]>();
X509Certificate[] chain = KeyChain.getCertificateChain(getApplicationContext(), mCurrentUserCertificateAlias);
if (chain == null || chain.length == 0) {
return null;
}
for (X509Certificate cert : chain) {
encodings.add(cert.getEncoded());
}
return encodings.toArray(new byte[encodings.size()][]);
}
/**
* Function called via JNI to get the private key the user selected.
* <p>
* Since this method is called from a thread of charon's thread pool we are safe
* to call methods on KeyChain directly.
*
* @return the private key
* @throws InterruptedException
* @throws KeyChainException
*/
private PrivateKey getUserKey() throws KeyChainException, InterruptedException {
return KeyChain.getPrivateKey(getApplicationContext(), mCurrentUserCertificateAlias);
}
/**
* Initialization of charon, provided by libandroidbridge.so
*
* @param builder BuilderAdapter for this connection
* @param logfile absolute path to the logfile
* @param appdir absolute path to the data directory of the app
* @param byod enable BYOD features
* @param ipv6 enable IPv6 transport
* @return TRUE if initialization was successful
*/
public native boolean initializeCharon(BuilderAdapter builder, String logfile, String appdir, boolean byod, boolean ipv6);
/**
* Deinitialize charon, provided by libandroidbridge.so
*/
public native void deinitializeCharon();
/**
* Initiate VPN, provided by libandroidbridge.so
*/
public native void initiate(String config);
/**
* Adapter for VpnService.Builder which is used to access it safely via JNI.
* There is a corresponding C object to access it from native code.
*/
public class BuilderAdapter {
private VpnProfile mProfile;
private VpnService.Builder mBuilder;
private BuilderCache mCache;
private BuilderCache mEstablishedCache;
private PacketDropper mDropper = new PacketDropper();
public synchronized void setProfile(VpnProfile profile) {
mProfile = profile;
mBuilder = createBuilder(mProfile.getName());
mCache = new BuilderCache(mProfile);
}
private VpnService.Builder createBuilder(String name) {
VpnService.Builder builder = new CharonVpnService.Builder();
builder.setSession(name);
/* mark all VPN connections as unmetered (default changed for Android 10) */
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
builder.setMetered(false);
}
return builder;
}
public synchronized boolean addAddress(String address, int prefixLength) {
try {
mCache.addAddress(address, prefixLength);
} catch (IllegalArgumentException ex) {
return false;
}
return true;
}
public synchronized boolean addDnsServer(String address) {
try {
mCache.addDnsServer(address);
} catch (IllegalArgumentException ex) {
return false;
}
return true;
}
public synchronized boolean addRoute(String address, int prefixLength) {
try {
mCache.addRoute(address, prefixLength);
} catch (IllegalArgumentException ex) {
return false;
}
return true;
}
public synchronized boolean addSearchDomain(String domain) {
try {
mBuilder.addSearchDomain(domain);
} catch (IllegalArgumentException ex) {
return false;
}
return true;
}
public synchronized boolean setMtu(int mtu) {
try {
mCache.setMtu(mtu);
} catch (IllegalArgumentException ex) {
return false;
}
return true;
}
private synchronized ParcelFileDescriptor establishIntern() {
ParcelFileDescriptor fd;
try {
mCache.applyData(mBuilder);
fd = mBuilder.establish();
if (fd != null) {
closeBlocking();
}
} catch (Exception ex) {
ex.printStackTrace();
return null;
}
if (fd == null) {
return null;
}
/* now that the TUN device is created we don't need the current
* builder anymore, but we might need another when reestablishing */
mBuilder = createBuilder(mProfile.getName());
mEstablishedCache = mCache;
mCache = new BuilderCache(mProfile);
return fd;
}
public synchronized int establish() {
ParcelFileDescriptor fd = establishIntern();
return fd != null ? fd.detachFd() : -1;
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public synchronized void establishBlocking() {
/* just choose some arbitrary values to block all traffic (except for what's configured in the profile) */
mCache.addAddress("172.16.252.1", 32);
mCache.addAddress("fd00::fd02:1", 128);
mCache.addRoute("0.0.0.0", 0);
mCache.addRoute("::", 0);
/* set DNS servers to avoid DNS leak later */
mBuilder.addDnsServer("8.8.8.8");
mBuilder.addDnsServer("2001:4860:4860::8888");
/* use blocking mode to simplify packet dropping */
mBuilder.setBlocking(true);
ParcelFileDescriptor fd = establishIntern();
if (fd != null) {
mDropper.start(fd);
}
}
public synchronized void closeBlocking() {
mDropper.stop();
}
public synchronized int establishNoDns() {
ParcelFileDescriptor fd;
if (mEstablishedCache == null) {
return -1;
}
try {
Builder builder = createBuilder(mProfile.getName());
mEstablishedCache.applyData(builder);
fd = builder.establish();
} catch (Exception ex) {
ex.printStackTrace();
return -1;
}
if (fd == null) {
return -1;
}
return fd.detachFd();
}
private class PacketDropper implements Runnable {
private ParcelFileDescriptor mFd;
private Thread mThread;
public void start(ParcelFileDescriptor fd) {
mFd = fd;
mThread = new Thread(this);
mThread.start();
}
public void stop() {
if (mFd != null) {
try {
mThread.interrupt();
mThread.join();
mFd.close();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
mFd = null;
}
}
@Override
public synchronized void run() {
try {
FileInputStream plain = new FileInputStream(mFd.getFileDescriptor());
ByteBuffer packet = ByteBuffer.allocate(mCache.mMtu);
while (true) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) { /* just read and ignore all data, regular read() is not interruptible */
int len = plain.getChannel().read(packet);
packet.clear();
if (len < 0) {
break;
}
} else { /* this is rather ugly but on older platforms not even the NIO version of read() is interruptible */
boolean wait = true;
if (plain.available() > 0) {
int len = plain.read(packet.array());
packet.clear();
if (len < 0 || Thread.interrupted()) {
break;
}
/* check again right away, there may be another packet */
wait = false;
}
if (wait) {
Thread.sleep(250);
}
}
}
} catch (ClosedByInterruptException | InterruptedException e) {
/* regular interruption */
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* Cache non DNS related information so we can recreate the builder without
* that information when reestablishing IKE_SAs
*/
public class BuilderCache {
private final List<IPRange> mAddresses = new ArrayList<>();
private final List<IPRange> mRoutesIPv4 = new ArrayList<>();
private final List<IPRange> mRoutesIPv6 = new ArrayList<>();
private final IPRangeSet mIncludedSubnetsv4 = new IPRangeSet();
private final IPRangeSet mIncludedSubnetsv6 = new IPRangeSet();
private final IPRangeSet mExcludedSubnets;
private final int mSplitTunneling;
private final SelectedAppsHandling mAppHandling;
private final SortedSet<String> mSelectedApps;
private final List<InetAddress> mDnsServers = new ArrayList<>();
private int mMtu;
private boolean mIPv4Seen, mIPv6Seen, mDnsServersConfigured;
public BuilderCache(VpnProfile profile) {
IPRangeSet included = IPRangeSet.fromString(profile.getIncludedSubnets());
for (IPRange range : included) {
if (range.getFrom() instanceof Inet4Address) {
mIncludedSubnetsv4.add(range);
} else if (range.getFrom() instanceof Inet6Address) {
mIncludedSubnetsv6.add(range);
}
}
mExcludedSubnets = IPRangeSet.fromString(profile.getExcludedSubnets());
Integer splitTunneling = profile.getSplitTunneling();
mSplitTunneling = splitTunneling != null ? splitTunneling : 0;
SelectedAppsHandling appHandling = profile.getSelectedAppsHandling();
mSelectedApps = profile.getSelectedAppsSet();
/* exclude our own app, otherwise the fetcher is blocked */
switch (appHandling) {
case SELECTED_APPS_DISABLE:
appHandling = SelectedAppsHandling.SELECTED_APPS_EXCLUDE;
mSelectedApps.clear();
/* fall-through */
case SELECTED_APPS_EXCLUDE:
mSelectedApps.add(getPackageName());
break;
case SELECTED_APPS_ONLY:
mSelectedApps.remove(getPackageName());
break;
}
mAppHandling = appHandling;
if (profile.getDnsServers() != null) {
for (String server : profile.getDnsServers().split("\\s+")) {
try {
mDnsServers.add(Utils.parseInetAddress(server));
recordAddressFamily(server);
mDnsServersConfigured = true;
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
}
/* set a default MTU, will be set by the daemon for regular interfaces */
Integer mtu = profile.getMTU();
mMtu = mtu == null ? Constants.MTU_MAX : mtu;
}
public void addAddress(String address, int prefixLength) {
try {
mAddresses.add(new IPRange(address, prefixLength));
recordAddressFamily(address);
} catch (UnknownHostException ex) {
ex.printStackTrace();
}
}
public void addDnsServer(String address) {
/* ignore received DNS servers if any were configured */
if (mDnsServersConfigured) {
return;
}
try {
mDnsServers.add(Utils.parseInetAddress(address));
recordAddressFamily(address);
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
public void addRoute(String address, int prefixLength) {
try {
if (isIPv6(address)) {
mRoutesIPv6.add(new IPRange(address, prefixLength));
} else {
mRoutesIPv4.add(new IPRange(address, prefixLength));
}
} catch (UnknownHostException ex) {
ex.printStackTrace();
}
}
public void setMtu(int mtu) {
mMtu = mtu;
}
public void recordAddressFamily(String address) {
try {