From 6fcd101fcbc7779ffd7239cc35e5c3359ae38fcf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Parm=C3=A9nides=20GV?= Date: Wed, 28 May 2014 17:15:44 +0200 Subject: Resources merge correctly. --- .../src/main/java/de/blinkt/openvpn/LaunchVPN.java | 229 +++++ .../main/java/de/blinkt/openvpn/VpnProfile.java | 944 +++++++++++++++++++++ .../blinkt/openvpn/activities/DisconnectVPN.java | 82 ++ .../de/blinkt/openvpn/activities/LogWindow.java | 32 + .../java/de/blinkt/openvpn/api/APIVpnProfile.java | 51 ++ .../java/de/blinkt/openvpn/api/ConfirmDialog.java | 126 +++ .../de/blinkt/openvpn/api/ExternalAppDatabase.java | 57 ++ .../blinkt/openvpn/api/ExternalOpenVPNService.java | 317 +++++++ .../openvpn/api/SecurityRemoteException.java | 12 + .../main/java/de/blinkt/openvpn/core/CIDRIP.java | 70 ++ .../java/de/blinkt/openvpn/core/ConfigParser.java | 767 +++++++++++++++++ .../blinkt/openvpn/core/DeviceStateReceiver.java | 243 ++++++ .../blinkt/openvpn/core/ICSOpenVPNApplication.java | 14 + .../java/de/blinkt/openvpn/core/NativeUtils.java | 13 + .../java/de/blinkt/openvpn/core/NetworkSpace.java | 300 +++++++ .../de/blinkt/openvpn/core/OpenVPNManagement.java | 24 + .../java/de/blinkt/openvpn/core/OpenVPNThread.java | 174 ++++ .../openvpn/core/OpenVpnManagementThread.java | 598 +++++++++++++ .../de/blinkt/openvpn/core/OpenVpnService.java | 757 +++++++++++++++++ .../java/de/blinkt/openvpn/core/PRNGFixes.java | 334 ++++++++ .../de/blinkt/openvpn/core/ProfileManager.java | 222 +++++ .../de/blinkt/openvpn/core/ProxyDetection.java | 55 ++ .../de/blinkt/openvpn/core/VPNLaunchHelper.java | 77 ++ .../java/de/blinkt/openvpn/core/VpnStatus.java | 540 ++++++++++++ .../java/de/blinkt/openvpn/core/X509Utils.java | 155 ++++ .../de/blinkt/openvpn/fragments/LogFragment.java | 661 +++++++++++++++ .../main/res/layout-sw600dp-port/log_fragment.xml | 42 + .../src/main/res/layout-sw600dp/log_fragment.xml | 32 + .../main/src/main/res/layout/log_fragment.xml | 29 + .../main/src/main/res/layout/log_window.xml | 7 + .../main/src/main/res/values-ca/strings.xml | 120 +++ .../main/src/main/res/values-cs/strings.xml | 320 +++++++ .../main/src/main/res/values-de/strings.xml | 322 +++++++ .../main/src/main/res/values-es/strings.xml | 317 +++++++ .../main/src/main/res/values-et/strings.xml | 317 +++++++ .../main/src/main/res/values-fr/strings.xml | 318 +++++++ .../main/src/main/res/values-id/strings.xml | 285 +++++++ .../main/src/main/res/values-it/strings.xml | 310 +++++++ .../main/src/main/res/values-ja/strings.xml | 327 +++++++ .../main/src/main/res/values-ko/strings.xml | 307 +++++++ .../main/src/main/res/values-nl/strings.xml | 125 +++ .../main/src/main/res/values-no/strings.xml | 128 +++ .../main/src/main/res/values-pl/strings.xml | 260 ++++++ .../main/src/main/res/values-ro/strings.xml | 276 ++++++ .../main/src/main/res/values-ru/strings.xml | 295 +++++++ .../main/src/main/res/values-sv/strings.xml | 274 ++++++ .../main/src/main/res/values-tr/strings.xml | 310 +++++++ .../main/src/main/res/values-uk/strings.xml | 276 ++++++ .../main/src/main/res/values-zh-rCN/strings.xml | 274 ++++++ .../main/src/main/res/values-zh-rTW/strings.xml | 172 ++++ .../main/src/main/res/values/strings.xml | 321 +++++++ .../main/src/main/res/values/untranslatable.xml | 44 + .../de/blinkt/openvpn/core/OpenVPNThreadv3.java | 277 ++++++ .../java/de/blinkt/openvpn/api/APIVpnProfile.java | 51 ++ .../remoteExample/src/main/res/values/strings.xml | 15 + .../src/main/res/values/strings.xml | 8 + 56 files changed, 13013 insertions(+) create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/LaunchVPN.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/VpnProfile.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/activities/DisconnectVPN.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/activities/LogWindow.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ConfirmDialog.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalAppDatabase.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalOpenVPNService.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/SecurityRemoteException.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/CIDRIP.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ConfigParser.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/DeviceStateReceiver.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ICSOpenVPNApplication.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/NativeUtils.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/NetworkSpace.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVPNManagement.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVPNThread.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVpnManagementThread.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVpnService.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/PRNGFixes.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ProfileManager.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ProxyDetection.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/VPNLaunchHelper.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/VpnStatus.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/X509Utils.java create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/fragments/LogFragment.java create mode 100644 ics-openvpn-stripped/main/src/main/res/layout-sw600dp-port/log_fragment.xml create mode 100644 ics-openvpn-stripped/main/src/main/res/layout-sw600dp/log_fragment.xml create mode 100644 ics-openvpn-stripped/main/src/main/res/layout/log_fragment.xml create mode 100644 ics-openvpn-stripped/main/src/main/res/layout/log_window.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-ca/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-cs/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-de/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-es/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-et/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-fr/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-id/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-it/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-ja/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-ko/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-nl/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-no/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-pl/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-ro/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-ru/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-sv/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-tr/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-uk/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-zh-rCN/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values-zh-rTW/strings.xml create mode 100755 ics-openvpn-stripped/main/src/main/res/values/strings.xml create mode 100644 ics-openvpn-stripped/main/src/main/res/values/untranslatable.xml create mode 100644 ics-openvpn-stripped/main/src/ovpn3/java/de/blinkt/openvpn/core/OpenVPNThreadv3.java create mode 100644 ics-openvpn-stripped/remoteExample/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java create mode 100644 ics-openvpn-stripped/remoteExample/src/main/res/values/strings.xml create mode 100644 ics-openvpn-stripped/vpndialogxposed/src/main/res/values/strings.xml (limited to 'ics-openvpn-stripped') diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/LaunchVPN.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/LaunchVPN.java new file mode 100644 index 00000000..c563899d --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/LaunchVPN.java @@ -0,0 +1,229 @@ +package de.blinkt.openvpn; + +import se.leap.bitmaskclient.R; + +import java.io.IOException; + +import android.app.Activity; +import android.app.AlertDialog; +import android.content.ActivityNotFoundException; +import android.content.DialogInterface; +import android.content.DialogInterface.OnClickListener; +import android.content.Intent; +import android.content.SharedPreferences; +import android.net.VpnService; +import android.os.Bundle; +import android.preference.PreferenceManager; +import android.text.InputType; +import android.text.TextUtils; +import android.text.method.PasswordTransformationMethod; +import android.view.View; +import android.widget.*; + +import de.blinkt.openvpn.activities.LogWindow; +import de.blinkt.openvpn.core.VpnStatus; +import de.blinkt.openvpn.core.VpnStatus.ConnectionStatus; +import de.blinkt.openvpn.core.ProfileManager; +import de.blinkt.openvpn.core.VPNLaunchHelper; + +/** + * This Activity actually handles two stages of a launcher shortcut's life cycle. + * + * 1. Your application offers to provide shortcuts to the launcher. When + * the user installs a shortcut, an activity within your application + * generates the actual shortcut and returns it to the launcher, where it + * is shown to the user as an icon. + * + * 2. Any time the user clicks on an installed shortcut, an intent is sent. + * Typically this would then be handled as necessary by an activity within + * your application. + * + * We handle stage 1 (creating a shortcut) by simply sending back the information (in the form + * of an {@link android.content.Intent} that the launcher will use to create the shortcut. + * + * You can also implement this in an interactive way, by having your activity actually present + * UI for the user to select the specific nature of the shortcut, such as a contact, picture, URL, + * media item, or action. + * + * We handle stage 2 (responding to a shortcut) in this sample by simply displaying the contents + * of the incoming {@link android.content.Intent}. + * + * In a real application, you would probably use the shortcut intent to display specific content + * or start a particular operation. + */ +public class LaunchVPN extends Activity { + + public static final String EXTRA_KEY = "de.blinkt.openvpn.shortcutProfileUUID"; + public static final String EXTRA_NAME = "de.blinkt.openvpn.shortcutProfileName"; + public static final String EXTRA_HIDELOG = "de.blinkt.openvpn.showNoLogWindow"; + + private static final int START_VPN_PROFILE= 70; + + + private ProfileManager mPM; + private VpnProfile mSelectedProfile; + private boolean mhideLog=false; + + private boolean mCmfixed=false; + + @Override + public void onCreate(Bundle icicle) { + super.onCreate(icicle); + + mPM =ProfileManager.getInstance(this); + + } + + @Override + protected void onStart() { + super.onStart(); + // Resolve the intent + + final Intent intent = getIntent(); + final String action = intent.getAction(); + + // If the intent is a request to create a shortcut, we'll do that and exit + + + if(Intent.ACTION_MAIN.equals(action)) { + // we got called to be the starting point, most likely a shortcut + String shortcutUUID = intent.getStringExtra( EXTRA_KEY); + String shortcutName = intent.getStringExtra( EXTRA_NAME); + mhideLog = intent.getBooleanExtra(EXTRA_HIDELOG, false); + + VpnProfile profileToConnect = ProfileManager.get(this,shortcutUUID); + if(shortcutName != null && profileToConnect ==null) + profileToConnect = ProfileManager.getInstance(this).getProfileByName(shortcutName); + + if(profileToConnect ==null) { + VpnStatus.logError(R.string.shortcut_profile_notfound); + // show Log window to display error + showLogWindow(); + finish(); + return; + } + + mSelectedProfile = profileToConnect; + launchVPN(); + + } + } + + @Override + protected void onActivityResult (int requestCode, int resultCode, Intent data) { + super.onActivityResult(requestCode, resultCode, data); + + if(requestCode==START_VPN_PROFILE) { + if(resultCode == Activity.RESULT_OK) { + int needpw = mSelectedProfile.needUserPWInput(); + if(needpw !=0) { + VpnStatus.updateStateString("USER_VPN_PASSWORD", "", R.string.state_user_vpn_password, + ConnectionStatus.LEVEL_WAITING_FOR_USER_INPUT); + askForPW(needpw); + } else { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this); + boolean showlogwindow = prefs.getBoolean("showlogwindow", true); + + if(!mhideLog && showlogwindow) + showLogWindow(); + new startOpenVpnThread().start(); + } + } else if (resultCode == Activity.RESULT_CANCELED) { + // User does not want us to start, so we just vanish + VpnStatus.updateStateString("USER_VPN_PERMISSION_CANCELLED", "", R.string.state_user_vpn_permission_cancelled, + ConnectionStatus.LEVEL_NOTCONNECTED); + + finish(); + } + } + } + void showLogWindow() { + + Intent startLW = new Intent(getBaseContext(),LogWindow.class); + startLW.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT); + startActivity(startLW); + + } + + void showConfigErrorDialog(int vpnok) { + AlertDialog.Builder d = new AlertDialog.Builder(this); + d.setTitle(R.string.config_error_found); + d.setMessage(vpnok); + d.setPositiveButton(android.R.string.ok, new OnClickListener() { + + @Override + public void onClick(DialogInterface dialog, int which) { + finish(); + + } + }); + d.show(); + } + + void launchVPN () { + int vpnok = mSelectedProfile.checkProfile(this); + if(vpnok!= R.string.no_error_found) { + showConfigErrorDialog(vpnok); + return; + } + + Intent intent = VpnService.prepare(this); + // Check if we want to fix /dev/tun + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this); + boolean usecm9fix = prefs.getBoolean("useCM9Fix", false); + boolean loadTunModule = prefs.getBoolean("loadTunModule", false); + + if(loadTunModule) + execeuteSUcmd("insmod /system/lib/modules/tun.ko"); + + if(usecm9fix && !mCmfixed ) { + execeuteSUcmd("chown system /dev/tun"); + } + + + if (intent != null) { + VpnStatus.updateStateString("USER_VPN_PERMISSION", "", R.string.state_user_vpn_permission, + ConnectionStatus.LEVEL_WAITING_FOR_USER_INPUT); + // Start the query + try { + startActivityForResult(intent, START_VPN_PROFILE); + } catch (ActivityNotFoundException ane) { + // Shame on you Sony! At least one user reported that + // an official Sony Xperia Arc S image triggers this exception + VpnStatus.logError(R.string.no_vpn_support_image); + showLogWindow(); + } + } else { + onActivityResult(START_VPN_PROFILE, Activity.RESULT_OK, null); + } + + } + + private void execeuteSUcmd(String command) { + ProcessBuilder pb = new ProcessBuilder("su","-c",command); + try { + Process p = pb.start(); + int ret = p.waitFor(); + if(ret ==0) + mCmfixed=true; + } catch (InterruptedException e) { + VpnStatus.logException("SU command", e); + + } catch (IOException e) { + VpnStatus.logException("SU command", e); + } + } + + private class startOpenVpnThread extends Thread { + + @Override + public void run() { + VPNLaunchHelper.startOpenVpn(mSelectedProfile, getBaseContext()); + finish(); + + } + + } + + +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/VpnProfile.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/VpnProfile.java new file mode 100644 index 00000000..afa70100 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/VpnProfile.java @@ -0,0 +1,944 @@ +package de.blinkt.openvpn; + +import se.leap.bitmaskclient.R; + +import android.content.Context; +import android.content.Intent; +import android.content.SharedPreferences; +import android.content.pm.ApplicationInfo; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; +import android.os.Build; +import android.preference.PreferenceManager; +import android.security.KeyChain; +import android.security.KeyChainException; +import android.util.Base64; + +import de.blinkt.openvpn.core.NativeUtils; +import de.blinkt.openvpn.core.VpnStatus; +import de.blinkt.openvpn.core.OpenVpnService; +import de.blinkt.openvpn.core.X509Utils; +import org.spongycastle.util.io.pem.PemObject; +import org.spongycastle.util.io.pem.PemWriter; + +import javax.crypto.BadPaddingException; +import javax.crypto.Cipher; +import javax.crypto.IllegalBlockSizeException; +import javax.crypto.NoSuchPaddingException; +import java.io.*; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.security.InvalidKeyException; +import java.security.NoSuchAlgorithmException; +import java.security.PrivateKey; +import java.security.cert.Certificate; +import java.security.cert.CertificateException; +import java.security.cert.X509Certificate; +import java.util.Collection; +import java.util.Locale; +import java.util.UUID; +import java.util.Vector; + +public class VpnProfile implements Serializable { + // Note that this class cannot be moved to core where it belongs since + // the profile loading depends on it being here + // The Serializable documentation mentions that class name change are possible + // but the how is unclear + // + transient public static final long MAX_EMBED_FILE_SIZE = 2048*1024; // 2048kB + // Don't change this, not all parts of the program use this constant + public static final String EXTRA_PROFILEUUID = "de.blinkt.openvpn.profileUUID"; + public static final String INLINE_TAG = "[[INLINE]]"; + public static final String DISPLAYNAME_TAG = "[[NAME]]"; + public static final String MINIVPN = "miniopenvpn"; + private static final long serialVersionUID = 7085688938959334563L; + private static final String OVPNCONFIGFILE = "android.conf"; + public static final int MAXLOGLEVEL = 4; + public static final int CURRENT_PROFILE_VERSION = 2; + public static String DEFAULT_DNS1 = "8.8.8.8"; + public static String DEFAULT_DNS2 = "8.8.4.4"; + + public transient String mTransientPW = null; + public transient String mTransientPCKS12PW = null; + + + public static final int TYPE_CERTIFICATES = 0; + public static final int TYPE_PKCS12 = 1; + public static final int TYPE_KEYSTORE = 2; + public static final int TYPE_USERPASS = 3; + public static final int TYPE_STATICKEYS = 4; + public static final int TYPE_USERPASS_CERTIFICATES = 5; + public static final int TYPE_USERPASS_PKCS12 = 6; + public static final int TYPE_USERPASS_KEYSTORE = 7; + public static final int X509_VERIFY_TLSREMOTE = 0; + public static final int X509_VERIFY_TLSREMOTE_COMPAT_NOREMAPPING = 1; + public static final int X509_VERIFY_TLSREMOTE_DN = 2; + public static final int X509_VERIFY_TLSREMOTE_RDN = 3; + public static final int X509_VERIFY_TLSREMOTE_RDN_PREFIX = 4; + // variable named wrong and should haven beeen transient + // but needs to keep wrong name to guarante loading of old + // profiles + public transient boolean profileDleted = false; + public int mAuthenticationType = TYPE_KEYSTORE; + public String mName; + public String mAlias; + public String mClientCertFilename; + public String mTLSAuthDirection = ""; + public String mTLSAuthFilename; + public String mClientKeyFilename; + public String mCaFilename; + public boolean mUseLzo = true; + public String mServerPort = "1194"; + public boolean mUseUdp = true; + public String mPKCS12Filename; + public String mPKCS12Password; + public boolean mUseTLSAuth = false; + public String mServerName = "openvpn.blinkt.de"; + public String mDNS1 = DEFAULT_DNS1; + public String mDNS2 = DEFAULT_DNS2; + public String mIPv4Address; + public String mIPv6Address; + public boolean mOverrideDNS = false; + public String mSearchDomain = "blinkt.de"; + public boolean mUseDefaultRoute = true; + public boolean mUsePull = true; + public String mCustomRoutes; + public boolean mCheckRemoteCN = false; + public boolean mExpectTLSCert = true; + public String mRemoteCN = ""; + public String mPassword = ""; + public String mUsername = ""; + public boolean mRoutenopull = false; + public boolean mUseRandomHostname = false; + public boolean mUseFloat = false; + public boolean mUseCustomConfig = false; + public String mCustomConfigOptions = ""; + public String mVerb = "1"; //ignored + public String mCipher = ""; + public boolean mNobind = false; + public boolean mUseDefaultRoutev6 = true; + public String mCustomRoutesv6 = ""; + public String mKeyPassword = ""; + public boolean mPersistTun = false; + public String mConnectRetryMax = "5"; + public String mConnectRetry = "5"; + public boolean mUserEditable = true; + public String mAuth = ""; + public int mX509AuthType = X509_VERIFY_TLSREMOTE_RDN; + private transient PrivateKey mPrivateKey; + // Public attributes, since I got mad with getter/setter + // set members to default values + private UUID mUuid; + public boolean mAllowLocalLAN; + private int mProfileVersion; + public String mExcludedRoutes; + public String mExcludedRoutesv6; + + public VpnProfile(String name) { + mUuid = UUID.randomUUID(); + mName = name; + mProfileVersion = CURRENT_PROFILE_VERSION; + } + + public static String openVpnEscape(String unescaped) { + if (unescaped == null) + return null; + String escapedString = unescaped.replace("\\", "\\\\"); + escapedString = escapedString.replace("\"", "\\\""); + escapedString = escapedString.replace("\n", "\\n"); + + if (escapedString.equals(unescaped) && !escapedString.contains(" ") && + !escapedString.contains("#") && !escapedString.contains(";")) + return unescaped; + else + return '"' + escapedString + '"'; + } + + public void clearDefaults() { + mServerName = "unknown"; + mUsePull = false; + mUseLzo = false; + mUseDefaultRoute = false; + mUseDefaultRoutev6 = false; + mExpectTLSCert = false; + mPersistTun = false; + mAllowLocalLAN = true; + } + + public UUID getUUID() { + return mUuid; + + } + + public String getName() { + if (mName==null) + return "No profile name"; + return mName; + } + + public void upgradeProfile(){ + if(mProfileVersion< 2) { + /* default to the behaviour the OS used */ + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) + mAllowLocalLAN = true; + else + mAllowLocalLAN = false; + } + + mProfileVersion= CURRENT_PROFILE_VERSION; + } + + public String getConfigFile(Context context, boolean configForOvpn3) { + + File cacheDir = context.getCacheDir(); + String cfg = ""; + + // Enable managment interface + cfg += "# Enables connection to GUI\n"; + cfg += "management "; + + cfg += cacheDir.getAbsolutePath() + "/" + "mgmtsocket"; + cfg += " unix\n"; + cfg += "management-client\n"; + // Not needed, see updated man page in 2.3 + //cfg += "management-signal\n"; + cfg += "management-query-passwords\n"; + cfg += "management-hold\n\n"; + + if (!configForOvpn3) + cfg += String.format("setenv IV_GUI_VER %s \n", openVpnEscape(getVersionEnvString(context))); + + cfg += "machine-readable-output\n"; + + + boolean useTLSClient = (mAuthenticationType != TYPE_STATICKEYS); + + if (useTLSClient && mUsePull) + cfg += "client\n"; + else if (mUsePull) + cfg += "pull\n"; + else if (useTLSClient) + cfg += "tls-client\n"; + + + //cfg += "verb " + mVerb + "\n"; + cfg += "verb " + MAXLOGLEVEL + "\n"; + + if (mConnectRetryMax == null) { + mConnectRetryMax = "5"; + } + + if (!mConnectRetryMax.equals("-1")) + cfg += "connect-retry-max " + mConnectRetryMax + "\n"; + + if (mConnectRetry == null) + mConnectRetry = "5"; + + + cfg += "connect-retry " + mConnectRetry + "\n"; + + cfg += "resolv-retry 60\n"; + + + // We cannot use anything else than tun + cfg += "dev tun\n"; + + // Server Address + cfg += "remote "; + cfg += mServerName; + cfg += " "; + cfg += mServerPort; + if (mUseUdp) + cfg += " udp\n"; + else + cfg += " tcp-client\n"; + + + switch (mAuthenticationType) { + case VpnProfile.TYPE_USERPASS_CERTIFICATES: + cfg += "auth-user-pass\n"; + case VpnProfile.TYPE_CERTIFICATES: + // Ca + cfg += insertFileData("ca", mCaFilename); + + // Client Cert + Key + cfg += insertFileData("key", mClientKeyFilename); + cfg += insertFileData("cert", mClientCertFilename); + + break; + case VpnProfile.TYPE_USERPASS_PKCS12: + cfg += "auth-user-pass\n"; + case VpnProfile.TYPE_PKCS12: + cfg += insertFileData("pkcs12", mPKCS12Filename); + break; + + case VpnProfile.TYPE_USERPASS_KEYSTORE: + cfg += "auth-user-pass\n"; + case VpnProfile.TYPE_KEYSTORE: + if (!configForOvpn3) { + String[] ks = getKeyStoreCertificates(context); + cfg += "### From Keystore ####\n"; + if (ks != null) { + cfg += "\n" + ks[0] + "\n\n"; + if (ks[1] != null) + cfg += "\n" + ks[1] + "\n\n"; + cfg += "\n" + ks[2] + "\n\n"; + cfg += "management-external-key\n"; + } else { + cfg += context.getString(R.string.keychain_access) + "\n"; + if (Build.VERSION.SDK_INT == Build.VERSION_CODES.JELLY_BEAN) + if (!mAlias.matches("^[a-zA-Z0-9]$")) + cfg += context.getString(R.string.jelly_keystore_alphanumeric_bug) + "\n"; + } + } + break; + case VpnProfile.TYPE_USERPASS: + cfg += "auth-user-pass\n"; + cfg += insertFileData("ca", mCaFilename); + } + + if (mUseLzo) { + cfg += "comp-lzo\n"; + } + + if (mUseTLSAuth) { + if (mAuthenticationType == TYPE_STATICKEYS) + cfg += insertFileData("secret", mTLSAuthFilename); + else + cfg += insertFileData("tls-auth", mTLSAuthFilename); + + if (nonNull(mTLSAuthDirection)) { + cfg += "key-direction "; + cfg += mTLSAuthDirection; + cfg += "\n"; + } + + } + + if (!mUsePull) { + if (nonNull(mIPv4Address)) + cfg += "ifconfig " + cidrToIPAndNetmask(mIPv4Address) + "\n"; + + if (nonNull(mIPv6Address)) + cfg += "ifconfig-ipv6 " + mIPv6Address + "\n"; + } + + if (mUsePull && mRoutenopull) + cfg += "route-nopull\n"; + + String routes = ""; + + if (mUseDefaultRoute) + routes += "route 0.0.0.0 0.0.0.0 vpn_gateway\n"; + else + { + for (String route : getCustomRoutes(mCustomRoutes)) { + routes += "route " + route + " vpn_gateway\n"; + } + + for (String route: getCustomRoutes(mExcludedRoutes)) { + routes += "route " + route + " net_gateway\n"; + } + } + + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT && !mAllowLocalLAN) + cfg+="redirect-private block-local\n"; + else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && mAllowLocalLAN) + cfg+="redirect-private unblock-local\n"; + + + if (mUseDefaultRoutev6) + cfg += "route-ipv6 ::/0\n"; + else + for (String route : getCustomRoutesv6(mCustomRoutesv6)) { + routes += "route-ipv6 " + route + "\n"; + } + + cfg += routes; + + if (mOverrideDNS || !mUsePull) { + if (nonNull(mDNS1)) + cfg += "dhcp-option DNS " + mDNS1 + "\n"; + if (nonNull(mDNS2)) + cfg += "dhcp-option DNS " + mDNS2 + "\n"; + if (nonNull(mSearchDomain)) + cfg += "dhcp-option DOMAIN " + mSearchDomain + "\n"; + + } + + if (mNobind) + cfg += "nobind\n"; + + + // Authentication + if (mAuthenticationType != TYPE_STATICKEYS) { + if (mCheckRemoteCN) { + if (mRemoteCN == null || mRemoteCN.equals("")) + cfg += "verify-x509-name " + mServerName + " name\n"; + else + switch (mX509AuthType) { + + // 2.2 style x509 checks + case X509_VERIFY_TLSREMOTE_COMPAT_NOREMAPPING: + cfg += "compat-names no-remapping\n"; + case X509_VERIFY_TLSREMOTE: + cfg += "tls-remote " + openVpnEscape(mRemoteCN) + "\n"; + break; + + case X509_VERIFY_TLSREMOTE_RDN: + cfg += "verify-x509-name " + openVpnEscape(mRemoteCN) + " name\n"; + break; + + case X509_VERIFY_TLSREMOTE_RDN_PREFIX: + cfg += "verify-x509-name " + openVpnEscape(mRemoteCN) + " name-prefix\n"; + break; + + case X509_VERIFY_TLSREMOTE_DN: + cfg += "verify-x509-name " + openVpnEscape(mRemoteCN) + "\n"; + break; + } + } + if (mExpectTLSCert) + cfg += "remote-cert-tls server\n"; + } + + if (nonNull(mCipher)) { + cfg += "cipher " + mCipher + "\n"; + } + + if (nonNull(mAuth)) { + cfg += "auth " + mAuth + "\n"; + } + + // Obscure Settings dialog + if (mUseRandomHostname) + cfg += "#my favorite options :)\nremote-random-hostname\n"; + + if (mUseFloat) + cfg += "float\n"; + + if (mPersistTun) { + cfg += "persist-tun\n"; + cfg += "# persist-tun also enables pre resolving to avoid DNS resolve problem\n"; + cfg += "preresolve\n"; + } + + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); + boolean usesystemproxy = prefs.getBoolean("usesystemproxy", true); + if (usesystemproxy) { + cfg += "# Use system proxy setting\n"; + cfg += "management-query-proxy\n"; + } + + + if (mUseCustomConfig) { + cfg += "# Custom configuration options\n"; + cfg += "# You are on your on own here :)\n"; + cfg += mCustomConfigOptions; + cfg += "\n"; + + } + + + return cfg; + } + + public String getVersionEnvString(Context c) { + String version = "unknown"; + try { + PackageInfo packageinfo = c.getPackageManager().getPackageInfo(c.getPackageName(), 0); + version = packageinfo.versionName; + } catch (PackageManager.NameNotFoundException e) { + VpnStatus.logException(e); + } + return String.format(Locale.US, "%s %s", c.getPackageName(), version); + + } + + //! Put inline data inline and other data as normal escaped filename + private String insertFileData(String cfgentry, String filedata) { + if (filedata == null) { + // TODO: generate good error + return String.format("%s %s\n", cfgentry, "missing"); + } else if (isEmbedded(filedata)) { + String dataWithOutHeader = getEmbeddedContent(filedata); + return String.format(Locale.ENGLISH, "<%s>\n%s\n\n", cfgentry, dataWithOutHeader, cfgentry); + } else { + return String.format(Locale.ENGLISH, "%s %s\n", cfgentry, openVpnEscape(filedata)); + } + } + + private boolean nonNull(String val) { + if (val == null || val.equals("")) + return false; + else + return true; + } + + private Collection getCustomRoutes(String routes) { + Vector cidrRoutes = new Vector(); + if (routes == null) { + // No routes set, return empty vector + return cidrRoutes; + } + for (String route : routes.split("[\n \t]")) { + if (!route.equals("")) { + String cidrroute = cidrToIPAndNetmask(route); + if (cidrroute == null) + return null; + + cidrRoutes.add(cidrroute); + } + } + + return cidrRoutes; + } + + private Collection getCustomRoutesv6(String routes) { + Vector cidrRoutes = new Vector(); + if (routes == null) { + // No routes set, return empty vector + return cidrRoutes; + } + for (String route : routes.split("[\n \t]")) { + if (!route.equals("")) { + cidrRoutes.add(route); + } + } + + return cidrRoutes; + } + + private String cidrToIPAndNetmask(String route) { + String[] parts = route.split("/"); + + // No /xx, assume /32 as netmask + if (parts.length == 1) + parts = (route + "/32").split("/"); + + if (parts.length != 2) + return null; + int len; + try { + len = Integer.parseInt(parts[1]); + } catch (NumberFormatException ne) { + return null; + } + if (len < 0 || len > 32) + return null; + + + long nm = 0xffffffffl; + nm = (nm << (32 - len)) & 0xffffffffl; + + String netmask = String.format(Locale.ENGLISH, "%d.%d.%d.%d", (nm & 0xff000000) >> 24, (nm & 0xff0000) >> 16, (nm & 0xff00) >> 8, nm & 0xff); + return parts[0] + " " + netmask; + } + + private String[] buildOpenvpnArgv(File cacheDir) { + Vector args = new Vector(); + + // Add fixed paramenters + //args.add("/data/data/de.blinkt.openvpn/lib/openvpn"); + args.add(cacheDir.getAbsolutePath() + "/" + VpnProfile.MINIVPN); + + args.add("--config"); + args.add(cacheDir.getAbsolutePath() + "/" + OVPNCONFIGFILE); + + + return args.toArray(new String[args.size()]); + } + + public Intent prepareIntent(Context context) { + String prefix = context.getPackageName(); + + Intent intent = new Intent(context, OpenVpnService.class); + + if (mAuthenticationType == VpnProfile.TYPE_KEYSTORE || mAuthenticationType == VpnProfile.TYPE_USERPASS_KEYSTORE) { + if (getKeyStoreCertificates(context) == null) + return null; + } + + intent.putExtra(prefix + ".ARGV", buildOpenvpnArgv(context.getCacheDir())); + intent.putExtra(prefix + ".profileUUID", mUuid.toString()); + + ApplicationInfo info = context.getApplicationInfo(); + intent.putExtra(prefix + ".nativelib", info.nativeLibraryDir); + + try { + FileWriter cfg = new FileWriter(context.getCacheDir().getAbsolutePath() + "/" + OVPNCONFIGFILE); + cfg.write(getConfigFile(context, false)); + cfg.flush(); + cfg.close(); + } catch (IOException e) { + VpnStatus.logException(e); + } + + return intent; + } + + public String[] getKeyStoreCertificates(Context context) { + return getKeyStoreCertificates(context, 5); + } + + public static String getDisplayName(String embeddedFile) { + int start = DISPLAYNAME_TAG.length(); + int end = embeddedFile.indexOf(INLINE_TAG); + return embeddedFile.substring(start,end); + } + + public static String getEmbeddedContent(String data) + { + if (!data.contains(INLINE_TAG)) + return data; + + int start = data.indexOf(INLINE_TAG) + INLINE_TAG.length(); + return data.substring(start); + } + + public static boolean isEmbedded(String data) { + if (data==null) + return false; + if(data.startsWith(INLINE_TAG) || data.startsWith(DISPLAYNAME_TAG)) + return true; + else + return false; + } + + + class NoCertReturnedException extends Exception { + public NoCertReturnedException (String msg) { + super(msg); + } + } + + synchronized String[] getKeyStoreCertificates(Context context,int tries) { + PrivateKey privateKey = null; + X509Certificate[] cachain; + Exception exp=null; + try { + privateKey = KeyChain.getPrivateKey(context, mAlias); + mPrivateKey = privateKey; + + String keystoreChain = null; + + + cachain = KeyChain.getCertificateChain(context, mAlias); + if(cachain == null) + throw new NoCertReturnedException("No certificate returned from Keystore"); + + if (cachain.length <= 1 && !nonNull(mCaFilename)) { + VpnStatus.logMessage(VpnStatus.LogLevel.ERROR, "", context.getString(R.string.keychain_nocacert)); + } else { + StringWriter ksStringWriter = new StringWriter(); + + PemWriter pw = new PemWriter(ksStringWriter); + for (int i = 1; i < cachain.length; i++) { + X509Certificate cert = cachain[i]; + pw.writeObject(new PemObject("CERTIFICATE", cert.getEncoded())); + } + pw.close(); + keystoreChain = ksStringWriter.toString(); + } + + + String caout = null; + if (nonNull(mCaFilename)) { + try { + Certificate cacert = X509Utils.getCertificateFromFile(mCaFilename); + StringWriter caoutWriter = new StringWriter(); + PemWriter pw = new PemWriter(caoutWriter); + + pw.writeObject(new PemObject("CERTIFICATE", cacert.getEncoded())); + pw.close(); + caout= caoutWriter.toString(); + + } catch (Exception e) { + VpnStatus.logError("Could not read CA certificate" + e.getLocalizedMessage()); + } + } + + + StringWriter certout = new StringWriter(); + + + if (cachain.length >= 1) { + X509Certificate usercert = cachain[0]; + + PemWriter upw = new PemWriter(certout); + upw.writeObject(new PemObject("CERTIFICATE", usercert.getEncoded())); + upw.close(); + + } + String user = certout.toString(); + + + String ca, extra; + if(caout==null) { + ca =keystoreChain; + extra=null; + } else { + ca = caout; + extra=keystoreChain; + } + + return new String[]{ca, extra, user}; + } catch (InterruptedException e) { + exp=e; + } catch (FileNotFoundException e) { + exp=e; + } catch (CertificateException e) { + exp=e; + } catch (IOException e) { + exp=e; + } catch (KeyChainException e) { + exp=e; + } catch (NoCertReturnedException e) { + exp =e; + } catch (IllegalArgumentException e) { + exp =e; + } catch (AssertionError e) { + if (tries ==0) + return null; + VpnStatus.logError(String.format("Failure getting Keystore Keys (%s), retrying",e.getLocalizedMessage())); + try { + Thread.sleep(3000); + } catch (InterruptedException e1) { + VpnStatus.logException(e1); + } + return getKeyStoreCertificates(context, tries-1); + } + if (exp != null) { + exp.printStackTrace(); + VpnStatus.logError(R.string.keyChainAccessError, exp.getLocalizedMessage()); + + VpnStatus.logError(R.string.keychain_access); + if (Build.VERSION.SDK_INT == Build.VERSION_CODES.JELLY_BEAN) { + if (!mAlias.matches("^[a-zA-Z0-9]$")) { + VpnStatus.logError(R.string.jelly_keystore_alphanumeric_bug); + } + } + } + return null; + } + + //! Return an error if somethign is wrong + public int checkProfile(Context context) { + if (mAuthenticationType == TYPE_KEYSTORE || mAuthenticationType == TYPE_USERPASS_KEYSTORE) { + if (mAlias == null) + return R.string.no_keystore_cert_selected; + } + + if (!mUsePull || mAuthenticationType == TYPE_STATICKEYS) { + if (mIPv4Address == null || cidrToIPAndNetmask(mIPv4Address) == null) + return R.string.ipv4_format_error; + } + if (!mUseDefaultRoute && (getCustomRoutes(mCustomRoutes) == null || getCustomRoutes(mExcludedRoutes) ==null)) + return R.string.custom_route_format_error; + + // Everything okay + return R.string.no_error_found; + + } + + //! Openvpn asks for a "Private Key", this should be pkcs12 key + // + public String getPasswordPrivateKey() { + if (mTransientPCKS12PW != null) { + String pwcopy = mTransientPCKS12PW; + mTransientPCKS12PW = null; + return pwcopy; + } + switch (mAuthenticationType) { + case TYPE_PKCS12: + case TYPE_USERPASS_PKCS12: + return mPKCS12Password; + + case TYPE_CERTIFICATES: + case TYPE_USERPASS_CERTIFICATES: + return mKeyPassword; + + case TYPE_USERPASS: + case TYPE_STATICKEYS: + default: + return null; + } + } + + public boolean isUserPWAuth() { + switch (mAuthenticationType) { + case TYPE_USERPASS: + case TYPE_USERPASS_CERTIFICATES: + case TYPE_USERPASS_KEYSTORE: + case TYPE_USERPASS_PKCS12: + return true; + default: + return false; + + } + } + + public boolean requireTLSKeyPassword() { + if (!nonNull(mClientKeyFilename)) + return false; + + String data = ""; + if (isEmbedded(mClientKeyFilename)) + data = mClientKeyFilename; + else { + char[] buf = new char[2048]; + FileReader fr; + try { + fr = new FileReader(mClientKeyFilename); + int len = fr.read(buf); + while (len > 0) { + data += new String(buf, 0, len); + len = fr.read(buf); + } + fr.close(); + } catch (FileNotFoundException e) { + return false; + } catch (IOException e) { + return false; + } + + } + + if (data.contains("Proc-Type: 4,ENCRYPTED")) + return true; + else if (data.contains("-----BEGIN ENCRYPTED PRIVATE KEY-----")) + return true; + else + return false; + } + + public int needUserPWInput() { + if ((mAuthenticationType == TYPE_PKCS12 || mAuthenticationType == TYPE_USERPASS_PKCS12) && + (mPKCS12Password == null || mPKCS12Password.equals(""))) { + if (mTransientPCKS12PW == null) + return R.string.pkcs12_file_encryption_key; + } + + if (mAuthenticationType == TYPE_CERTIFICATES || mAuthenticationType == TYPE_USERPASS_CERTIFICATES) { + if (requireTLSKeyPassword() && !nonNull(mKeyPassword)) + if (mTransientPCKS12PW == null) { + return R.string.private_key_password; + } + } + + if (isUserPWAuth() && !(nonNull(mUsername) && (nonNull(mPassword) || mTransientPW != null))) { + return R.string.password; + } + return 0; + } + + public String getPasswordAuth() { + if (mTransientPW != null) { + String pwcopy = mTransientPW; + mTransientPW = null; + return pwcopy; + } else { + return mPassword; + } + } + + // Used by the Array Adapter + @Override + public String toString() { + return mName; + } + + public String getUUIDString() { + return mUuid.toString(); + } + + public PrivateKey getKeystoreKey() { + return mPrivateKey; + } + + public String getSignedData(String b64data) { + PrivateKey privkey = getKeystoreKey(); + Exception err; + + byte[] data = Base64.decode(b64data, Base64.DEFAULT); + + // The Jelly Bean *evil* Hack + // 4.2 implements the RSA/ECB/PKCS1PADDING in the OpenSSLprovider + if (Build.VERSION.SDK_INT == Build.VERSION_CODES.JELLY_BEAN) { + return processSignJellyBeans(privkey, data); + } + + + try { + + + Cipher rsasinger = Cipher.getInstance("RSA/ECB/PKCS1PADDING"); + + rsasinger.init(Cipher.ENCRYPT_MODE, privkey); + + byte[] signed_bytes = rsasinger.doFinal(data); + return Base64.encodeToString(signed_bytes, Base64.NO_WRAP); + + } catch (NoSuchAlgorithmException e) { + err = e; + } catch (InvalidKeyException e) { + err = e; + } catch (NoSuchPaddingException e) { + err = e; + } catch (IllegalBlockSizeException e) { + err = e; + } catch (BadPaddingException e) { + err = e; + } + + VpnStatus.logError(R.string.error_rsa_sign, err.getClass().toString(), err.getLocalizedMessage()); + + return null; + + } + + private String processSignJellyBeans(PrivateKey privkey, byte[] data) { + Exception err; + try { + Method getKey = privkey.getClass().getSuperclass().getDeclaredMethod("getOpenSSLKey"); + getKey.setAccessible(true); + + // Real object type is OpenSSLKey + Object opensslkey = getKey.invoke(privkey); + + getKey.setAccessible(false); + + Method getPkeyContext = opensslkey.getClass().getDeclaredMethod("getPkeyContext"); + + // integer pointer to EVP_pkey + getPkeyContext.setAccessible(true); + int pkey = (Integer) getPkeyContext.invoke(opensslkey); + getPkeyContext.setAccessible(false); + + // 112 with TLS 1.2 (172 back with 4.3), 36 with TLS 1.0 + byte[] signed_bytes = NativeUtils.rsasign(data, pkey); + return Base64.encodeToString(signed_bytes, Base64.NO_WRAP); + + } catch (NoSuchMethodException e) { + err = e; + } catch (IllegalArgumentException e) { + err = e; + } catch (IllegalAccessException e) { + err = e; + } catch (InvocationTargetException e) { + err = e; + } catch (InvalidKeyException e) { + err = e; + } + VpnStatus.logError(R.string.error_rsa_sign, err.getClass().toString(), err.getLocalizedMessage()); + + return null; + + } + + +} + + + + diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/activities/DisconnectVPN.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/activities/DisconnectVPN.java new file mode 100644 index 00000000..da011c98 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/activities/DisconnectVPN.java @@ -0,0 +1,82 @@ +package de.blinkt.openvpn.activities; + +import android.app.Activity; +import android.app.AlertDialog; +import android.content.*; +import android.os.IBinder; + +import se.leap.bitmaskclient.R; +import de.blinkt.openvpn.core.OpenVpnService; +import de.blinkt.openvpn.core.ProfileManager; + +/** + * Created by arne on 13.10.13. + */ +public class DisconnectVPN extends Activity implements DialogInterface.OnClickListener{ + protected OpenVpnService mService; + + private ServiceConnection mConnection = new ServiceConnection() { + + + @Override + public void onServiceConnected(ComponentName className, + IBinder service) { + // We've bound to LocalService, cast the IBinder and get LocalService instance + OpenVpnService.LocalBinder binder = (OpenVpnService.LocalBinder) service; + mService = binder.getService(); + } + + @Override + public void onServiceDisconnected(ComponentName arg0) { + mService =null; + } + + }; + + @Override + protected void onResume() { + super.onResume(); + Intent intent = new Intent(this, OpenVpnService.class); + intent.setAction(OpenVpnService.START_SERVICE); + bindService(intent, mConnection, Context.BIND_AUTO_CREATE); + showDisconnectDialog(); + } + + @Override + protected void onStop() { + super.onStop(); + unbindService(mConnection); + } + + // if (getIntent() !=null && OpenVpnService.DISCONNECT_VPN.equals(getIntent().getAction())) + + // setIntent(null); + + /* + @Override + protected void onNewIntent(Intent intent) { + super.onNewIntent(intent); + setIntent(intent); + } + */ + + private void showDisconnectDialog() { + AlertDialog.Builder builder = new AlertDialog.Builder(this); + builder.setTitle(R.string.title_cancel); + builder.setMessage(R.string.cancel_connection_query); + builder.setNegativeButton(android.R.string.no, this); + builder.setPositiveButton(android.R.string.yes,this); + + builder.show(); + } + + @Override + public void onClick(DialogInterface dialog, int which) { + if (which == DialogInterface.BUTTON_POSITIVE) { + ProfileManager.setConntectedVpnProfileDisconnected(this); + if (mService != null && mService.getManagement() != null) + mService.getManagement().stopVPN(); + } + finish(); + } +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/activities/LogWindow.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/activities/LogWindow.java new file mode 100644 index 00000000..7ed09dd2 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/activities/LogWindow.java @@ -0,0 +1,32 @@ +package de.blinkt.openvpn.activities; + +import android.app.Activity; +import android.os.Bundle; +import android.view.MenuItem; + +import se.leap.bitmaskclient.R; +import de.blinkt.openvpn.fragments.LogFragment; + +/** + * Created by arne on 13.10.13. + */ +public class LogWindow extends Activity { + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.log_window); + getActionBar().setDisplayHomeAsUpEnabled(true); + + if (savedInstanceState == null) { + getFragmentManager().beginTransaction() + .add(R.id.container, new LogFragment()) + .commit(); + } + + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + return super.onOptionsItemSelected(item); + } +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java new file mode 100644 index 00000000..a44891ab --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java @@ -0,0 +1,51 @@ +package de.blinkt.openvpn.api; + +import android.os.Parcel; +import android.os.Parcelable; + +public class APIVpnProfile implements Parcelable { + + public final String mUUID; + public final String mName; + public final boolean mUserEditable; + + public APIVpnProfile(Parcel in) { + mUUID = in.readString(); + mName = in.readString(); + mUserEditable = in.readInt() != 0; + } + + public APIVpnProfile(String uuidString, String name, boolean userEditable) { + mUUID=uuidString; + mName = name; + mUserEditable=userEditable; + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeString(mUUID); + dest.writeString(mName); + if(mUserEditable) + dest.writeInt(0); + else + dest.writeInt(1); + } + + public static final Parcelable.Creator CREATOR + = new Parcelable.Creator() { + public APIVpnProfile createFromParcel(Parcel in) { + return new APIVpnProfile(in); + } + + public APIVpnProfile[] newArray(int size) { + return new APIVpnProfile[size]; + } + }; + + +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ConfirmDialog.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ConfirmDialog.java new file mode 100644 index 00000000..3856a181 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ConfirmDialog.java @@ -0,0 +1,126 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package de.blinkt.openvpn.api; + +import android.app.Activity; +import android.app.AlertDialog; +import android.app.AlertDialog.Builder; +import android.content.DialogInterface; +import android.content.DialogInterface.OnShowListener; +import android.content.pm.ApplicationInfo; +import android.content.pm.PackageManager; +import android.util.Log; +import android.view.View; +import android.widget.Button; +import android.widget.CompoundButton; +import android.widget.ImageView; +import android.widget.TextView; +import se.leap.bitmaskclient.R; + + +public class ConfirmDialog extends Activity implements +CompoundButton.OnCheckedChangeListener, DialogInterface.OnClickListener { + private static final String TAG = "OpenVPNVpnConfirm"; + + private String mPackage; + + private Button mButton; + + private AlertDialog mAlert; + + @Override + protected void onResume() { + super.onResume(); + try { + mPackage = getCallingPackage(); + if (mPackage==null) { + finish(); + return; + } + + + PackageManager pm = getPackageManager(); + ApplicationInfo app = pm.getApplicationInfo(mPackage, 0); + + View view = View.inflate(this, R.layout.api_confirm, null); + ((ImageView) view.findViewById(R.id.icon)).setImageDrawable(app.loadIcon(pm)); + ((TextView) view.findViewById(R.id.prompt)).setText( + getString(R.string.prompt, app.loadLabel(pm), getString(R.string.app))); + ((CompoundButton) view.findViewById(R.id.check)).setOnCheckedChangeListener(this); + + + Builder builder = new AlertDialog.Builder(this); + + builder.setView(view); + + builder.setIconAttribute(android.R.attr.alertDialogIcon); + builder.setTitle(android.R.string.dialog_alert_title); + builder.setPositiveButton(android.R.string.ok,this); + builder.setNegativeButton(android.R.string.cancel,this); + + mAlert = builder.create(); + mAlert.setCanceledOnTouchOutside(false); + + mAlert.setOnShowListener (new OnShowListener() { + + @Override + public void onShow(DialogInterface dialog) { + mButton = mAlert.getButton(DialogInterface.BUTTON_POSITIVE); + mButton.setEnabled(false); + + } + }); + + //setCloseOnTouchOutside(false); + + mAlert.show(); + + } catch (Exception e) { + Log.e(TAG, "onResume", e); + finish(); + } + } + + @Override + public void onBackPressed() { + setResult(RESULT_CANCELED); + finish(); + } + + @Override + public void onCheckedChanged(CompoundButton button, boolean checked) { + mButton.setEnabled(checked); + } + + @Override + public void onClick(DialogInterface dialog, int which) { + + if (which == DialogInterface.BUTTON_POSITIVE) { + ExternalAppDatabase extapps = new ExternalAppDatabase(this); + extapps.addApp(mPackage); + setResult(RESULT_OK); + finish(); + } + + if (which == DialogInterface.BUTTON_NEGATIVE) { + setResult(RESULT_CANCELED); + finish(); + } + } + +} + diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalAppDatabase.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalAppDatabase.java new file mode 100644 index 00000000..02c369b1 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalAppDatabase.java @@ -0,0 +1,57 @@ +package de.blinkt.openvpn.api; + +import java.util.HashSet; +import java.util.Set; + +import android.content.Context; +import android.content.SharedPreferences; +import android.content.SharedPreferences.Editor; +import android.preference.PreferenceManager; + +public class ExternalAppDatabase { + + Context mContext; + + public ExternalAppDatabase(Context c) { + mContext =c; + } + + private final String PREFERENCES_KEY = "PREFERENCES_KEY"; + + boolean isAllowed(String packagename) { + Set allowedapps = getExtAppList(); + + return allowedapps.contains(packagename); + + } + + public Set getExtAppList() { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext); + return prefs.getStringSet(PREFERENCES_KEY, new HashSet()); + } + + void addApp(String packagename) + { + Set allowedapps = getExtAppList(); + allowedapps.add(packagename); + saveExtAppList(allowedapps); + } + + private void saveExtAppList( Set allowedapps) { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext); + Editor prefedit = prefs.edit(); + prefedit.putStringSet(PREFERENCES_KEY, allowedapps); + prefedit.apply(); + } + + public void clearAllApiApps() { + saveExtAppList(new HashSet()); + } + + public void removeApp(String packagename) { + Set allowedapps = getExtAppList(); + allowedapps.remove(packagename); + saveExtAppList(allowedapps); + } + +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalOpenVPNService.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalOpenVPNService.java new file mode 100644 index 00000000..784ec72a --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalOpenVPNService.java @@ -0,0 +1,317 @@ +package de.blinkt.openvpn.api; + +import java.io.IOException; +import java.io.StringReader; +import java.lang.ref.WeakReference; +import java.util.LinkedList; +import java.util.List; + +import android.annotation.TargetApi; +import android.app.Service; +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.ServiceConnection; +import android.content.pm.ApplicationInfo; +import android.content.pm.PackageManager; +import android.content.pm.PackageManager.NameNotFoundException; +import android.net.VpnService; +import android.os.*; +import se.leap.bitmaskclient.R; +import de.blinkt.openvpn.VpnProfile; +import de.blinkt.openvpn.core.ConfigParser; +import de.blinkt.openvpn.core.ConfigParser.ConfigParseError; +import de.blinkt.openvpn.core.VpnStatus; +import de.blinkt.openvpn.core.VpnStatus.ConnectionStatus; +import de.blinkt.openvpn.core.VpnStatus.StateListener; +import de.blinkt.openvpn.core.OpenVpnService; +import de.blinkt.openvpn.core.OpenVpnService.LocalBinder; +import de.blinkt.openvpn.core.ProfileManager; +import de.blinkt.openvpn.core.VPNLaunchHelper; + +@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) +public class ExternalOpenVPNService extends Service implements StateListener { + + private static final int SEND_TOALL = 0; + + final RemoteCallbackList mCallbacks = + new RemoteCallbackList(); + + private OpenVpnService mService; + private ExternalAppDatabase mExtAppDb; + + + private ServiceConnection mConnection = new ServiceConnection() { + + + @Override + public void onServiceConnected(ComponentName className, + IBinder service) { + // We've bound to LocalService, cast the IBinder and get LocalService instance + LocalBinder binder = (LocalBinder) service; + mService = binder.getService(); + } + + @Override + public void onServiceDisconnected(ComponentName arg0) { + mService = null; + } + + }; + + @Override + public void onCreate() { + super.onCreate(); + VpnStatus.addStateListener(this); + mExtAppDb = new ExternalAppDatabase(this); + + Intent intent = new Intent(getBaseContext(), OpenVpnService.class); + intent.setAction(OpenVpnService.START_SERVICE); + + bindService(intent, mConnection, Context.BIND_AUTO_CREATE); + mHandler.setService(this); + } + + private final IOpenVPNAPIService.Stub mBinder = new IOpenVPNAPIService.Stub() { + + private void checkOpenVPNPermission() throws SecurityRemoteException { + PackageManager pm = getPackageManager(); + + for (String apppackage : mExtAppDb.getExtAppList()) { + ApplicationInfo app; + try { + app = pm.getApplicationInfo(apppackage, 0); + if (Binder.getCallingUid() == app.uid) { + return; + } + } catch (NameNotFoundException e) { + // App not found. Remove it from the list + mExtAppDb.removeApp(apppackage); + } + + } + throw new SecurityException("Unauthorized OpenVPN API Caller"); + } + + @Override + public List getProfiles() throws RemoteException { + checkOpenVPNPermission(); + + ProfileManager pm = ProfileManager.getInstance(getBaseContext()); + + List profiles = new LinkedList(); + + for (VpnProfile vp : pm.getProfiles()) + profiles.add(new APIVpnProfile(vp.getUUIDString(), vp.mName, vp.mUserEditable)); + + return profiles; + } + + @Override + public void startProfile(String profileUUID) throws RemoteException { + checkOpenVPNPermission(); + + Intent shortVPNIntent = new Intent(Intent.ACTION_MAIN); + shortVPNIntent.setClass(getBaseContext(), de.blinkt.openvpn.LaunchVPN.class); + shortVPNIntent.putExtra(de.blinkt.openvpn.LaunchVPN.EXTRA_KEY, profileUUID); + shortVPNIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + startActivity(shortVPNIntent); + } + + public void startVPN(String inlineconfig) throws RemoteException { + checkOpenVPNPermission(); + + ConfigParser cp = new ConfigParser(); + try { + cp.parseConfig(new StringReader(inlineconfig)); + VpnProfile vp = cp.convertProfile(); + if (vp.checkProfile(getApplicationContext()) != R.string.no_error_found) + throw new RemoteException(getString(vp.checkProfile(getApplicationContext()))); + + + ProfileManager.setTemporaryProfile(vp); + VPNLaunchHelper.startOpenVpn(vp, getBaseContext()); + + + } catch (IOException e) { + throw new RemoteException(e.getMessage()); + } catch (ConfigParseError e) { + throw new RemoteException(e.getMessage()); + } + } + + @Override + public boolean addVPNProfile(String name, String config) throws RemoteException { + checkOpenVPNPermission(); + + ConfigParser cp = new ConfigParser(); + try { + cp.parseConfig(new StringReader(config)); + VpnProfile vp = cp.convertProfile(); + vp.mName = name; + ProfileManager pm = ProfileManager.getInstance(getBaseContext()); + pm.addProfile(vp); + } catch (IOException e) { + VpnStatus.logException(e); + return false; + } catch (ConfigParseError e) { + VpnStatus.logException(e); + return false; + } + + return true; + } + + + @Override + public Intent prepare(String packagename) { + if (new ExternalAppDatabase(ExternalOpenVPNService.this).isAllowed(packagename)) + return null; + + Intent intent = new Intent(); + intent.setClass(ExternalOpenVPNService.this, ConfirmDialog.class); + return intent; + } + + @Override + public Intent prepareVPNService() throws RemoteException { + checkOpenVPNPermission(); + + if (VpnService.prepare(ExternalOpenVPNService.this) == null) + return null; + else + return new Intent(getBaseContext(), GrantPermissionsActivity.class); + } + + + @Override + public void registerStatusCallback(IOpenVPNStatusCallback cb) + throws RemoteException { + checkOpenVPNPermission(); + + if (cb != null) { + cb.newStatus(mMostRecentState.vpnUUID, mMostRecentState.state, + mMostRecentState.logmessage, mMostRecentState.level.name()); + mCallbacks.register(cb); + } + + + } + + @Override + public void unregisterStatusCallback(IOpenVPNStatusCallback cb) + throws RemoteException { + checkOpenVPNPermission(); + + if (cb != null) + mCallbacks.unregister(cb); + } + + @Override + public void disconnect() throws RemoteException { + checkOpenVPNPermission(); + if (mService != null && mService.getManagement() != null) + mService.getManagement().stopVPN(); + } + + @Override + public void pause() throws RemoteException { + checkOpenVPNPermission(); + if (mService != null) + mService.userPause(true); + } + + @Override + public void resume() throws RemoteException { + checkOpenVPNPermission(); + if (mService != null) + mService.userPause(false); + + } + }; + + + private UpdateMessage mMostRecentState; + + @Override + public IBinder onBind(Intent intent) { + return mBinder; + } + + @Override + public void onDestroy() { + super.onDestroy(); + mCallbacks.kill(); + unbindService(mConnection); + VpnStatus.removeStateListener(this); + } + + class UpdateMessage { + public String state; + public String logmessage; + public ConnectionStatus level; + public String vpnUUID; + + public UpdateMessage(String state, String logmessage, ConnectionStatus level) { + this.state = state; + this.logmessage = logmessage; + this.level = level; + } + } + + @Override + public void updateState(String state, String logmessage, int resid, ConnectionStatus level) { + mMostRecentState = new UpdateMessage(state, logmessage, level); + if (ProfileManager.getLastConnectedVpn() != null) + mMostRecentState.vpnUUID = ProfileManager.getLastConnectedVpn().getUUIDString(); + + Message msg = mHandler.obtainMessage(SEND_TOALL, mMostRecentState); + msg.sendToTarget(); + + } + + private static final OpenVPNServiceHandler mHandler = new OpenVPNServiceHandler(); + + + static class OpenVPNServiceHandler extends Handler { + WeakReference service = null; + + private void setService(ExternalOpenVPNService eos) { + service = new WeakReference(eos); + } + + @Override + public void handleMessage(Message msg) { + + RemoteCallbackList callbacks; + switch (msg.what) { + case SEND_TOALL: + if (service == null || service.get() == null) + return; + + callbacks = service.get().mCallbacks; + + + // Broadcast to all clients the new value. + final int N = callbacks.beginBroadcast(); + for (int i = 0; i < N; i++) { + try { + sendUpdate(callbacks.getBroadcastItem(i), (UpdateMessage) msg.obj); + } catch (RemoteException e) { + // The RemoteCallbackList will take care of removing + // the dead object for us. + } + } + callbacks.finishBroadcast(); + break; + } + } + + private void sendUpdate(IOpenVPNStatusCallback broadcastItem, + UpdateMessage um) throws RemoteException { + broadcastItem.newStatus(um.vpnUUID, um.state, um.logmessage, um.level.name()); + } + } + + +} \ No newline at end of file diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/SecurityRemoteException.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/SecurityRemoteException.java new file mode 100644 index 00000000..08d90e3b --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/SecurityRemoteException.java @@ -0,0 +1,12 @@ +package de.blinkt.openvpn.api; + +import android.os.RemoteException; + +public class SecurityRemoteException extends RemoteException { + + /** + * + */ + private static final long serialVersionUID = 1L; + +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/CIDRIP.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/CIDRIP.java new file mode 100644 index 00000000..960e7d11 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/CIDRIP.java @@ -0,0 +1,70 @@ +package de.blinkt.openvpn.core; + +import java.util.Locale; + +class CIDRIP { + String mIp; + int len; + + + public CIDRIP(String ip, String mask) { + mIp = ip; + long netmask = getInt(mask); + + // Add 33. bit to ensure the loop terminates + netmask += 1l << 32; + + int lenZeros = 0; + while ((netmask & 0x1) == 0) { + lenZeros++; + netmask = netmask >> 1; + } + // Check if rest of netmask is only 1s + if (netmask != (0x1ffffffffl >> lenZeros)) { + // Asume no CIDR, set /32 + len = 32; + } else { + len = 32 - lenZeros; + } + + } + + public CIDRIP(String address, int prefix_length) { + len = prefix_length; + mIp = address; + } + + @Override + public String toString() { + return String.format(Locale.ENGLISH, "%s/%d", mIp, len); + } + + public boolean normalise() { + long ip = getInt(mIp); + + long newip = ip & (0xffffffffl << (32 - len)); + if (newip != ip) { + mIp = String.format("%d.%d.%d.%d", (newip & 0xff000000) >> 24, (newip & 0xff0000) >> 16, (newip & 0xff00) >> 8, newip & 0xff); + return true; + } else { + return false; + } + } + + static long getInt(String ipaddr) { + String[] ipt = ipaddr.split("\\."); + long ip = 0; + + ip += Long.parseLong(ipt[0]) << 24; + ip += Integer.parseInt(ipt[1]) << 16; + ip += Integer.parseInt(ipt[2]) << 8; + ip += Integer.parseInt(ipt[3]); + + return ip; + } + + public long getInt() { + return getInt(mIp); + } + +} \ No newline at end of file diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ConfigParser.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ConfigParser.java new file mode 100644 index 00000000..378b6b92 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ConfigParser.java @@ -0,0 +1,767 @@ +package de.blinkt.openvpn.core; + +import de.blinkt.openvpn.VpnProfile; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.Reader; +import java.util.Collections; +import java.util.HashMap; +import java.util.Locale; +import java.util.Vector; + +//! Openvpn Config FIle Parser, probably not 100% accurate but close enough + +// And remember, this is valid :) +// -- +// bar +// +public class ConfigParser { + + + public static final String CONVERTED_PROFILE = "converted Profile"; + private HashMap>> options = new HashMap>>(); + private HashMap> meta = new HashMap>(); + + + private boolean extraRemotesAsCustom=false; + + public void parseConfig(Reader reader) throws IOException, ConfigParseError { + + + BufferedReader br =new BufferedReader(reader); + + while (true){ + String line = br.readLine(); + if(line==null) + break; + + // Check for OpenVPN Access Server Meta information + if (line.startsWith("# OVPN_ACCESS_SERVER_")) { + Vector metaarg = parsemeta(line); + meta.put(metaarg.get(0),metaarg); + continue; + } + Vector args = parseline(line); + + if(args.size() ==0) + continue; + + + if(args.get(0).startsWith("--")) + args.set(0, args.get(0).substring(2)); + + checkinlinefile(args,br); + + String optionname = args.get(0); + if(!options.containsKey(optionname)) { + options.put(optionname, new Vector>()); + } + options.get(optionname).add(args); + } + } + + private Vector parsemeta(String line) { + String meta = line.split("#\\sOVPN_ACCESS_SERVER_", 2)[1]; + String[] parts = meta.split("=",2); + Vector rval = new Vector(); + Collections.addAll(rval, parts); + return rval; + + } + + private void checkinlinefile(Vector args, BufferedReader br) throws IOException, ConfigParseError { + String arg0 = args.get(0).trim(); + // CHeck for + if(arg0.startsWith("<") && arg0.endsWith(">")) { + String argname = arg0.substring(1, arg0.length()-1); + String inlinefile = VpnProfile.INLINE_TAG; + + String endtag = String.format("",argname); + do { + String line = br.readLine(); + if(line==null){ + throw new ConfigParseError(String.format("No endtag for starttag <%s> found",argname,argname)); + } + if(line.trim().equals(endtag)) + break; + else { + inlinefile+=line; + inlinefile+= "\n"; + } + } while(true); + + args.clear(); + args.add(argname); + args.add(inlinefile); + } + + } + + enum linestate { + initial, + readin_single_quote + , reading_quoted, reading_unquoted, done} + + private boolean space(char c) { + // I really hope nobody is using zero bytes inside his/her config file + // to sperate parameter but here we go: + return Character.isWhitespace(c) || c == '\0'; + + } + + public class ConfigParseError extends Exception { + private static final long serialVersionUID = -60L; + + public ConfigParseError(String msg) { + super(msg); + } + } + + + // adapted openvpn's parse function to java + private Vector parseline(String line) throws ConfigParseError { + Vector parameters = new Vector(); + + if (line.length()==0) + return parameters; + + + linestate state = linestate.initial; + boolean backslash = false; + char out=0; + + int pos=0; + String currentarg=""; + + do { + // Emulate the c parsing ... + char in; + if(pos < line.length()) + in = line.charAt(pos); + else + in = '\0'; + + if (!backslash && in == '\\' && state != linestate.readin_single_quote) + { + backslash = true; + } + else + { + if (state == linestate.initial) + { + if (!space (in)) + { + if (in == ';' || in == '#') /* comment */ + break; + if (!backslash && in == '\"') + state = linestate.reading_quoted; + else if (!backslash && in == '\'') + state = linestate.readin_single_quote; + else + { + out = in; + state = linestate.reading_unquoted; + } + } + } + else if (state == linestate.reading_unquoted) + { + if (!backslash && space (in)) + state = linestate.done; + else + out = in; + } + else if (state == linestate.reading_quoted) + { + if (!backslash && in == '\"') + state = linestate.done; + else + out = in; + } + else if (state == linestate.readin_single_quote) + { + if (in == '\'') + state = linestate.done; + else + out = in; + } + + if (state == linestate.done) + { + /* ASSERT (parm_len > 0); */ + state = linestate.initial; + parameters.add(currentarg); + currentarg = ""; + out =0; + } + + if (backslash && out!=0) + { + if (!(out == '\\' || out == '\"' || space (out))) + { + throw new ConfigParseError("Options warning: Bad backslash ('\\') usage"); + } + } + backslash = false; + } + + /* store parameter character */ + if (out!=0) + { + currentarg+=out; + } + } while (pos++ < line.length()); + + return parameters; + } + + + final String[] unsupportedOptions = { "config", + "connection", + "proto-force", + "remote-random", + "tls-server" + + }; + + // Ignore all scripts + // in most cases these won't work and user who wish to execute scripts will + // figure out themselves + final String[] ignoreOptions = { "tls-client", + "askpass", + "auth-nocache", + "up", + "down", + "route-up", + "ipchange", + "route-up", + "route-pre-down", + "auth-user-pass-verify", + "dhcp-release", + "dhcp-renew", + "dh", + "group", + "ip-win32", + "management-hold", + "management", + "management-client", + "management-query-remote", + "management-query-passwords", + "management-query-proxy", + "management-external-key", + "management-forget-disconnect", + "management-signal", + "management-log-cache", + "management-up-down", + "management-client-user", + "management-client-group", + "pause-exit", + "plugin", + "machine-readable-output", + "persist-key", + "register-dns", + "route-delay", + "route-gateway", + "route-metric", + "route-method", + "status", + "script-security", + "show-net-up", + "suppress-timestamps", + "tmp-dir", + "tun-ipv6", + "topology", + "user", + "win-sys", + + }; + + final String[][] ignoreOptionsWithArg = + { + {"setenv", "IV_GUI_VER"}, + {"setenv", "IV_OPENVPN_GUI_VERSION"} + }; + + final String[] connectionOptions = { + "local", + "remote", + "float", + "port", +// "connect-retry", + "connect-timeout", + "connect-retry-max", + "link-mtu", + "tun-mtu", + "tun-mtu-extra", + "fragment", + "mtu-disc", + "local-port", + "remote-port", + "bind", + "nobind", + "proto", + "http-proxy", + "http-proxy-retry", + "http-proxy-timeout", + "http-proxy-option", + "socks-proxy", + "socks-proxy-retry", + "explicit-exit-notify", + "mssfix" + }; + + + // This method is far too long + @SuppressWarnings("ConstantConditions") + public VpnProfile convertProfile() throws ConfigParseError{ + boolean noauthtypeset=true; + VpnProfile np = new VpnProfile(CONVERTED_PROFILE); + // Pull, client, tls-client + np.clearDefaults(); + + if(options.containsKey("client") || options.containsKey("pull")) { + np.mUsePull=true; + options.remove("pull"); + options.remove("client"); + } + + Vector secret = getOption("secret", 1, 2); + if(secret!=null) + { + np.mAuthenticationType=VpnProfile.TYPE_STATICKEYS; + noauthtypeset=false; + np.mUseTLSAuth=true; + np.mTLSAuthFilename=secret.get(1); + if(secret.size()==3) + np.mTLSAuthDirection=secret.get(2); + + } + + Vector> routes = getAllOption("route", 1, 4); + if(routes!=null) { + String routeopt = ""; + String routeExcluded = ""; + for(Vector route:routes){ + String netmask = "255.255.255.255"; + String gateway = "vpn_gateway"; + + if(route.size() >= 3) + netmask = route.get(2); + if (route.size() >= 4) + gateway = route.get(3); + + String net = route.get(1); + try { + CIDRIP cidr = new CIDRIP(net, netmask); + if (gateway.equals("net_gateway")) + routeExcluded += cidr.toString() + " "; + else + routeopt+=cidr.toString() + " "; + } catch (ArrayIndexOutOfBoundsException aioob) { + throw new ConfigParseError("Could not parse netmask of route " + netmask); + } catch (NumberFormatException ne) { + + + + + throw new ConfigParseError("Could not parse netmask of route " + netmask); + } + + } + np.mCustomRoutes=routeopt; + np.mExcludedRoutes=routeExcluded; + } + + Vector> routesV6 = getAllOption("route-ipv6", 1, 4); + if (routesV6!=null) { + String customIPv6Routes = ""; + for (Vector route:routesV6){ + customIPv6Routes += route.get(1) + " "; + } + + np.mCustomRoutesv6 = customIPv6Routes; + } + + // Also recognize tls-auth [inline] direction ... + Vector> tlsauthoptions = getAllOption("tls-auth", 1, 2); + if(tlsauthoptions!=null) { + for(Vector tlsauth:tlsauthoptions) { + if(tlsauth!=null) + { + if(!tlsauth.get(1).equals("[inline]")) { + np.mTLSAuthFilename=tlsauth.get(1); + np.mUseTLSAuth=true; + } + if(tlsauth.size()==3) + np.mTLSAuthDirection=tlsauth.get(2); + } + } + } + + Vector direction = getOption("key-direction", 1, 1); + if(direction!=null) + np.mTLSAuthDirection=direction.get(1); + + Vector> defgw = getAllOption("redirect-gateway", 0, 5); + if(defgw != null) + { + np.mUseDefaultRoute=true; + checkRedirectParameters(np, defgw); + } + + Vector> redirectPrivate = getAllOption("redirect-private",0,5); + if (redirectPrivate != null) + { + checkRedirectParameters(np,redirectPrivate); + } + Vector dev =getOption("dev",1,1); + Vector devtype =getOption("dev-type",1,1); + + if ((devtype != null && devtype.get(1).equals("tun")) || + (dev != null && dev.get(1).startsWith("tun")) || + (devtype == null && dev == null)) { + //everything okay + } else { + throw new ConfigParseError("Sorry. Only tun mode is supported. See the FAQ for more detail"); + } + + + + Vector mode =getOption("mode",1,1); + if (mode != null){ + if(!mode.get(1).equals("p2p")) + throw new ConfigParseError("Invalid mode for --mode specified, need p2p"); + } + + Vector port = getOption("port", 1,1); + if(port!=null){ + np.mServerPort = port.get(1); + } + + Vector rport = getOption("rport", 1,1); + if(port!=null){ + np.mServerPort = port.get(1); + } + + Vector proto = getOption("proto", 1,1); + if(proto!=null){ + np.mUseUdp=isUdpProto(proto.get(1)); + } + + // Parse remote config + Vector> remotes = getAllOption("remote",1,3); + + if(remotes!=null && remotes.size()>=1 ) { + Vector remote = remotes.get(0); + switch (remote.size()) { + case 4: + np.mUseUdp=isUdpProto(remote.get(3)); + case 3: + np.mServerPort = remote.get(2); + case 2: + np.mServerName = remote.get(1); + } + } + + + + Vector> dhcpoptions = getAllOption("dhcp-option", 2, 2); + if(dhcpoptions!=null) { + for(Vector dhcpoption:dhcpoptions) { + String type=dhcpoption.get(1); + String arg = dhcpoption.get(2); + if(type.equals("DOMAIN")) { + np.mSearchDomain=dhcpoption.get(2); + } else if(type.equals("DNS")) { + np.mOverrideDNS=true; + if(np.mDNS1.equals(VpnProfile.DEFAULT_DNS1)) + np.mDNS1=arg; + else + np.mDNS2=arg; + } + } + } + + Vector ifconfig = getOption("ifconfig", 2, 2); + if(ifconfig!=null) { + try { + CIDRIP cidr = new CIDRIP(ifconfig.get(1), ifconfig.get(2)); + np.mIPv4Address=cidr.toString(); + } catch (NumberFormatException nfe) { + throw new ConfigParseError("Could not pase ifconfig IP address: " + nfe.getLocalizedMessage()); + } + + } + + if(getOption("remote-random-hostname", 0, 0)!=null) + np.mUseRandomHostname=true; + + if(getOption("float", 0, 0)!=null) + np.mUseFloat=true; + + if(getOption("comp-lzo", 0, 1)!=null) + np.mUseLzo=true; + + Vector cipher = getOption("cipher", 1, 1); + if(cipher!=null) + np.mCipher= cipher.get(1); + + Vector auth = getOption("auth", 1, 1); + if(auth!=null) + np.mAuth = auth.get(1); + + + Vector ca = getOption("ca",1,1); + if(ca!=null){ + np.mCaFilename = ca.get(1); + } + + Vector cert = getOption("cert",1,1); + if(cert!=null){ + np.mClientCertFilename = cert.get(1); + np.mAuthenticationType = VpnProfile.TYPE_CERTIFICATES; + noauthtypeset=false; + } + Vector key= getOption("key",1,1); + if(key!=null) + np.mClientKeyFilename=key.get(1); + + Vector pkcs12 = getOption("pkcs12",1,1); + if(pkcs12!=null) { + np.mPKCS12Filename = pkcs12.get(1); + np.mAuthenticationType = VpnProfile.TYPE_KEYSTORE; + noauthtypeset=false; + } + + + Vector compatnames = getOption("compat-names",1,2); + Vector nonameremapping = getOption("no-name-remapping",1,1); + Vector tlsremote = getOption("tls-remote",1,1); + if(tlsremote!=null){ + np.mRemoteCN = tlsremote.get(1); + np.mCheckRemoteCN=true; + np.mX509AuthType = VpnProfile.X509_VERIFY_TLSREMOTE; + + if((compatnames!=null && compatnames.size() > 2) || + (nonameremapping!=null)) + np.mX509AuthType = VpnProfile.X509_VERIFY_TLSREMOTE_COMPAT_NOREMAPPING; + } + + Vector verifyx509name = getOption("verify-x509-name",1,2); + if(verifyx509name!=null){ + np.mRemoteCN = verifyx509name.get(1); + np.mCheckRemoteCN=true; + if(verifyx509name.size()>2) { + if (verifyx509name.get(2).equals("name")) + np.mX509AuthType=VpnProfile.X509_VERIFY_TLSREMOTE_RDN; + else if (verifyx509name.get(2).equals("name-prefix")) + np.mX509AuthType=VpnProfile.X509_VERIFY_TLSREMOTE_RDN_PREFIX; + else + throw new ConfigParseError("Unknown parameter to x509-verify-name: " + verifyx509name.get(2) ); + } else { + np.mX509AuthType = VpnProfile.X509_VERIFY_TLSREMOTE_DN; + } + + } + + + Vector verb = getOption("verb",1,1); + if(verb!=null){ + np.mVerb=verb.get(1); + } + + + if(getOption("nobind", 0, 0) != null) + np.mNobind=true; + + if(getOption("persist-tun", 0,0) != null) + np.mPersistTun=true; + + Vector connectretry = getOption("connect-retry", 1, 1); + if(connectretry!=null) + np.mConnectRetry =connectretry.get(1); + + Vector connectretrymax = getOption("connect-retry-max", 1, 1); + if(connectretrymax!=null) + np.mConnectRetryMax =connectretrymax.get(1); + + Vector> remotetls = getAllOption("remote-cert-tls", 1, 1); + if(remotetls!=null) + if(remotetls.get(0).get(1).equals("server")) + np.mExpectTLSCert=true; + else + options.put("remotetls",remotetls); + + Vector authuser = getOption("auth-user-pass",0,1); + if(authuser !=null){ + if(noauthtypeset) { + np.mAuthenticationType=VpnProfile.TYPE_USERPASS; + } else if(np.mAuthenticationType==VpnProfile.TYPE_CERTIFICATES) { + np.mAuthenticationType=VpnProfile.TYPE_USERPASS_CERTIFICATES; + } else if(np.mAuthenticationType==VpnProfile.TYPE_KEYSTORE) { + np.mAuthenticationType=VpnProfile.TYPE_USERPASS_KEYSTORE; + } + if(authuser.size()>1) { + // Set option value to password get to get cance to embed later. + np.mUsername=null; + np.mPassword=authuser.get(1); + useEmbbedUserAuth(np,authuser.get(1)); + } + } + + // Parse OpenVPN Access Server extra + Vector friendlyname = meta.get("FRIENDLY_NAME"); + if(friendlyname !=null && friendlyname.size() > 1) + np.mName=friendlyname.get(1); + + + Vector ocusername = meta.get("USERNAME"); + if(ocusername !=null && ocusername.size() > 1) + np.mUsername=ocusername.get(1); + + // Check the other options + if(remotes !=null && remotes.size()>1 && extraRemotesAsCustom) { + // first is already added + remotes.remove(0); + np.mCustomConfigOptions += getOptionStrings(remotes); + np.mUseCustomConfig=true; + + } + checkIgnoreAndInvalidOptions(np); + fixup(np); + + return np; + } + + private void checkRedirectParameters(VpnProfile np, Vector> defgw) { + for (Vector redirect: defgw) + for (int i=1;i= 2) { + np.mUsername=parts[0]; + np.mPassword=parts[1]; + } + } + + private void checkIgnoreAndInvalidOptions(VpnProfile np) throws ConfigParseError { + for(String option:unsupportedOptions) + if(options.containsKey(option)) + throw new ConfigParseError(String.format("Unsupported Option %s encountered in config file. Aborting",option)); + + for(String option:ignoreOptions) + // removing an item which is not in the map is no error + options.remove(option); + + + + + if(options.size()> 0) { + np.mCustomConfigOptions += "# These Options were found in the config file do not map to config settings:\n"; + + for(Vector> option:options.values()) { + + np.mCustomConfigOptions += getOptionStrings(option); + + } + np.mUseCustomConfig=true; + + } + } + + + boolean ignoreThisOption(Vector option) { + for (String[] ignoreOption : ignoreOptionsWithArg) { + + if (option.size() < ignoreOption.length) + continue; + + boolean ignore = true; + for (int i = 0; i < ignoreOption.length; i++) { + if (!ignoreOption[i].equals(option.get(i))) + ignore = false; + } + if (ignore) + return true; + + } + return false; + } + + private String getOptionStrings(Vector> option) { + String custom = ""; + for (Vector optionsline : option) { + if (!ignoreThisOption(optionsline)) { + for (String arg : optionsline) + custom += VpnProfile.openVpnEscape(arg) + " "; + custom += "\n"; + } + } + return custom; + } + + + private void fixup(VpnProfile np) { + if(np.mRemoteCN.equals(np.mServerName)) { + np.mRemoteCN=""; + } + } + + private Vector getOption(String option, int minarg, int maxarg) throws ConfigParseError { + Vector> alloptions = getAllOption(option, minarg, maxarg); + if(alloptions==null) + return null; + else + return alloptions.lastElement(); + } + + + private Vector> getAllOption(String option, int minarg, int maxarg) throws ConfigParseError { + Vector> args = options.get(option); + if(args==null) + return null; + + for(Vector optionline:args) + + if(optionline.size()< (minarg+1) || optionline.size() > maxarg+1) { + String err = String.format(Locale.getDefault(),"Option %s has %d parameters, expected between %d and %d", + option,optionline.size()-1,minarg,maxarg ); + throw new ConfigParseError(err); + } + options.remove(option); + return args; + } + +} + + + + diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/DeviceStateReceiver.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/DeviceStateReceiver.java new file mode 100644 index 00000000..18c5f1d9 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/DeviceStateReceiver.java @@ -0,0 +1,243 @@ +package de.blinkt.openvpn.core; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.SharedPreferences; +import android.net.ConnectivityManager; +import android.net.NetworkInfo; +import android.net.NetworkInfo.State; +import android.preference.PreferenceManager; +import se.leap.bitmaskclient.R; +import de.blinkt.openvpn.core.VpnStatus.ByteCountListener; + +import java.util.LinkedList; + +import static de.blinkt.openvpn.core.OpenVPNManagement.pauseReason; + +public class DeviceStateReceiver extends BroadcastReceiver implements ByteCountListener { + private int lastNetwork = -1; + private OpenVPNManagement mManagement; + + // Window time in s + private final int TRAFFIC_WINDOW = 60; + // Data traffic limit in bytes + private final long TRAFFIC_LIMIT = 64 * 1024; + + + connectState network = connectState.DISCONNECTED; + connectState screen = connectState.SHOULDBECONNECTED; + connectState userpause = connectState.SHOULDBECONNECTED; + + private String lastStateMsg = null; + + enum connectState { + SHOULDBECONNECTED, + PENDINGDISCONNECT, + DISCONNECTED + } + + static class Datapoint { + private Datapoint(long t, long d) { + timestamp = t; + data = d; + } + + long timestamp; + long data; + } + + LinkedList trafficdata = new LinkedList(); + + @Override + public void updateByteCount(long in, long out, long diffIn, long diffOut) { + if (screen != connectState.PENDINGDISCONNECT) + return; + + long total = diffIn + diffOut; + trafficdata.add(new Datapoint(System.currentTimeMillis(), total)); + + while (trafficdata.getFirst().timestamp <= (System.currentTimeMillis() - TRAFFIC_WINDOW * 1000)) { + trafficdata.removeFirst(); + } + + long windowtraffic = 0; + for (Datapoint dp : trafficdata) + windowtraffic += dp.data; + + if (windowtraffic < TRAFFIC_LIMIT) { + screen = connectState.DISCONNECTED; + VpnStatus.logInfo(R.string.screenoff_pause, + OpenVpnService.humanReadableByteCount(TRAFFIC_LIMIT, false), TRAFFIC_WINDOW); + + mManagement.pause(getPauseReason()); + } + } + + + public void userPause(boolean pause) { + if (pause) { + userpause = connectState.DISCONNECTED; + // Check if we should disconnect + mManagement.pause(getPauseReason()); + } else { + boolean wereConnected = shouldBeConnected(); + userpause = connectState.SHOULDBECONNECTED; + if (shouldBeConnected() && !wereConnected) + mManagement.resume(); + else + // Update the reason why we currently paused + mManagement.pause(getPauseReason()); + } + } + + public DeviceStateReceiver(OpenVPNManagement magnagement) { + super(); + mManagement = magnagement; + } + + + @Override + public void onReceive(Context context, Intent intent) { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); + + + if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) { + networkStateChange(context); + } else if (Intent.ACTION_SCREEN_OFF.equals(intent.getAction())) { + boolean screenOffPause = prefs.getBoolean("screenoff", false); + + if (screenOffPause) { + if (ProfileManager.getLastConnectedVpn()!=null && !ProfileManager.getLastConnectedVpn().mPersistTun) + VpnStatus.logError(R.string.screen_nopersistenttun); + + screen = connectState.PENDINGDISCONNECT; + fillTrafficData(); + if (network == connectState.DISCONNECTED || userpause == connectState.DISCONNECTED) + screen = connectState.DISCONNECTED; + } + } else if (Intent.ACTION_SCREEN_ON.equals(intent.getAction())) { + // Network was disabled because screen off + boolean connected = shouldBeConnected(); + screen = connectState.SHOULDBECONNECTED; + + /* should be connected has changed because the screen is on now, connect the VPN */ + if (shouldBeConnected() != connected) + mManagement.resume(); + else if (!shouldBeConnected()) + /*Update the reason why we are still paused */ + mManagement.pause(getPauseReason()); + + } + } + + + private void fillTrafficData() { + trafficdata.add(new Datapoint(System.currentTimeMillis(), TRAFFIC_LIMIT)); + } + + + public void networkStateChange(Context context) { + NetworkInfo networkInfo = getCurrentNetworkInfo(context); + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); + boolean sendusr1 = prefs.getBoolean("netchangereconnect", true); + + + String netstatestring; + if (networkInfo == null) { + netstatestring = "not connected"; + } else { + String subtype = networkInfo.getSubtypeName(); + if (subtype == null) + subtype = ""; + String extrainfo = networkInfo.getExtraInfo(); + if (extrainfo == null) + extrainfo = ""; + + /* + if(networkInfo.getType()==android.net.ConnectivityManager.TYPE_WIFI) { + WifiManager wifiMgr = (WifiManager) context.getSystemService(Context.WIFI_SERVICE); + WifiInfo wifiinfo = wifiMgr.getConnectionInfo(); + extrainfo+=wifiinfo.getBSSID(); + + subtype += wifiinfo.getNetworkId(); + }*/ + + + netstatestring = String.format("%2$s %4$s to %1$s %3$s", networkInfo.getTypeName(), + networkInfo.getDetailedState(), extrainfo, subtype); + } + + if (networkInfo != null && networkInfo.getState() == State.CONNECTED) { + int newnet = networkInfo.getType(); + network = connectState.SHOULDBECONNECTED; + + if (lastNetwork != newnet) { + if (screen == connectState.PENDINGDISCONNECT) + screen = connectState.DISCONNECTED; + + if (shouldBeConnected()) { + if (sendusr1) { + if (lastNetwork == -1) { + mManagement.resume(); + } else { + mManagement.reconnect(); + } + } else { + mManagement.networkChange(); + } + } + + + lastNetwork = newnet; + } + } else if (networkInfo == null) { + // Not connected, stop openvpn, set last connected network to no network + lastNetwork = -1; + if (sendusr1) { + network = connectState.DISCONNECTED; + + // Set screen state to be disconnected if disconnect pending + if (screen == connectState.PENDINGDISCONNECT) + screen = connectState.DISCONNECTED; + + mManagement.pause(getPauseReason()); + } + } + + + if (!netstatestring.equals(lastStateMsg)) + VpnStatus.logInfo(R.string.netstatus, netstatestring); + lastStateMsg = netstatestring; + + } + + public boolean isUserPaused() { + return userpause == connectState.DISCONNECTED; + } + + private boolean shouldBeConnected() { + return (screen == connectState.SHOULDBECONNECTED && userpause == connectState.SHOULDBECONNECTED && + network == connectState.SHOULDBECONNECTED); + } + + private pauseReason getPauseReason() { + if (userpause == connectState.DISCONNECTED) + return pauseReason.userPause; + + if (screen == connectState.DISCONNECTED) + return pauseReason.screenOff; + + if (network == connectState.DISCONNECTED) + return pauseReason.noNetwork; + + return pauseReason.userPause; + } + + private NetworkInfo getCurrentNetworkInfo(Context context) { + ConnectivityManager conn = (ConnectivityManager) + context.getSystemService(Context.CONNECTIVITY_SERVICE); + + return conn.getActiveNetworkInfo(); + } +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ICSOpenVPNApplication.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ICSOpenVPNApplication.java new file mode 100644 index 00000000..1daa3433 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ICSOpenVPNApplication.java @@ -0,0 +1,14 @@ +package de.blinkt.openvpn.core; + +import android.app.Application; + +/** + * Created by arne on 28.12.13. + */ +public class ICSOpenVPNApplication extends Application { + @Override + public void onCreate() { + super.onCreate(); + PRNGFixes.apply(); + } +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/NativeUtils.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/NativeUtils.java new file mode 100644 index 00000000..a2c4796d --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/NativeUtils.java @@ -0,0 +1,13 @@ +package de.blinkt.openvpn.core; + +import java.security.InvalidKeyException; + +public class NativeUtils { + public static native byte[] rsasign(byte[] input,int pkey) throws InvalidKeyException; + static native void jniclose(int fdint); + + static { + System.loadLibrary("stlport_shared"); + System.loadLibrary("opvpnutil"); + } +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/NetworkSpace.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/NetworkSpace.java new file mode 100644 index 00000000..990e70d8 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/NetworkSpace.java @@ -0,0 +1,300 @@ +package de.blinkt.openvpn.core; + +import android.os.Build; +import android.text.TextUtils; + +import junit.framework.Assert; + +import java.math.BigInteger; +import java.net.Inet6Address; +import java.util.*; + +import se.leap.bitmaskclient.BuildConfig; + +public class NetworkSpace { + + + static class ipAddress implements Comparable { + private BigInteger netAddress; + public int networkMask; + private boolean included; + private boolean isV4; + private BigInteger firstAddress; + private BigInteger lastAddress; + + + @Override + public int compareTo(ipAddress another) { + int comp = getFirstAddress().compareTo(another.getFirstAddress()); + if (comp != 0) + return comp; + + // bigger mask means smaller address block + if (networkMask > another.networkMask) + return -1; + else if (another.networkMask == networkMask) + return 0; + else + return 1; + } + + public ipAddress(CIDRIP ip, boolean include) { + included = include; + netAddress = BigInteger.valueOf(ip.getInt()); + networkMask = ip.len; + isV4 = true; + } + + public ipAddress(Inet6Address address, int mask, boolean include) { + networkMask = mask; + included = include; + + int s = 128; + + netAddress = BigInteger.ZERO; + for (byte b : address.getAddress()) { + s -= 16; + netAddress = netAddress.add(BigInteger.valueOf(b).shiftLeft(s)); + } + } + + public BigInteger getLastAddress() { + if(lastAddress ==null) + lastAddress = getMaskedAddress(true); + return lastAddress; + } + + + public BigInteger getFirstAddress() { + if (firstAddress ==null) + firstAddress =getMaskedAddress(false); + return firstAddress; + } + + + private BigInteger getMaskedAddress(boolean one) { + BigInteger numAddress = netAddress; + + int numBits; + if (isV4) { + numBits = 32 - networkMask; + } else { + numBits = 128 - networkMask; + } + + for (int i = 0; i < numBits; i++) { + if (one) + numAddress = numAddress.setBit(i); + else + numAddress = numAddress.clearBit(i); + } + return numAddress; + } + + + @Override + public String toString() { + //String in = included ? "+" : "-"; + if (isV4) + return String.format(Locale.US,"%s/%d", getIPv4Address(), networkMask); + else + return String.format(Locale.US, "%s/%d", getIPv6Address(), networkMask); + } + + ipAddress(BigInteger baseAddress, int mask, boolean included, boolean isV4) { + this.netAddress = baseAddress; + this.networkMask = mask; + this.included = included; + this.isV4 = isV4; + } + + + public ipAddress[] split() { + ipAddress firsthalf = new ipAddress(getFirstAddress(), networkMask + 1, included, isV4); + ipAddress secondhalf = new ipAddress(firsthalf.getLastAddress().add(BigInteger.ONE), networkMask + 1, included, isV4); + if (BuildConfig.DEBUG) Assert.assertTrue(secondhalf.getLastAddress().equals(getLastAddress())); + return new ipAddress[]{firsthalf, secondhalf}; + } + + String getIPv4Address() { + if (BuildConfig.DEBUG) { + Assert.assertTrue (isV4); + Assert.assertTrue (netAddress.longValue() <= 0xffffffffl); + Assert.assertTrue (netAddress.longValue() >= 0); + } + long ip = netAddress.longValue(); + return String.format(Locale.US, "%d.%d.%d.%d", (ip >> 24) % 256, (ip >> 16) % 256, (ip >> 8) % 256, ip % 256); + } + + String getIPv6Address() { + if (BuildConfig.DEBUG) Assert.assertTrue (!isV4); + BigInteger r = netAddress; + if (r.longValue() == 0) + return "::"; + + Vector parts = new Vector(); + while (r.compareTo(BigInteger.ZERO) == 1) { + parts.add(0, String.format(Locale.US, "%x", r.mod(BigInteger.valueOf(256)).longValue())); + r = r.shiftRight(16); + } + + return TextUtils.join(":", parts); + } + + public boolean containsNet(ipAddress network) { + return getFirstAddress().compareTo(network.getFirstAddress()) != 1 && + getLastAddress().compareTo(network.getLastAddress()) != -1; + } + } + + + TreeSet mIpAddresses = new TreeSet(); + + + public Collection getNetworks(boolean included) { + Vector ips = new Vector(); + for (ipAddress ip : mIpAddresses) { + if (ip.included == included) + ips.add(ip); + } + return ips; + } + + public void clear() { + mIpAddresses.clear(); + } + + + void addIP(CIDRIP cidrIp, boolean include) { + + mIpAddresses.add(new ipAddress(cidrIp, include)); + } + + void addIPv6(Inet6Address address, int mask, boolean included) { + mIpAddresses.add(new ipAddress(address, mask, included)); + } + + TreeSet generateIPList() { + + PriorityQueue networks = new PriorityQueue(mIpAddresses); + + TreeSet ipsDone = new TreeSet(); + + ipAddress currentNet = networks.poll(); + if (currentNet==null) + return ipsDone; + + while (currentNet!=null) { + // Check if it and the next of it are compatbile + ipAddress nextNet = networks.poll(); + + if (BuildConfig.DEBUG) Assert.assertNotNull(currentNet); + if (nextNet== null || currentNet.getLastAddress().compareTo(nextNet.getFirstAddress()) == -1) { + // Everything good, no overlapping nothing to do + ipsDone.add(currentNet); + + currentNet = nextNet; + } else { + // This network is smaller or equal to the next but has the same base address + if (currentNet.getFirstAddress().equals(nextNet.getFirstAddress()) && currentNet.networkMask >= nextNet.networkMask) { + if (currentNet.included == nextNet.included) { + // Included in the next next and same type + // Simply forget our current network + currentNet=nextNet; + } else { + // our currentnet is included in next and types differ. Need to split the next network + ipAddress[] newNets = nextNet.split(); + + // First add the second half to keep the order in networks + if (!networks.contains(newNets[1])) + networks.add(newNets[1]); + + if (newNets[0].getLastAddress().equals(currentNet.getLastAddress())) { + if (BuildConfig.DEBUG) Assert.assertEquals (newNets[0].networkMask, currentNet.networkMask); + // Don't add the lower half that would conflict with currentNet + } else { + if (!networks.contains(newNets[0])) + networks.add(newNets[0]); + } + // Keep currentNet as is + } + } else { + if (BuildConfig.DEBUG) { + Assert.assertTrue(currentNet.networkMask < nextNet.networkMask); + Assert.assertTrue (nextNet.getFirstAddress().compareTo(currentNet.getFirstAddress()) == 1); + Assert.assertTrue (currentNet.getLastAddress().compareTo(nextNet.getLastAddress()) != -1); + } + // This network is bigger than the next and last ip of current >= next + + if (currentNet.included == nextNet.included) { + // Next network is in included in our network with the same type, + // simply ignore the next and move on + } else { + // We need to split our network + ipAddress[] newNets = currentNet.split(); + + + if (newNets[1].networkMask == nextNet.networkMask) { + if (BuildConfig.DEBUG) { + Assert.assertTrue (newNets[1].getFirstAddress().equals(nextNet.getFirstAddress())); + Assert.assertTrue (newNets[1].getLastAddress().equals(currentNet.getLastAddress())); + // Splitted second equal the next network, do not add it + } + networks.add(nextNet); + } else { + // Add the smaller network first + networks.add(newNets[1]); + networks.add(nextNet); + } + currentNet = newNets[0]; + + } + } + } + + } + + return ipsDone; + } + + Collection getPositiveIPList() { + TreeSet ipsSorted = generateIPList(); + + Vector ips = new Vector(); + for (ipAddress ia : ipsSorted) { + if (ia.included) + ips.add(ia); + } + + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) { + // Include postive routes from the original set under < 4.4 since these might overrule the local + // network but only if no smaller negative route exists + for(ipAddress origIp: mIpAddresses){ + if (!origIp.included) + continue; + + // The netspace exists + if(ipsSorted.contains(origIp)) + continue; + + boolean skipIp=false; + // If there is any smaller net that is excluded we may not add the positive route back + for (ipAddress calculatedIp: ipsSorted) { + if(!calculatedIp.included && origIp.containsNet(calculatedIp)) { + skipIp=true; + break; + } + } + if (skipIp) + continue; + + // It is safe to include the IP + ips.add(origIp); + } + + } + + return ips; + } + +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVPNManagement.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVPNManagement.java new file mode 100644 index 00000000..a5a3e9f4 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVPNManagement.java @@ -0,0 +1,24 @@ +package de.blinkt.openvpn.core; + +public interface OpenVPNManagement { + enum pauseReason { + noNetwork, + userPause, + screenOff + } + + int mBytecountInterval =2; + + void reconnect(); + + void pause(pauseReason reason); + + void resume(); + + boolean stopVPN(); + + /* + * Rebind the interface + */ + void networkChange(); +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVPNThread.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVPNThread.java new file mode 100644 index 00000000..67c24884 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVPNThread.java @@ -0,0 +1,174 @@ +package de.blinkt.openvpn.core; + +import android.util.Log; +import se.leap.bitmaskclient.R; +import de.blinkt.openvpn.VpnProfile; +import de.blinkt.openvpn.core.VpnStatus.ConnectionStatus; +import de.blinkt.openvpn.core.VpnStatus.LogItem; + +import java.io.*; +import java.text.SimpleDateFormat; +import java.util.*; +import java.util.Map.Entry; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public class OpenVPNThread implements Runnable { + private static final String DUMP_PATH_STRING = "Dump path: "; + private static final String TAG = "OpenVPN"; + public static final int M_FATAL = (1 << 4); + public static final int M_NONFATAL = (1 << 5); + public static final int M_WARN = (1 << 6); + public static final int M_DEBUG = (1 << 7); + private String[] mArgv; + private Process mProcess; + private String mNativeDir; + private OpenVpnService mService; + private String mDumpPath; + private Map mProcessEnv; + + public OpenVPNThread(OpenVpnService service,String[] argv, Map processEnv, String nativelibdir) + { + mArgv = argv; + mNativeDir = nativelibdir; + mService = service; + mProcessEnv = processEnv; + } + + public void stopProcess() { + mProcess.destroy(); + } + + + + @Override + public void run() { + try { + Log.i(TAG, "Starting openvpn"); + startOpenVPNThreadArgs(mArgv, mProcessEnv); + Log.i(TAG, "Giving up"); + } catch (Exception e) { + VpnStatus.logException("Starting OpenVPN Thread" ,e); + Log.e(TAG, "OpenVPNThread Got " + e.toString()); + } finally { + int exitvalue = 0; + try { + if (mProcess!=null) + exitvalue = mProcess.waitFor(); + } catch ( IllegalThreadStateException ite) { + VpnStatus.logError("Illegal Thread state: " + ite.getLocalizedMessage()); + } catch (InterruptedException ie) { + VpnStatus.logError("InterruptedException: " + ie.getLocalizedMessage()); + } + if( exitvalue != 0) + VpnStatus.logError("Process exited with exit value " + exitvalue); + + VpnStatus.updateStateString("NOPROCESS", "No process running.", R.string.state_noprocess, ConnectionStatus.LEVEL_NOTCONNECTED); + if(mDumpPath!=null) { + try { + BufferedWriter logout = new BufferedWriter(new FileWriter(mDumpPath + ".log")); + SimpleDateFormat timeformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.GERMAN); + for(LogItem li : VpnStatus.getlogbuffer()){ + String time = timeformat.format(new Date(li.getLogtime())); + logout.write(time +" " + li.getString(mService) + "\n"); + } + logout.close(); + VpnStatus.logError(R.string.minidump_generated); + } catch (IOException e) { + VpnStatus.logError("Writing minidump log: " + e.getLocalizedMessage()); + } + } + + mService.processDied(); + Log.i(TAG, "Exiting"); + } + } + + private void startOpenVPNThreadArgs(String[] argv, Map env) { + LinkedList argvlist = new LinkedList(); + + Collections.addAll(argvlist, argv); + + ProcessBuilder pb = new ProcessBuilder(argvlist); + // Hack O rama + + String lbpath = genLibraryPath(argv, pb); + + pb.environment().put("LD_LIBRARY_PATH", lbpath); + + // Add extra variables + for(Entry e:env.entrySet()){ + pb.environment().put(e.getKey(), e.getValue()); + } + pb.redirectErrorStream(true); + try { + mProcess = pb.start(); + // Close the output, since we don't need it + mProcess.getOutputStream().close(); + InputStream in = mProcess.getInputStream(); + BufferedReader br = new BufferedReader(new InputStreamReader(in)); + + while(true) { + String logline = br.readLine(); + if(logline==null) + return; + + if (logline.startsWith(DUMP_PATH_STRING)) + mDumpPath = logline.substring(DUMP_PATH_STRING.length()); + + + // 1380308330.240114 18000002 Send to HTTP proxy: 'X-Online-Host: bla.blabla.com' + + Pattern p = Pattern.compile("(\\d+).(\\d+) ([0-9a-f])+ (.*)"); + Matcher m = p.matcher(logline); + if(m.matches()) { + int flags = Integer.parseInt(m.group(3),16); + String msg = m.group(4); + int logLevel = flags & 0x0F; + + VpnStatus.LogLevel logStatus = VpnStatus.LogLevel.INFO; + + if ((flags & M_FATAL) != 0) + logStatus = VpnStatus.LogLevel.ERROR; + else if ((flags & M_NONFATAL)!=0) + logStatus = VpnStatus.LogLevel.WARNING; + else if ((flags & M_WARN)!=0) + logStatus = VpnStatus.LogLevel.WARNING; + else if ((flags & M_DEBUG)!=0) + logStatus = VpnStatus.LogLevel.VERBOSE; + + if (msg.startsWith("MANAGEMENT: CMD")) + logLevel = Math.max(4, logLevel); + + + VpnStatus.logMessageOpenVPN(logStatus,logLevel,msg); + } else { + VpnStatus.logInfo("P:" + logline); + } + } + + + } catch (IOException e) { + VpnStatus.logException("Error reading from output of OpenVPN process" , e); + stopProcess(); + } + + + } + + private String genLibraryPath(String[] argv, ProcessBuilder pb) { + // Hack until I find a good way to get the real library path + String applibpath = argv[0].replace("/cache/" + VpnProfile.MINIVPN , "/lib"); + + String lbpath = pb.environment().get("LD_LIBRARY_PATH"); + if(lbpath==null) + lbpath = applibpath; + else + lbpath = lbpath + ":" + applibpath; + + if (!applibpath.equals(mNativeDir)) { + lbpath = lbpath + ":" + mNativeDir; + } + return lbpath; + } +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVpnManagementThread.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVpnManagementThread.java new file mode 100644 index 00000000..4cba4f5f --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVpnManagementThread.java @@ -0,0 +1,598 @@ +package de.blinkt.openvpn.core; + +import android.content.Context; +import android.content.SharedPreferences; +import android.net.LocalServerSocket; +import android.net.LocalSocket; +import android.net.LocalSocketAddress; +import android.os.ParcelFileDescriptor; +import android.preference.PreferenceManager; +import android.util.Log; + +import org.jetbrains.annotations.NotNull; + +import se.leap.bitmaskclient.R; +import de.blinkt.openvpn.VpnProfile; +import de.blinkt.openvpn.core.VpnStatus.ConnectionStatus; + +import java.io.FileDescriptor; +import java.io.IOException; +import java.io.InputStream; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.net.InetSocketAddress; +import java.net.SocketAddress; +import java.util.*; + +public class OpenVpnManagementThread implements Runnable, OpenVPNManagement { + + private static final String TAG = "openvpn"; + private LocalSocket mSocket; + private VpnProfile mProfile; + private OpenVpnService mOpenVPNService; + private LinkedList mFDList=new LinkedList(); + private LocalServerSocket mServerSocket; + private boolean mReleaseHold=true; + private boolean mWaitingForRelease=false; + private long mLastHoldRelease=0; + + private static Vector active=new Vector(); + private LocalSocket mServerSocketLocal; + + private pauseReason lastPauseReason = pauseReason.noNetwork; + + public OpenVpnManagementThread(VpnProfile profile, OpenVpnService openVpnService) { + mProfile = profile; + mOpenVPNService = openVpnService; + + + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(openVpnService); + boolean managemeNetworkState = prefs.getBoolean("netchangereconnect", true); + if(managemeNetworkState) + mReleaseHold=false; + + } + + public boolean openManagementInterface(@NotNull Context c) { + // Could take a while to open connection + int tries=8; + + String socketName = (c.getCacheDir().getAbsolutePath() + "/" + "mgmtsocket"); + // The mServerSocketLocal is transferred to the LocalServerSocket, ignore warning + + mServerSocketLocal = new LocalSocket(); + + while(tries > 0 && !mServerSocketLocal.isConnected()) { + try { + mServerSocketLocal.bind(new LocalSocketAddress(socketName, + LocalSocketAddress.Namespace.FILESYSTEM)); + } catch (IOException e) { + // wait 300 ms before retrying + try { Thread.sleep(300); + } catch (InterruptedException e1) { + } + + } + tries--; + } + + try { + + mServerSocket = new LocalServerSocket(mServerSocketLocal.getFileDescriptor()); + return true; + } catch (IOException e) { + VpnStatus.logException(e); + } + return false; + + + } + + public void managmentCommand(String cmd) { + try { + if(mSocket!=null && mSocket.getOutputStream() !=null) { + mSocket.getOutputStream().write(cmd.getBytes()); + mSocket.getOutputStream().flush(); + } + }catch (IOException e) { + // Ignore socket stack traces + } + } + + + @Override + public void run() { + byte [] buffer =new byte[2048]; + // mSocket.setSoTimeout(5); // Setting a timeout cannot be that bad + + String pendingInput=""; + active.add(this); + + try { + // Wait for a client to connect + mSocket= mServerSocket.accept(); + InputStream instream = mSocket.getInputStream(); + // Close the management socket after client connected + + mServerSocket.close(); + // Closing one of the two sockets also closes the other + //mServerSocketLocal.close(); + + while(true) { + int numbytesread = instream.read(buffer); + if(numbytesread==-1) + return; + + FileDescriptor[] fds = null; + try { + fds = mSocket.getAncillaryFileDescriptors(); + } catch (IOException e) { + VpnStatus.logException("Error reading fds from socket", e); + } + if(fds!=null){ + Collections.addAll(mFDList, fds); + } + + String input = new String(buffer,0,numbytesread,"UTF-8"); + + pendingInput += input; + + pendingInput=processInput(pendingInput); + + + + } + } catch (IOException e) { + if (!e.getMessage().equals("socket closed")) + VpnStatus.logException(e); + } + active.remove(this); + } + + //! Hack O Rama 2000! + private void protectFileDescriptor(FileDescriptor fd) { + Exception exp; + try { + Method getInt = FileDescriptor.class.getDeclaredMethod("getInt$"); + int fdint = (Integer) getInt.invoke(fd); + + // You can even get more evil by parsing toString() and extract the int from that :) + + boolean result = mOpenVPNService.protect(fdint); + if (!result) + VpnStatus.logWarning("Could not protect VPN socket"); + + + //ParcelFileDescriptor pfd = ParcelFileDescriptor.fromFd(fdint); + //pfd.close(); + NativeUtils.jniclose(fdint); + return; + } catch (NoSuchMethodException e) { + exp =e; + } catch (IllegalArgumentException e) { + exp =e; + } catch (IllegalAccessException e) { + exp =e; + } catch (InvocationTargetException e) { + exp =e; + } catch (NullPointerException e) { + exp =e; + } + + Log.d("Openvpn", "Failed to retrieve fd from socket: " + fd); + VpnStatus.logException("Failed to retrieve fd from socket (" + fd + ")" , exp); + } + + private String processInput(String pendingInput) { + + + while(pendingInput.contains("\n")) { + String[] tokens = pendingInput.split("\\r?\\n", 2); + processCommand(tokens[0]); + if(tokens.length == 1) + // No second part, newline was at the end + pendingInput=""; + else + pendingInput=tokens[1]; + } + return pendingInput; + } + + + private void processCommand(String command) { + //Log.i(TAG, "Line from managment" + command); + + + if (command.startsWith(">") && command.contains(":")) { + String[] parts = command.split(":",2); + String cmd = parts[0].substring(1); + String argument = parts[1]; + + + if(cmd.equals("INFO")) { + /* Ignore greeting from management */ + return; + }else if (cmd.equals("PASSWORD")) { + processPWCommand(argument); + } else if (cmd.equals("HOLD")) { + handleHold(); + } else if (cmd.equals("NEED-OK")) { + processNeedCommand(argument); + } else if (cmd.equals("BYTECOUNT")){ + processByteCount(argument); + } else if (cmd.equals("STATE")) { + processState(argument); + } else if (cmd.equals("PROXY")) { + processProxyCMD(argument); + } else if (cmd.equals("LOG")) { + processLogMessage(argument); + } else if (cmd.equals("RSA_SIGN")) { + processSignCommand(argument); + } else { + VpnStatus.logWarning("MGMT: Got unrecognized command" + command); + Log.i(TAG, "Got unrecognized command" + command); + } + } else if (command.startsWith("SUCCESS:")) { + /* Ignore this kind of message too */ + return; + } else if (command.startsWith("PROTECTFD: ")) { + FileDescriptor fdtoprotect = mFDList.pollFirst(); + if (fdtoprotect!=null) + protectFileDescriptor(fdtoprotect); + } else { + Log.i(TAG, "Got unrecognized line from managment" + command); + VpnStatus.logWarning("MGMT: Got unrecognized line from management:" + command); + } + } + + private void processLogMessage(String argument) { + String[] args = argument.split(",",4); + // 0 unix time stamp + // 1 log level N,I,E etc. + /* + (b) zero or more message flags in a single string: + I -- informational + F -- fatal error + N -- non-fatal error + W -- warning + D -- debug, and + */ + // 2 log message + + Log.d("OpenVPN", argument); + + VpnStatus.LogLevel level; + if (args[1].equals("I")) { + level = VpnStatus.LogLevel.INFO; + } else if (args[1].equals("W")) { + level = VpnStatus.LogLevel.WARNING; + } else if (args[1].equals("D")) { + level = VpnStatus.LogLevel.VERBOSE; + } else if (args[1].equals("F")) { + level = VpnStatus.LogLevel.ERROR; + } else { + level = VpnStatus.LogLevel.INFO; + } + + int ovpnlevel = Integer.parseInt(args[2]) & 0x0F; + String msg = args[3]; + + if (msg.startsWith("MANAGEMENT: CMD")) + ovpnlevel = Math.max(4, ovpnlevel); + + VpnStatus.logMessageOpenVPN(level,ovpnlevel, msg); + } + + private void handleHold() { + if(mReleaseHold) { + releaseHoldCmd(); + } else { + mWaitingForRelease=true; + + VpnStatus.updateStatePause(lastPauseReason); + + + } + } + private void releaseHoldCmd() { + if ((System.currentTimeMillis()- mLastHoldRelease) < 5000) { + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + } + + } + mWaitingForRelease=false; + mLastHoldRelease = System.currentTimeMillis(); + managmentCommand("hold release\n"); + managmentCommand("bytecount " + mBytecountInterval + "\n"); + managmentCommand("state on\n"); + //managmentCommand("log on all\n"); + } + + public void releaseHold() { + mReleaseHold=true; + if(mWaitingForRelease) + releaseHoldCmd(); + + } + + private void processProxyCMD(String argument) { + String[] args = argument.split(",",3); + SocketAddress proxyaddr = ProxyDetection.detectProxy(mProfile); + + + if(args.length >= 2) { + String proto = args[1]; + if(proto.equals("UDP")) { + proxyaddr=null; + } + } + + if(proxyaddr instanceof InetSocketAddress ){ + InetSocketAddress isa = (InetSocketAddress) proxyaddr; + + VpnStatus.logInfo(R.string.using_proxy, isa.getHostName(), isa.getPort()); + + String proxycmd = String.format(Locale.ENGLISH,"proxy HTTP %s %d\n", isa.getHostName(),isa.getPort()); + managmentCommand(proxycmd); + } else { + managmentCommand("proxy NONE\n"); + } + + } + private void processState(String argument) { + String[] args = argument.split(",",3); + String currentstate = args[1]; + + if(args[2].equals(",,")) + VpnStatus.updateStateString(currentstate, ""); + else + VpnStatus.updateStateString(currentstate, args[2]); + } + + + private void processByteCount(String argument) { + // >BYTECOUNT:{BYTES_IN},{BYTES_OUT} + int comma = argument.indexOf(','); + long in = Long.parseLong(argument.substring(0, comma)); + long out = Long.parseLong(argument.substring(comma+1)); + + VpnStatus.updateByteCount(in, out); + + } + + + + private void processNeedCommand(String argument) { + int p1 =argument.indexOf('\''); + int p2 = argument.indexOf('\'',p1+1); + + String needed = argument.substring(p1+1, p2); + String extra = argument.split(":",2)[1]; + + String status = "ok"; + + + if (needed.equals("PROTECTFD")) { + FileDescriptor fdtoprotect = mFDList.pollFirst(); + protectFileDescriptor(fdtoprotect); + } else if (needed.equals("DNSSERVER")) { + mOpenVPNService.addDNS(extra); + }else if (needed.equals("DNSDOMAIN")){ + mOpenVPNService.setDomain(extra); + } else if (needed.equals("ROUTE")) { + String[] routeparts = extra.split(" "); + + /* + buf_printf (&out, "%s %s %s dev %s", network, netmask, gateway, rgi->iface); + else + buf_printf (&out, "%s %s %s", network, netmask, gateway); + */ + + if(routeparts.length==5) { + assert(routeparts[3].equals("dev")); + mOpenVPNService.addRoute(routeparts[0], routeparts[1], routeparts[2], routeparts[4]); + } else if (routeparts.length >= 3) { + mOpenVPNService.addRoute(routeparts[0], routeparts[1], routeparts[2], null); + } else { + VpnStatus.logError("Unrecognized ROUTE cmd:" + Arrays.toString(routeparts) + " | " + argument); + } + + } else if (needed.equals("ROUTE6")) { + String[] routeparts = extra.split(" "); + mOpenVPNService.addRoutev6(routeparts[0],routeparts[1]); + } else if (needed.equals("IFCONFIG")) { + String[] ifconfigparts = extra.split(" "); + int mtu = Integer.parseInt(ifconfigparts[2]); + mOpenVPNService.setLocalIP(ifconfigparts[0], ifconfigparts[1],mtu,ifconfigparts[3]); + } else if (needed.equals("IFCONFIG6")) { + mOpenVPNService.setLocalIPv6(extra); + + } else if (needed.equals("PERSIST_TUN_ACTION")) { + // check if tun cfg stayed the same + status = mOpenVPNService.getTunReopenStatus(); + } else if (needed.equals("OPENTUN")) { + if(sendTunFD(needed,extra)) + return; + else + status="cancel"; + // This not nice or anything but setFileDescriptors accepts only FilDescriptor class :( + + } else { + Log.e(TAG,"Unkown needok command " + argument); + return; + } + + String cmd = String.format("needok '%s' %s\n", needed, status); + managmentCommand(cmd); + } + + private boolean sendTunFD (String needed, String extra) { + Exception exp; + if(!extra.equals("tun")) { + // We only support tun + VpnStatus.logError(String.format("Device type %s requested, but only tun is possible with the Android API, sorry!",extra)); + + return false; + } + ParcelFileDescriptor pfd = mOpenVPNService.openTun(); + if(pfd==null) + return false; + + Method setInt; + int fdint = pfd.getFd(); + try { + setInt = FileDescriptor.class.getDeclaredMethod("setInt$",int.class); + FileDescriptor fdtosend = new FileDescriptor(); + + setInt.invoke(fdtosend,fdint); + + FileDescriptor[] fds = {fdtosend}; + mSocket.setFileDescriptorsForSend(fds); + + // Trigger a send so we can close the fd on our side of the channel + // The API documentation fails to mention that it will not reset the file descriptor to + // be send and will happily send the file descriptor on every write ... + String cmd = String.format("needok '%s' %s\n", needed, "ok"); + managmentCommand(cmd); + + // Set the FileDescriptor to null to stop this mad behavior + mSocket.setFileDescriptorsForSend(null); + + pfd.close(); + + return true; + } catch (NoSuchMethodException e) { + exp =e; + } catch (IllegalArgumentException e) { + exp =e; + } catch (IllegalAccessException e) { + exp =e; + } catch (InvocationTargetException e) { + exp =e; + } catch (IOException e) { + exp =e; + } + VpnStatus.logException("Could not send fd over socket" , exp); + + return false; + } + + private void processPWCommand(String argument) { + //argument has the form Need 'Private Key' password + // or ">PASSWORD:Verification Failed: '%s' ['%s']" + String needed; + + + + try{ + + int p1 = argument.indexOf('\''); + int p2 = argument.indexOf('\'',p1+1); + needed = argument.substring(p1+1, p2); + if (argument.startsWith("Verification Failed")) { + proccessPWFailed(needed, argument.substring(p2+1)); + return; + } + } catch (StringIndexOutOfBoundsException sioob) { + VpnStatus.logError("Could not parse management Password command: " + argument); + return; + } + + String pw=null; + + if(needed.equals("Private Key")) { + pw = mProfile.getPasswordPrivateKey(); + } else if (needed.equals("Auth")) { + String usercmd = String.format("username '%s' %s\n", + needed, VpnProfile.openVpnEscape(mProfile.mUsername)); + managmentCommand(usercmd); + pw = mProfile.getPasswordAuth(); + } + if(pw!=null) { + String cmd = String.format("password '%s' %s\n", needed, VpnProfile.openVpnEscape(pw)); + managmentCommand(cmd); + } else { + VpnStatus.logError(String.format("Openvpn requires Authentication type '%s' but no password/key information available", needed)); + } + + } + + + + + private void proccessPWFailed(String needed, String args) { + VpnStatus.updateStateString("AUTH_FAILED", needed + args, R.string.state_auth_failed, ConnectionStatus.LEVEL_AUTH_FAILED); + } + + + private static boolean stopOpenVPN() { + boolean sendCMD=false; + for (OpenVpnManagementThread mt: active){ + mt.managmentCommand("signal SIGINT\n"); + sendCMD=true; + try { + if(mt.mSocket !=null) + mt.mSocket.close(); + } catch (IOException e) { + // Ignore close error on already closed socket + } + } + return sendCMD; + } + + @Override + public void networkChange() { + if(!mWaitingForRelease) + managmentCommand("network-change\n"); + } + + public void signalusr1() { + mReleaseHold=false; + + if(!mWaitingForRelease) + managmentCommand("signal SIGUSR1\n"); + else + // If signalusr1 is called update the state string + // if there is another for stopping + VpnStatus.updateStatePause(lastPauseReason); + } + + public void reconnect() { + signalusr1(); + releaseHold(); + } + + private void processSignCommand(String b64data) { + + String signed_string = mProfile.getSignedData(b64data); + if(signed_string==null) { + managmentCommand("rsa-sig\n"); + managmentCommand("\nEND\n"); + stopOpenVPN(); + return; + } + managmentCommand("rsa-sig\n"); + managmentCommand(signed_string); + managmentCommand("\nEND\n"); + } + + @Override + public void pause (pauseReason reason) { + lastPauseReason = reason; + signalusr1(); + } + + @Override + public void resume() { + releaseHold(); + /* Reset the reason why we are disconnected */ + lastPauseReason = pauseReason.noNetwork; + } + + @Override + public boolean stopVPN() { + return stopOpenVPN(); + } +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVpnService.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVpnService.java new file mode 100644 index 00000000..8281aed8 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVpnService.java @@ -0,0 +1,757 @@ +package de.blinkt.openvpn.core; + +import android.Manifest.permission; +import android.annotation.TargetApi; +import android.app.Notification; +import android.app.NotificationManager; +import android.app.PendingIntent; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.SharedPreferences; +import android.net.ConnectivityManager; +import android.net.VpnService; +import android.os.Binder; +import android.os.Build; +import android.os.Handler.Callback; +import android.os.IBinder; +import android.os.Message; +import android.os.ParcelFileDescriptor; +import android.preference.PreferenceManager; +import android.text.TextUtils; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.net.Inet6Address; +import java.net.InetAddress; +import java.net.UnknownHostException; +import java.util.Collection; +import java.util.HashMap; +import java.util.Locale; +import java.util.Vector; + +import se.leap.bitmaskclient.BuildConfig; +import se.leap.bitmaskclient.R; +import de.blinkt.openvpn.VpnProfile; +import de.blinkt.openvpn.activities.DisconnectVPN; +import de.blinkt.openvpn.activities.LogWindow; +import de.blinkt.openvpn.core.VpnStatus.ByteCountListener; +import de.blinkt.openvpn.core.VpnStatus.ConnectionStatus; +import de.blinkt.openvpn.core.VpnStatus.StateListener; + +import static de.blinkt.openvpn.core.NetworkSpace.ipAddress; +import static de.blinkt.openvpn.core.VpnStatus.ConnectionStatus.LEVEL_CONNECTED; +import static de.blinkt.openvpn.core.VpnStatus.ConnectionStatus.LEVEL_CONNECTING_NO_SERVER_REPLY_YET; +import static de.blinkt.openvpn.core.VpnStatus.ConnectionStatus.LEVEL_WAITING_FOR_USER_INPUT; + +public class OpenVpnService extends VpnService implements StateListener, Callback, ByteCountListener { + public static final String START_SERVICE = "de.blinkt.openvpn.START_SERVICE"; + public static final String START_SERVICE_STICKY = "de.blinkt.openvpn.START_SERVICE_STICKY"; + public static final String ALWAYS_SHOW_NOTIFICATION = "de.blinkt.openvpn.NOTIFICATION_ALWAYS_VISIBLE"; + public static final String DISCONNECT_VPN = "de.blinkt.openvpn.DISCONNECT_VPN"; + private static final String PAUSE_VPN = "de.blinkt.openvpn.PAUSE_VPN"; + private static final String RESUME_VPN = "se.leap.bitmaskclient.RESUME_VPN"; + private static final int OPENVPN_STATUS = 1; + private static boolean mNotificationAlwaysVisible = false; + private final Vector mDnslist = new Vector(); + private final NetworkSpace mRoutes = new NetworkSpace(); + private final NetworkSpace mRoutesv6 = new NetworkSpace(); + private final IBinder mBinder = new LocalBinder(); + private Thread mProcessThread = null; + private VpnProfile mProfile; + private String mDomain = null; + private CIDRIP mLocalIP = null; + private int mMtu; + private String mLocalIPv6 = null; + private DeviceStateReceiver mDeviceStateReceiver; + private boolean mDisplayBytecount = false; + private boolean mStarting = false; + private long mConnecttime; + private boolean mOvpn3 = false; + private OpenVPNManagement mManagement; + private String mLastTunCfg; + private String mRemoteGW; + + // From: http://stackoverflow.com/questions/3758606/how-to-convert-byte-size-into-human-readable-format-in-java + public static String humanReadableByteCount(long bytes, boolean mbit) { + if (mbit) + bytes = bytes * 8; + int unit = mbit ? 1000 : 1024; + if (bytes < unit) + return bytes + (mbit ? " bit" : " B"); + + int exp = (int) (Math.log(bytes) / Math.log(unit)); + String pre = (mbit ? "kMGTPE" : "KMGTPE").charAt(exp - 1) + (mbit ? "" : ""); + if (mbit) + return String.format(Locale.getDefault(), "%.1f %sbit", bytes / Math.pow(unit, exp), pre); + else + return String.format(Locale.getDefault(), "%.1f %sB", bytes / Math.pow(unit, exp), pre); + } + + @Override + public IBinder onBind(Intent intent) { + String action = intent.getAction(); + if (action != null && action.equals(START_SERVICE)) + return mBinder; + else + return super.onBind(intent); + } + + @Override + public void onRevoke() { + mManagement.stopVPN(); + endVpnService(); + } + + // Similar to revoke but do not try to stop process + public void processDied() { + endVpnService(); + } + + private void endVpnService() { + mProcessThread = null; + VpnStatus.removeByteCountListener(this); + unregisterDeviceStateReceiver(); + ProfileManager.setConntectedVpnProfileDisconnected(this); + if (!mStarting) { + stopForeground(!mNotificationAlwaysVisible); + + if (!mNotificationAlwaysVisible) { + stopSelf(); + VpnStatus.removeStateListener(this); + } + } + } + + private void showNotification(String msg, String tickerText, boolean lowpriority, long when, ConnectionStatus status) { + String ns = Context.NOTIFICATION_SERVICE; + NotificationManager mNotificationManager = (NotificationManager) getSystemService(ns); + + + int icon = getIconByConnectionStatus(status); + + android.app.Notification.Builder nbuilder = new Notification.Builder(this); + + if (mProfile != null) + nbuilder.setContentTitle(getString(R.string.notifcation_title, mProfile.mName)); + else + nbuilder.setContentTitle(getString(R.string.notifcation_title_notconnect)); + + nbuilder.setContentText(msg); + nbuilder.setOnlyAlertOnce(true); + nbuilder.setOngoing(true); + nbuilder.setContentIntent(getLogPendingIntent()); + nbuilder.setSmallIcon(icon); + + + if (when != 0) + nbuilder.setWhen(when); + + + // Try to set the priority available since API 16 (Jellybean) + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) + jbNotificationExtras(lowpriority, nbuilder); + + if (tickerText != null && !tickerText.equals("")) + nbuilder.setTicker(tickerText); + + @SuppressWarnings("deprecation") + Notification notification = nbuilder.getNotification(); + + + mNotificationManager.notify(OPENVPN_STATUS, notification); + startForeground(OPENVPN_STATUS, notification); + } + + private int getIconByConnectionStatus(ConnectionStatus level) { + switch (level) { + case LEVEL_CONNECTED: + return R.drawable.ic_stat_vpn; + case LEVEL_AUTH_FAILED: + case LEVEL_NONETWORK: + case LEVEL_NOTCONNECTED: + return R.drawable.ic_stat_vpn_offline; + case LEVEL_CONNECTING_NO_SERVER_REPLY_YET: + case LEVEL_WAITING_FOR_USER_INPUT: + return R.drawable.ic_stat_vpn_outline; + case LEVEL_CONNECTING_SERVER_REPLIED: + return R.drawable.ic_stat_vpn_empty_halo; + case LEVEL_VPNPAUSED: + return android.R.drawable.ic_media_pause; + case UNKNOWN_LEVEL: + default: + return R.drawable.ic_stat_vpn; + + } + } + + @TargetApi(Build.VERSION_CODES.JELLY_BEAN) + private void jbNotificationExtras(boolean lowpriority, + android.app.Notification.Builder nbuilder) { + try { + if (lowpriority) { + Method setpriority = nbuilder.getClass().getMethod("setPriority", int.class); + // PRIORITY_MIN == -2 + setpriority.invoke(nbuilder, -2); + + Method setUsesChronometer = nbuilder.getClass().getMethod("setUsesChronometer", boolean.class); + setUsesChronometer.invoke(nbuilder, true); + + } + + Intent disconnectVPN = new Intent(this, DisconnectVPN.class); + disconnectVPN.setAction(DISCONNECT_VPN); + PendingIntent disconnectPendingIntent = PendingIntent.getActivity(this, 0, disconnectVPN, 0); + + nbuilder.addAction(android.R.drawable.ic_menu_close_clear_cancel, + getString(R.string.cancel_connection), disconnectPendingIntent); + + Intent pauseVPN = new Intent(this, OpenVpnService.class); + if (mDeviceStateReceiver == null || !mDeviceStateReceiver.isUserPaused()) { + pauseVPN.setAction(PAUSE_VPN); + PendingIntent pauseVPNPending = PendingIntent.getService(this, 0, pauseVPN, 0); + nbuilder.addAction(android.R.drawable.ic_media_pause, + getString(R.string.pauseVPN), pauseVPNPending); + + } else { + pauseVPN.setAction(RESUME_VPN); + PendingIntent resumeVPNPending = PendingIntent.getService(this, 0, pauseVPN, 0); + nbuilder.addAction(android.R.drawable.ic_media_play, + getString(R.string.resumevpn), resumeVPNPending); + } + + + //ignore exception + } catch (NoSuchMethodException nsm) { + VpnStatus.logException(nsm); + } catch (IllegalArgumentException e) { + VpnStatus.logException(e); + } catch (IllegalAccessException e) { + VpnStatus.logException(e); + } catch (InvocationTargetException e) { + VpnStatus.logException(e); + } + + } + + PendingIntent getLogPendingIntent() { + // Let the configure Button show the Log + Intent intent = new Intent(getBaseContext(), LogWindow.class); + intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT); + PendingIntent startLW = PendingIntent.getActivity(this, 0, intent, 0); + intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT); + return startLW; + + } + + synchronized void registerDeviceStateReceiver(OpenVPNManagement magnagement) { + // Registers BroadcastReceiver to track network connection changes. + IntentFilter filter = new IntentFilter(); + filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION); + filter.addAction(Intent.ACTION_SCREEN_OFF); + filter.addAction(Intent.ACTION_SCREEN_ON); + mDeviceStateReceiver = new DeviceStateReceiver(magnagement); + registerReceiver(mDeviceStateReceiver, filter); + VpnStatus.addByteCountListener(mDeviceStateReceiver); + } + + synchronized void unregisterDeviceStateReceiver() { + if (mDeviceStateReceiver != null) + try { + VpnStatus.removeByteCountListener(mDeviceStateReceiver); + this.unregisterReceiver(mDeviceStateReceiver); + } catch (IllegalArgumentException iae) { + // I don't know why this happens: + // java.lang.IllegalArgumentException: Receiver not registered: de.blinkt.openvpn.NetworkSateReceiver@41a61a10 + // Ignore for now ... + iae.printStackTrace(); + } + mDeviceStateReceiver = null; + } + + public void userPause(boolean shouldBePaused) { + if (mDeviceStateReceiver != null) + mDeviceStateReceiver.userPause(shouldBePaused); + } + + @Override + public int onStartCommand(Intent intent, int flags, int startId) { + + if (intent != null && intent.getBooleanExtra(ALWAYS_SHOW_NOTIFICATION, false)) + mNotificationAlwaysVisible = true; + + VpnStatus.addStateListener(this); + VpnStatus.addByteCountListener(this); + + if (intent != null && PAUSE_VPN.equals(intent.getAction())) { + if (mDeviceStateReceiver != null) + mDeviceStateReceiver.userPause(true); + return START_NOT_STICKY; + } + + if (intent != null && RESUME_VPN.equals(intent.getAction())) { + if (mDeviceStateReceiver != null) + mDeviceStateReceiver.userPause(false); + return START_NOT_STICKY; + } + + + if (intent != null && START_SERVICE.equals(intent.getAction())) + return START_NOT_STICKY; + if (intent != null && START_SERVICE_STICKY.equals(intent.getAction())) { + return START_REDELIVER_INTENT; + } + + if (intent == null) + return START_NOT_STICKY; + + // Extract information from the intent. + String prefix = getPackageName(); + String[] argv = intent.getStringArrayExtra(prefix + ".ARGV"); + String nativelibdir = intent.getStringExtra(prefix + ".nativelib"); + String profileUUID = intent.getStringExtra(prefix + ".profileUUID"); + + mProfile = ProfileManager.get(this, profileUUID); + + String startTitle = getString(R.string.start_vpn_title, mProfile.mName); + String startTicker = getString(R.string.start_vpn_ticker, mProfile.mName); + showNotification(startTitle, startTicker, + false, 0, LEVEL_CONNECTING_NO_SERVER_REPLY_YET); + + // Set a flag that we are starting a new VPN + mStarting = true; + // Stop the previous session by interrupting the thread. + if (mManagement != null && mManagement.stopVPN()) + // an old was asked to exit, wait 1s + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + //ignore + } + + + if (mProcessThread != null) { + mProcessThread.interrupt(); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + //ignore + } + } + // An old running VPN should now be exited + mStarting = false; + + // Start a new session by creating a new thread. + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this); + + mOvpn3 = prefs.getBoolean("ovpn3", false); + if (!"ovpn3".equals(BuildConfig.FLAVOR)) + mOvpn3 = false; + + + // Open the Management Interface + if (!mOvpn3) { + + // start a Thread that handles incoming messages of the managment socket + OpenVpnManagementThread ovpnManagementThread = new OpenVpnManagementThread(mProfile, this); + if (ovpnManagementThread.openManagementInterface(this)) { + + Thread mSocketManagerThread = new Thread(ovpnManagementThread, "OpenVPNManagementThread"); + mSocketManagerThread.start(); + mManagement = ovpnManagementThread; + VpnStatus.logInfo("started Socket Thread"); + } else { + return START_NOT_STICKY; + } + } + + + Runnable processThread; + if (mOvpn3) { + + OpenVPNManagement mOpenVPN3 = instantiateOpenVPN3Core(); + processThread = (Runnable) mOpenVPN3; + mManagement = mOpenVPN3; + + + } else { + HashMap env = new HashMap(); + processThread = new OpenVPNThread(this, argv, env, nativelibdir); + } + + mProcessThread = new Thread(processThread, "OpenVPNProcessThread"); + mProcessThread.start(); + + if (mDeviceStateReceiver != null) + unregisterDeviceStateReceiver(); + + registerDeviceStateReceiver(mManagement); + + + ProfileManager.setConnectedVpnProfile(this, mProfile); + + return START_NOT_STICKY; + } + + private OpenVPNManagement instantiateOpenVPN3Core() { + try { + Class cl = Class.forName("de.blinkt.openvpn.core.OpenVPNThreadv3"); + return (OpenVPNManagement) cl.getConstructor(OpenVpnService.class,VpnProfile.class).newInstance(this,mProfile); + } catch (IllegalArgumentException e) { + e.printStackTrace(); + } catch (InstantiationException e) { + e.printStackTrace(); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } catch (InvocationTargetException e) { + e.printStackTrace(); + } catch (NoSuchMethodException e) { + e.printStackTrace(); + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + return null; + } + + @Override + public void onDestroy() { + if (mProcessThread != null) { + mManagement.stopVPN(); + + mProcessThread.interrupt(); + } + if (mDeviceStateReceiver != null) { + this.unregisterReceiver(mDeviceStateReceiver); + } + // Just in case unregister for state + VpnStatus.removeStateListener(this); + + } + + private String getTunConfigString() { + // The format of the string is not important, only that + // two identical configurations produce the same result + String cfg = "TUNCFG UNQIUE STRING ips:"; + + if (mLocalIP != null) + cfg += mLocalIP.toString(); + if (mLocalIPv6 != null) + cfg += mLocalIPv6; + + cfg += "routes: " + TextUtils.join("|", mRoutes.getNetworks(true)) + TextUtils.join("|", mRoutesv6.getNetworks(true)); + cfg += "excl. routes:" + TextUtils.join("|", mRoutes.getNetworks(false)) + TextUtils.join("|", mRoutesv6.getNetworks(false)); + cfg += "dns: " + TextUtils.join("|", mDnslist); + cfg += "domain: " + mDomain; + cfg += "mtu: " + mMtu; + return cfg; + } + + public ParcelFileDescriptor openTun() { + + //Debug.startMethodTracing(getExternalFilesDir(null).toString() + "/opentun.trace", 40* 1024 * 1024); + + Builder builder = new Builder(); + + VpnStatus.logInfo(R.string.last_openvpn_tun_config); + + + if (mLocalIP == null && mLocalIPv6 == null) { + VpnStatus.logError(getString(R.string.opentun_no_ipaddr)); + return null; + } + + if (mLocalIP != null) { + try { + builder.addAddress(mLocalIP.mIp, mLocalIP.len); + } catch (IllegalArgumentException iae) { + VpnStatus.logError(R.string.dns_add_error, mLocalIP, iae.getLocalizedMessage()); + return null; + } + } + + if (mLocalIPv6 != null) { + String[] ipv6parts = mLocalIPv6.split("/"); + try { + builder.addAddress(ipv6parts[0], Integer.parseInt(ipv6parts[1])); + } catch (IllegalArgumentException iae) { + VpnStatus.logError(R.string.ip_add_error, mLocalIPv6, iae.getLocalizedMessage()); + return null; + } + + } + + + for (String dns : mDnslist) { + try { + builder.addDnsServer(dns); + } catch (IllegalArgumentException iae) { + VpnStatus.logError(R.string.dns_add_error, dns, iae.getLocalizedMessage()); + } + } + + + builder.setMtu(mMtu); + + Collection positiveIPv4Routes = mRoutes.getPositiveIPList(); + Collection positiveIPv6Routes = mRoutesv6.getPositiveIPList(); + + for (NetworkSpace.ipAddress route : positiveIPv4Routes) { + try { + builder.addRoute(route.getIPv4Address(), route.networkMask); + } catch (IllegalArgumentException ia) { + VpnStatus.logError(getString(R.string.route_rejected) + route + " " + ia.getLocalizedMessage()); + } + } + + for (NetworkSpace.ipAddress route6 : positiveIPv6Routes) { + try { + builder.addRoute(route6.getIPv6Address(), route6.networkMask); + } catch (IllegalArgumentException ia) { + VpnStatus.logError(getString(R.string.route_rejected) + route6 + " " + ia.getLocalizedMessage()); + } + } + + if (mDomain != null) + builder.addSearchDomain(mDomain); + + VpnStatus.logInfo(R.string.local_ip_info, mLocalIP.mIp, mLocalIP.len, mLocalIPv6, mMtu); + VpnStatus.logInfo(R.string.dns_server_info, TextUtils.join(", ", mDnslist), mDomain); + VpnStatus.logInfo(R.string.routes_info_incl, TextUtils.join(", ", mRoutes.getNetworks(true)), TextUtils.join(", ", mRoutesv6.getNetworks(true))); + VpnStatus.logInfo(R.string.routes_info_excl, TextUtils.join(", ", mRoutes.getNetworks(false)),TextUtils.join(", ", mRoutesv6.getNetworks(false))); + VpnStatus.logDebug(R.string.routes_debug, TextUtils.join(", ", positiveIPv4Routes), TextUtils.join(", ", positiveIPv6Routes)); + + String session = mProfile.mName; + if (mLocalIP != null && mLocalIPv6 != null) + session = getString(R.string.session_ipv6string, session, mLocalIP, mLocalIPv6); + else if (mLocalIP != null) + session = getString(R.string.session_ipv4string, session, mLocalIP); + + builder.setSession(session); + + // No DNS Server, log a warning + if (mDnslist.size() == 0) + VpnStatus.logInfo(R.string.warn_no_dns); + + mLastTunCfg = getTunConfigString(); + + // Reset information + mDnslist.clear(); + mRoutes.clear(); + mRoutesv6.clear(); + mLocalIP = null; + mLocalIPv6 = null; + mDomain = null; + + builder.setConfigureIntent(getLogPendingIntent()); + + try { + //Debug.stopMethodTracing(); + return builder.establish(); + } catch (Exception e) { + VpnStatus.logError(R.string.tun_open_error); + VpnStatus.logError(getString(R.string.error) + e.getLocalizedMessage()); + if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.JELLY_BEAN_MR1) { + VpnStatus.logError(R.string.tun_error_helpful); + } + return null; + } + + } + + public void addDNS(String dns) { + mDnslist.add(dns); + } + + public void setDomain(String domain) { + if (mDomain == null) { + mDomain = domain; + } + } + + /** Route that is always included, used by the v3 core */ + public void addRoute (CIDRIP route) { + mRoutes.addIP(route, true); + } + + public void addRoute (String dest, String mask, String gateway, String device) { + CIDRIP route = new CIDRIP(dest, mask); + boolean include = isAndroidTunDevice(device); + + NetworkSpace.ipAddress gatewayIP = new NetworkSpace.ipAddress(new CIDRIP(gateway, 32),false); + + if (mLocalIP==null) { + VpnStatus.logError("Local IP address unset but adding route?! This is broken! Please contact author with log"); + return; + } + NetworkSpace.ipAddress localNet = new NetworkSpace.ipAddress(mLocalIP,true); + if (localNet.containsNet(gatewayIP)) + include=true; + + if (gateway!= null && + (gateway.equals("255.255.255.255") || gateway.equals(mRemoteGW))) + include=true; + + + if (route.len == 32 && !mask.equals("255.255.255.255")) { + VpnStatus.logWarning(R.string.route_not_cidr, dest, mask); + } + + if (route.normalise()) + VpnStatus.logWarning(R.string.route_not_netip, dest, route.len, route.mIp); + + mRoutes.addIP(route, include); + } + + public void addRoutev6(String network, String device) { + String[] v6parts = network.split("/"); + boolean included = isAndroidTunDevice(device); + + // Tun is opened after ROUTE6, no device name may be present + + try { + Inet6Address ip = (Inet6Address) InetAddress.getAllByName(v6parts[0])[0]; + int mask = Integer.parseInt(v6parts[1]); + mRoutesv6.addIPv6(ip, mask, included); + + } catch (UnknownHostException e) { + VpnStatus.logException(e); + } + + + } + + private boolean isAndroidTunDevice(String device) { + return device!=null && + (device.startsWith("tun") || "(null)".equals(device) || "vpnservice-tun".equals(device)); + } + + public void setMtu(int mtu) { + mMtu = mtu; + } + + public void setLocalIP(CIDRIP cdrip) { + mLocalIP = cdrip; + } + + public void setLocalIP(String local, String netmask, int mtu, String mode) { + mLocalIP = new CIDRIP(local, netmask); + mMtu = mtu; + mRemoteGW=null; + + + if (mLocalIP.len == 32 && !netmask.equals("255.255.255.255")) { + // get the netmask as IP + long netMaskAsInt = CIDRIP.getInt(netmask); + + int masklen; + if ("net30".equals(mode)) + masklen = 30; + else + masklen = 31; + + int mask = ~( 1 << (32 - (mLocalIP.len +1))); + // Netmask is Ip address +/-1, assume net30/p2p with small net + if ((netMaskAsInt & mask) == (mLocalIP.getInt() & mask )) { + mLocalIP.len = masklen; + } else { + if (!"p2p".equals(mode)) + VpnStatus.logWarning(R.string.ip_not_cidr, local, netmask, mode); + mRemoteGW=netmask; + } + } + } + + public void setLocalIPv6(String ipv6addr) { + mLocalIPv6 = ipv6addr; + } + + @Override + public void updateState(String state, String logmessage, int resid, ConnectionStatus level) { + // If the process is not running, ignore any state, + // Notification should be invisible in this state + doSendBroadcast(state, level); + if (mProcessThread == null && !mNotificationAlwaysVisible) + return; + + boolean lowpriority = false; + // Display byte count only after being connected + + { + if (level == LEVEL_WAITING_FOR_USER_INPUT) { + // The user is presented a dialog of some kind, no need to inform the user + // with a notifcation + return; + } else if (level == LEVEL_CONNECTED) { + mDisplayBytecount = true; + mConnecttime = System.currentTimeMillis(); + lowpriority = true; + } else { + mDisplayBytecount = false; + } + + // Other notifications are shown, + // This also mean we are no longer connected, ignore bytecount messages until next + // CONNECTED + // Does not work :( + String msg = getString(resid); + String ticker = msg; + showNotification(msg + " " + logmessage, ticker, lowpriority , 0, level); + + } + } + + private void doSendBroadcast(String state, ConnectionStatus level) { + Intent vpnstatus = new Intent(); + vpnstatus.setAction("de.blinkt.openvpn.VPN_STATUS"); + vpnstatus.putExtra("status", level.toString()); + vpnstatus.putExtra("detailstatus", state); + sendBroadcast(vpnstatus, permission.ACCESS_NETWORK_STATE); + } + + @Override + public void updateByteCount(long in, long out, long diffIn, long diffOut) { + if (mDisplayBytecount) { + String netstat = String.format(getString(R.string.statusline_bytecount), + humanReadableByteCount(in, false), + humanReadableByteCount(diffIn / OpenVPNManagement.mBytecountInterval, true), + humanReadableByteCount(out, false), + humanReadableByteCount(diffOut / OpenVPNManagement.mBytecountInterval, true)); + + boolean lowpriority = !mNotificationAlwaysVisible; + showNotification(netstat, null, lowpriority, mConnecttime, LEVEL_CONNECTED); + } + + } + + @Override + public boolean handleMessage(Message msg) { + Runnable r = msg.getCallback(); + if (r != null) { + r.run(); + return true; + } else { + return false; + } + } + + public OpenVPNManagement getManagement() { + return mManagement; + } + + public String getTunReopenStatus() { + String currentConfiguration = getTunConfigString(); + if (currentConfiguration.equals(mLastTunCfg)) + return "NOACTION"; + else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) + return "OPEN_AFTER_CLOSE"; + else + return "OPEN_BEFORE_CLOSE"; + } + + public class LocalBinder extends Binder { + public OpenVpnService getService() { + // Return this instance of LocalService so clients can call public methods + return OpenVpnService.this; + } + } +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/PRNGFixes.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/PRNGFixes.java new file mode 100644 index 00000000..dd420371 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/PRNGFixes.java @@ -0,0 +1,334 @@ +package de.blinkt.openvpn.core;/* + * This software is provided 'as-is', without any express or implied + * warranty. In no event will Google be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, as long as the origin is not misrepresented. + */ + +import android.os.Build; +import android.os.Process; +import android.util.Log; + +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.OutputStream; +import java.io.UnsupportedEncodingException; +import java.security.NoSuchAlgorithmException; +import java.security.Provider; +import java.security.SecureRandom; +import java.security.SecureRandomSpi; +import java.security.Security; + +/** + * Fixes for the output of the default PRNG having low entropy. + * + * The fixes need to be applied via {@link #apply()} before any use of Java + * Cryptography Architecture primitives. A good place to invoke them is in the + * application's {@code onCreate}. + */ +public final class PRNGFixes { + + private static final int VERSION_CODE_JELLY_BEAN = 16; + private static final int VERSION_CODE_JELLY_BEAN_MR2 = 18; + private static final byte[] BUILD_FINGERPRINT_AND_DEVICE_SERIAL = + getBuildFingerprintAndDeviceSerial(); + + /** Hidden constructor to prevent instantiation. */ + private PRNGFixes() {} + + /** + * Applies all fixes. + * + * @throws SecurityException if a fix is needed but could not be applied. + */ + public static void apply() { + applyOpenSSLFix(); + installLinuxPRNGSecureRandom(); + } + + /** + * Applies the fix for OpenSSL PRNG having low entropy. Does nothing if the + * fix is not needed. + * + * @throws SecurityException if the fix is needed but could not be applied. + */ + private static void applyOpenSSLFix() throws SecurityException { + if ((Build.VERSION.SDK_INT < VERSION_CODE_JELLY_BEAN) + || (Build.VERSION.SDK_INT > VERSION_CODE_JELLY_BEAN_MR2)) { + // No need to apply the fix + return; + } + + try { + // Mix in the device- and invocation-specific seed. + Class.forName("org.apache.harmony.xnet.provider.jsse.NativeCrypto") + .getMethod("RAND_seed", byte[].class) + .invoke(null, generateSeed()); + + // Mix output of Linux PRNG into OpenSSL's PRNG + int bytesRead = (Integer) Class.forName( + "org.apache.harmony.xnet.provider.jsse.NativeCrypto") + .getMethod("RAND_load_file", String.class, long.class) + .invoke(null, "/dev/urandom", 1024); + if (bytesRead != 1024) { + throw new IOException( + "Unexpected number of bytes read from Linux PRNG: " + + bytesRead); + } + } catch (Exception e) { + throw new SecurityException("Failed to seed OpenSSL PRNG", e); + } + } + + /** + * Installs a Linux PRNG-backed {@code SecureRandom} implementation as the + * default. Does nothing if the implementation is already the default or if + * there is not need to install the implementation. + * + * @throws SecurityException if the fix is needed but could not be applied. + */ + private static void installLinuxPRNGSecureRandom() + throws SecurityException { + if (Build.VERSION.SDK_INT > VERSION_CODE_JELLY_BEAN_MR2) { + // No need to apply the fix + return; + } + + // Install a Linux PRNG-based SecureRandom implementation as the + // default, if not yet installed. + Provider[] secureRandomProviders = + Security.getProviders("SecureRandom.SHA1PRNG"); + if ((secureRandomProviders == null) + || (secureRandomProviders.length < 1) + || (!LinuxPRNGSecureRandomProvider.class.equals( + secureRandomProviders[0].getClass()))) { + Security.insertProviderAt(new LinuxPRNGSecureRandomProvider(), 1); + } + + // Assert that new SecureRandom() and + // SecureRandom.getInstance("SHA1PRNG") return a SecureRandom backed + // by the Linux PRNG-based SecureRandom implementation. + SecureRandom rng1 = new SecureRandom(); + if (!LinuxPRNGSecureRandomProvider.class.equals( + rng1.getProvider().getClass())) { + throw new SecurityException( + "new SecureRandom() backed by wrong Provider: " + + rng1.getProvider().getClass()); + } + + SecureRandom rng2; + try { + rng2 = SecureRandom.getInstance("SHA1PRNG"); + } catch (NoSuchAlgorithmException e) { + throw new SecurityException("SHA1PRNG not available", e); + } + if (!LinuxPRNGSecureRandomProvider.class.equals( + rng2.getProvider().getClass())) { + throw new SecurityException( + "SecureRandom.getInstance(\"SHA1PRNG\") backed by wrong" + + " Provider: " + rng2.getProvider().getClass()); + } + } + + /** + * {@code Provider} of {@code SecureRandom} engines which pass through + * all requests to the Linux PRNG. + */ + private static class LinuxPRNGSecureRandomProvider extends Provider { + + public LinuxPRNGSecureRandomProvider() { + super("LinuxPRNG", + 1.0, + "A Linux-specific random number provider that uses" + + " /dev/urandom"); + // Although /dev/urandom is not a SHA-1 PRNG, some apps + // explicitly request a SHA1PRNG SecureRandom and we thus need to + // prevent them from getting the default implementation whose output + // may have low entropy. + put("SecureRandom.SHA1PRNG", LinuxPRNGSecureRandom.class.getName()); + put("SecureRandom.SHA1PRNG ImplementedIn", "Software"); + } + } + + /** + * {@link SecureRandomSpi} which passes all requests to the Linux PRNG + * ({@code /dev/urandom}). + */ + public static class LinuxPRNGSecureRandom extends SecureRandomSpi { + + /* + * IMPLEMENTATION NOTE: Requests to generate bytes and to mix in a seed + * are passed through to the Linux PRNG (/dev/urandom). Instances of + * this class seed themselves by mixing in the current time, PID, UID, + * build fingerprint, and hardware serial number (where available) into + * Linux PRNG. + * + * Concurrency: Read requests to the underlying Linux PRNG are + * serialized (on sLock) to ensure that multiple threads do not get + * duplicated PRNG output. + */ + + private static final File URANDOM_FILE = new File("/dev/urandom"); + + private static final Object sLock = new Object(); + + /** + * Input stream for reading from Linux PRNG or {@code null} if not yet + * opened. + * + * @GuardedBy("sLock") + */ + private static DataInputStream sUrandomIn; + + /** + * Output stream for writing to Linux PRNG or {@code null} if not yet + * opened. + * + * @GuardedBy("sLock") + */ + private static OutputStream sUrandomOut; + + /** + * Whether this engine instance has been seeded. This is needed because + * each instance needs to seed itself if the client does not explicitly + * seed it. + */ + private boolean mSeeded; + + @Override + protected void engineSetSeed(byte[] bytes) { + try { + OutputStream out; + synchronized (sLock) { + out = getUrandomOutputStream(); + } + out.write(bytes); + out.flush(); + } catch (IOException e) { + // On a small fraction of devices /dev/urandom is not writable. + // Log and ignore. + Log.w(PRNGFixes.class.getSimpleName(), + "Failed to mix seed into " + URANDOM_FILE); + } finally { + mSeeded = true; + } + } + + @Override + protected void engineNextBytes(byte[] bytes) { + if (!mSeeded) { + // Mix in the device- and invocation-specific seed. + engineSetSeed(generateSeed()); + } + + try { + DataInputStream in; + synchronized (sLock) { + in = getUrandomInputStream(); + } + synchronized (in) { + in.readFully(bytes); + } + } catch (IOException e) { + throw new SecurityException( + "Failed to read from " + URANDOM_FILE, e); + } + } + + @Override + protected byte[] engineGenerateSeed(int size) { + byte[] seed = new byte[size]; + engineNextBytes(seed); + return seed; + } + + private DataInputStream getUrandomInputStream() { + synchronized (sLock) { + if (sUrandomIn == null) { + // NOTE: Consider inserting a BufferedInputStream between + // DataInputStream and FileInputStream if you need higher + // PRNG output performance and can live with future PRNG + // output being pulled into this process prematurely. + try { + sUrandomIn = new DataInputStream( + new FileInputStream(URANDOM_FILE)); + } catch (IOException e) { + throw new SecurityException("Failed to open " + + URANDOM_FILE + " for reading", e); + } + } + return sUrandomIn; + } + } + + private OutputStream getUrandomOutputStream() throws IOException { + synchronized (sLock) { + if (sUrandomOut == null) { + sUrandomOut = new FileOutputStream(URANDOM_FILE); + } + return sUrandomOut; + } + } + } + + /** + * Generates a device- and invocation-specific seed to be mixed into the + * Linux PRNG. + */ + private static byte[] generateSeed() { + try { + ByteArrayOutputStream seedBuffer = new ByteArrayOutputStream(); + DataOutputStream seedBufferOut = + new DataOutputStream(seedBuffer); + seedBufferOut.writeLong(System.currentTimeMillis()); + seedBufferOut.writeLong(System.nanoTime()); + seedBufferOut.writeInt(Process.myPid()); + seedBufferOut.writeInt(Process.myUid()); + seedBufferOut.write(BUILD_FINGERPRINT_AND_DEVICE_SERIAL); + seedBufferOut.close(); + return seedBuffer.toByteArray(); + } catch (IOException e) { + throw new SecurityException("Failed to generate seed", e); + } + } + + /** + * Gets the hardware serial number of this device. + * + * @return serial number or {@code null} if not available. + */ + private static String getDeviceSerialNumber() { + // We're using the Reflection API because Build.SERIAL is only available + // since API Level 9 (Gingerbread, Android 2.3). + try { + return (String) Build.class.getField("SERIAL").get(null); + } catch (Exception ignored) { + return null; + } + } + + private static byte[] getBuildFingerprintAndDeviceSerial() { + StringBuilder result = new StringBuilder(); + String fingerprint = Build.FINGERPRINT; + if (fingerprint != null) { + result.append(fingerprint); + } + String serial = getDeviceSerialNumber(); + if (serial != null) { + result.append(serial); + } + try { + return result.toString().getBytes("UTF-8"); + } catch (UnsupportedEncodingException e) { + throw new RuntimeException("UTF-8 encoding not supported"); + } + } +} \ No newline at end of file diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ProfileManager.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ProfileManager.java new file mode 100644 index 00000000..4cfbcc8e --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ProfileManager.java @@ -0,0 +1,222 @@ +package de.blinkt.openvpn.core; + +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.StreamCorruptedException; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Set; + +import de.blinkt.openvpn.VpnProfile; + +import android.app.Activity; +import android.content.Context; +import android.content.SharedPreferences; +import android.content.SharedPreferences.Editor; +import android.preference.PreferenceManager; + +public class ProfileManager { + private static final String PREFS_NAME = "VPNList"; + + + + private static final String ONBOOTPROFILE = "onBootProfile"; + + + + private static ProfileManager instance; + + + + private static VpnProfile mLastConnectedVpn=null; + private HashMap profiles=new HashMap(); + private static VpnProfile tmpprofile=null; + + + private static VpnProfile get(String key) { + if (tmpprofile!=null && tmpprofile.getUUIDString().equals(key)) + return tmpprofile; + + if(instance==null) + return null; + return instance.profiles.get(key); + + } + + + + private ProfileManager() { } + + private static void checkInstance(Context context) { + if(instance == null) { + instance = new ProfileManager(); + instance.loadVPNList(context); + } + } + + synchronized public static ProfileManager getInstance(Context context) { + checkInstance(context); + return instance; + } + + public static void setConntectedVpnProfileDisconnected(Context c) { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(c); + Editor prefsedit = prefs.edit(); + prefsedit.putString(ONBOOTPROFILE, null); + prefsedit.apply(); + + } + + public static void setConnectedVpnProfile(Context c, VpnProfile connectedrofile) { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(c); + Editor prefsedit = prefs.edit(); + + prefsedit.putString(ONBOOTPROFILE, connectedrofile.getUUIDString()); + prefsedit.apply(); + mLastConnectedVpn=connectedrofile; + + } + + public static VpnProfile getOnBootProfile(Context c) { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(c); + + boolean useStartOnBoot = prefs.getBoolean("restartvpnonboot", false); + + + String mBootProfileUUID = prefs.getString(ONBOOTPROFILE,null); + if(useStartOnBoot && mBootProfileUUID!=null) + return get(c, mBootProfileUUID); + else + return null; + } + + + + + public Collection getProfiles() { + return profiles.values(); + } + + public VpnProfile getProfileByName(String name) { + for (VpnProfile vpnp : profiles.values()) { + if(vpnp.getName().equals(name)) { + return vpnp; + } + } + return null; + } + + public void saveProfileList(Context context) { + SharedPreferences sharedprefs = context.getSharedPreferences(PREFS_NAME,Activity.MODE_PRIVATE); + Editor editor = sharedprefs.edit(); + editor.putStringSet("vpnlist", profiles.keySet()); + + // For reasing I do not understand at all + // Android saves my prefs file only one time + // if I remove the debug code below :( + int counter = sharedprefs.getInt("counter", 0); + editor.putInt("counter", counter+1); + editor.apply(); + + } + + public void addProfile(VpnProfile profile) { + profiles.put(profile.getUUID().toString(),profile); + + } + + public static void setTemporaryProfile(VpnProfile tmp) { + ProfileManager.tmpprofile = tmp; + } + + + public void saveProfile(Context context,VpnProfile profile) { + // First let basic settings save its state + + ObjectOutputStream vpnfile; + try { + vpnfile = new ObjectOutputStream(context.openFileOutput((profile.getUUID().toString() + ".vp"),Activity.MODE_PRIVATE)); + + vpnfile.writeObject(profile); + vpnfile.flush(); + vpnfile.close(); + } catch (FileNotFoundException e) { + + VpnStatus.logException("saving VPN profile", e); + throw new RuntimeException(e); + } catch (IOException e) { + VpnStatus.logException("saving VPN profile", e); + throw new RuntimeException(e); + } + } + + + private void loadVPNList(Context context) { + profiles = new HashMap(); + SharedPreferences listpref = context.getSharedPreferences(PREFS_NAME,Activity.MODE_PRIVATE); + Set vlist = listpref.getStringSet("vpnlist", null); + Exception exp =null; + if(vlist==null){ + vlist = new HashSet(); + } + + for (String vpnentry : vlist) { + try { + ObjectInputStream vpnfile = new ObjectInputStream(context.openFileInput(vpnentry + ".vp")); + VpnProfile vp = ((VpnProfile) vpnfile.readObject()); + + // Sanity check + if(vp==null || vp.mName==null || vp.getUUID()==null) + continue; + + vp.upgradeProfile(); + profiles.put(vp.getUUID().toString(), vp); + + } catch (StreamCorruptedException e) { + exp=e; + } catch (FileNotFoundException e) { + exp=e; + } catch (IOException e) { + exp=e; + } catch (ClassNotFoundException e) { + exp=e; + } + if(exp!=null) { + VpnStatus.logException("Loading VPN List",exp); + } + } + } + + public int getNumberOfProfiles() { + return profiles.size(); + } + + + + public void removeProfile(Context context,VpnProfile profile) { + String vpnentry = profile.getUUID().toString(); + profiles.remove(vpnentry); + saveProfileList(context); + context.deleteFile(vpnentry + ".vp"); + if(mLastConnectedVpn==profile) + mLastConnectedVpn=null; + + } + + + + public static VpnProfile get(Context context, String profileUUID) { + checkInstance(context); + return get(profileUUID); + } + + + + public static VpnProfile getLastConnectedVpn() { + return mLastConnectedVpn; + } + +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ProxyDetection.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ProxyDetection.java new file mode 100644 index 00000000..47d88279 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ProxyDetection.java @@ -0,0 +1,55 @@ +package de.blinkt.openvpn.core; + +import java.net.InetSocketAddress; +import java.net.MalformedURLException; +import java.net.Proxy; +import java.net.ProxySelector; +import java.net.SocketAddress; +import java.net.URISyntaxException; +import java.net.URL; +import java.util.List; + +import se.leap.bitmaskclient.R; +import de.blinkt.openvpn.VpnProfile; + +public class ProxyDetection { + static SocketAddress detectProxy(VpnProfile vp) { + // Construct a new url with https as protocol + try { + URL url = new URL(String.format("https://%s:%s",vp.mServerName,vp.mServerPort)); + Proxy proxy = getFirstProxy(url); + + if(proxy==null) + return null; + SocketAddress addr = proxy.address(); + if (addr instanceof InetSocketAddress) { + return addr; + } + + } catch (MalformedURLException e) { + VpnStatus.logError(R.string.getproxy_error, e.getLocalizedMessage()); + } catch (URISyntaxException e) { + VpnStatus.logError(R.string.getproxy_error, e.getLocalizedMessage()); + } + return null; + } + + static Proxy getFirstProxy(URL url) throws URISyntaxException { + System.setProperty("java.net.useSystemProxies", "true"); + + List proxylist = ProxySelector.getDefault().select(url.toURI()); + + + if (proxylist != null) { + for (Proxy proxy: proxylist) { + SocketAddress addr = proxy.address(); + + if (addr != null) { + return proxy; + } + } + + } + return null; + } +} \ No newline at end of file diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/VPNLaunchHelper.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/VPNLaunchHelper.java new file mode 100644 index 00000000..55fcb0ba --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/VPNLaunchHelper.java @@ -0,0 +1,77 @@ +package de.blinkt.openvpn.core; + +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; + +import android.content.Context; +import android.content.Intent; +import android.os.Build; +import se.leap.bitmaskclient.R; +import de.blinkt.openvpn.VpnProfile; + +public class VPNLaunchHelper { + static private boolean writeMiniVPN(Context context) { + File mvpnout = new File(context.getCacheDir(),VpnProfile.MINIVPN); + if (mvpnout.exists() && mvpnout.canExecute()) + return true; + + IOException e2 = null; + + try { + InputStream mvpn; + + try { + mvpn = context.getAssets().open("minivpn." + Build.CPU_ABI); + } + catch (IOException errabi) { + VpnStatus.logInfo("Failed getting assets for archicture " + Build.CPU_ABI); + e2=errabi; + mvpn = context.getAssets().open("minivpn." + Build.CPU_ABI2); + + } + + + FileOutputStream fout = new FileOutputStream(mvpnout); + + byte buf[]= new byte[4096]; + + int lenread = mvpn.read(buf); + while(lenread> 0) { + fout.write(buf, 0, lenread); + lenread = mvpn.read(buf); + } + fout.close(); + + if(!mvpnout.setExecutable(true)) { + VpnStatus.logError("Failed to set minivpn executable"); + return false; + } + + + return true; + } catch (IOException e) { + if(e2!=null) + VpnStatus.logException(e2); + VpnStatus.logException(e); + + return false; + } + } + + + public static void startOpenVpn(VpnProfile startprofile, Context context) { + if(!writeMiniVPN(context)) { + VpnStatus.logError("Error writing minivpn binary"); + return; + } + + VpnStatus.logInfo(R.string.building_configration); + + Intent startVPN = startprofile.prepareIntent(context); + if(startVPN!=null) + context.startService(startVPN); + + } +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/VpnStatus.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/VpnStatus.java new file mode 100644 index 00000000..c19daeb0 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/VpnStatus.java @@ -0,0 +1,540 @@ +package de.blinkt.openvpn.core; + +import android.annotation.SuppressLint; +import android.content.Context; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; +import android.content.pm.PackageManager.NameNotFoundException; +import android.content.pm.Signature; +import android.os.Build; +import android.os.Parcel; +import android.os.Parcelable; +import se.leap.bitmaskclient.R; + +import java.io.ByteArrayInputStream; +import java.io.FileNotFoundException; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.security.cert.CertificateException; +import java.security.cert.CertificateFactory; +import java.security.cert.X509Certificate; +import java.util.Arrays; +import java.util.FormatFlagsConversionMismatchException; +import java.util.LinkedList; +import java.util.Locale; +import java.util.UnknownFormatConversionException; +import java.util.Vector; + +public class VpnStatus { + + + public static LinkedList logbuffer; + + private static Vector logListener; + private static Vector stateListener; + private static Vector byteCountListener; + + private static String mLaststatemsg=""; + + private static String mLaststate = "NOPROCESS"; + + private static int mLastStateresid=R.string.state_noprocess; + + private static long mlastByteCount[]={0,0,0,0}; + + public static void logException(LogLevel ll, String context, Exception e) { + StringWriter sw = new StringWriter(); + e.printStackTrace(new PrintWriter(sw)); + LogItem li; + if (context !=null) { + li = new LogItem(ll, R.string.unhandled_exception_context, e.getMessage(), sw.toString(), context); + } else { + li = new LogItem(ll, R.string.unhandled_exception, e.getMessage(), sw.toString()); + } + newLogItem(li); + } + + public static void logException(Exception e) { + logException(LogLevel.ERROR, null, e); + } + + public static void logException(String context, Exception e) { + logException(LogLevel.ERROR, context, e); + } + + private static final int MAXLOGENTRIES = 1000; + + public static final String MANAGMENT_PREFIX = "M:"; + + public enum ConnectionStatus { + LEVEL_CONNECTED, + LEVEL_VPNPAUSED, + LEVEL_CONNECTING_SERVER_REPLIED, + LEVEL_CONNECTING_NO_SERVER_REPLY_YET, + LEVEL_NONETWORK, + LEVEL_NOTCONNECTED, + LEVEL_AUTH_FAILED, + LEVEL_WAITING_FOR_USER_INPUT, + UNKNOWN_LEVEL + } + + public enum LogLevel { + INFO(2), + ERROR(-2), + WARNING(1), + VERBOSE(3), + DEBUG(4); + + protected int mValue; + LogLevel(int value) { + mValue = value; + } + + public int getInt() { + return mValue; + } + + public static LogLevel getEnumByValue(int value) { + switch (value) { + case 1: return INFO; + case 2: return ERROR; + case 3: return WARNING; + case 4: return DEBUG; + default: return null; + } + } + } + + // keytool -printcert -jarfile de.blinkt.openvpn_85.apk + public static final byte[] officalkey = {-58, -42, -44, -106, 90, -88, -87, -88, -52, -124, 84, 117, 66, 79, -112, -111, -46, 86, -37, 109}; + public static final byte[] officaldebugkey = {-99, -69, 45, 71, 114, -116, 82, 66, -99, -122, 50, -70, -56, -111, 98, -35, -65, 105, 82, 43}; + public static final byte[] amazonkey = {-116, -115, -118, -89, -116, -112, 120, 55, 79, -8, -119, -23, 106, -114, -85, -56, -4, 105, 26, -57}; + public static final byte[] fdroidkey = {-92, 111, -42, -46, 123, -96, -60, 79, -27, -31, 49, 103, 11, -54, -68, -27, 17, 2, 121, 104}; + + + private static ConnectionStatus mLastLevel=ConnectionStatus.LEVEL_NOTCONNECTED; + + static { + logbuffer = new LinkedList(); + logListener = new Vector(); + stateListener = new Vector(); + byteCountListener = new Vector(); + logInformation(); + } + + + public static class LogItem implements Parcelable { + + + private Object [] mArgs = null; + private String mMessage = null; + private int mRessourceId; + // Default log priority + LogLevel mLevel = LogLevel.INFO; + private long logtime = System.currentTimeMillis(); + private int mVerbosityLevel = -1; + + private LogItem(int ressourceId, Object[] args) { + mRessourceId = ressourceId; + mArgs = args; + } + + public LogItem(LogLevel level, int verblevel, String message) { + mMessage=message; + mLevel = level; + mVerbosityLevel = verblevel; + } + + @Override + public int describeContents() { + return 0; + } + + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeArray(mArgs); + dest.writeString(mMessage); + dest.writeInt(mRessourceId); + dest.writeInt(mLevel.getInt()); + dest.writeInt(mVerbosityLevel); + + dest.writeLong(logtime); + } + + public LogItem(Parcel in) { + mArgs = in.readArray(Object.class.getClassLoader()); + mMessage = in.readString(); + mRessourceId = in.readInt(); + mLevel = LogLevel.getEnumByValue(in.readInt()); + mVerbosityLevel = in.readInt(); + logtime = in.readLong(); + } + + public static final Parcelable.Creator CREATOR + = new Parcelable.Creator() { + public LogItem createFromParcel(Parcel in) { + return new LogItem(in); + } + + public LogItem[] newArray(int size) { + return new LogItem[size]; + } + }; + + public LogItem(LogLevel loglevel,int ressourceId, Object... args) { + mRessourceId = ressourceId; + mArgs =args; + mLevel = loglevel; + } + + + public LogItem(LogLevel loglevel, String msg) { + mLevel = loglevel; + mMessage = msg; + } + + + public LogItem(LogLevel loglevel, int ressourceId) { + mRessourceId =ressourceId; + mLevel = loglevel; + } + + public String getString(Context c) { + try { + if(mMessage !=null) { + return mMessage; + } else { + if(c!=null) { + if(mRessourceId==R.string.mobile_info) + return getMobileInfoString(c); + if(mArgs == null) + return c.getString(mRessourceId); + else + return c.getString(mRessourceId,mArgs); + } else { + String str = String.format(Locale.ENGLISH,"Log (no context) resid %d", mRessourceId); + if(mArgs !=null) + for(Object o:mArgs) + str += "|" + o.toString(); + + return str; + } + } + } catch (UnknownFormatConversionException e) { + if (c != null) + throw new UnknownFormatConversionException(e.getLocalizedMessage() + getString(null)); + else + throw e; + } catch (java.util.FormatFlagsConversionMismatchException e) { + if (c != null) + throw new FormatFlagsConversionMismatchException(e.getLocalizedMessage() + getString(null),e.getConversion()); + else + throw e; + } + + } + + public LogLevel getLogLevel() + { + return mLevel; + } + + // The lint is wrong here + @SuppressLint("StringFormatMatches") + private String getMobileInfoString(Context c) { + c.getPackageManager(); + String apksign="error getting package signature"; + + String version="error getting version"; + try { + Signature raw = c.getPackageManager().getPackageInfo(c.getPackageName(), PackageManager.GET_SIGNATURES).signatures[0]; + CertificateFactory cf = CertificateFactory.getInstance("X.509"); + X509Certificate cert = (X509Certificate) cf.generateCertificate(new ByteArrayInputStream(raw.toByteArray())); + MessageDigest md = MessageDigest.getInstance("SHA-1"); + byte[] der = cert.getEncoded(); + md.update(der); + byte[] digest = md.digest(); + + if (Arrays.equals(digest, officalkey)) + apksign = c.getString(R.string.official_build); + else if (Arrays.equals(digest, officaldebugkey)) + apksign = c.getString(R.string.debug_build); + else if (Arrays.equals(digest, amazonkey)) + apksign = "amazon version"; + else if (Arrays.equals(digest, fdroidkey)) + apksign = "F-Droid built and signed version"; + else + apksign = c.getString(R.string.built_by,cert.getSubjectX500Principal().getName()); + + PackageInfo packageinfo = c.getPackageManager().getPackageInfo(c.getPackageName(), 0); + version = packageinfo.versionName; + + } catch (NameNotFoundException e) { + } catch (CertificateException e) { + } catch (NoSuchAlgorithmException e) { + } + + Object[] argsext = Arrays.copyOf(mArgs, mArgs.length+2); + argsext[argsext.length-1]=apksign; + argsext[argsext.length-2]=version; + + return c.getString(R.string.mobile_info_extended, argsext); + + } + + public long getLogtime() { + return logtime; + } + + + public int getVerbosityLevel() { + if (mVerbosityLevel==-1) { + // Hack: + // For message not from OpenVPN, report the status level as log level + return mLevel.getInt(); + } + return mVerbosityLevel; + } + } + + + + public interface LogListener { + void newLog(LogItem logItem); + } + + public interface StateListener { + void updateState(String state, String logmessage, int localizedResId, ConnectionStatus level); + } + + public interface ByteCountListener { + void updateByteCount(long in, long out, long diffIn, long diffOut); + } + + public synchronized static void logMessage(LogLevel level,String prefix, String message) + { + newLogItem(new LogItem(level, prefix + message)); + + } + + public synchronized static void clearLog() { + logbuffer.clear(); + logInformation(); + } + + private static void logInformation() { + logInfo(R.string.mobile_info,Build.MODEL, Build.BOARD,Build.BRAND,Build.VERSION.SDK_INT); + } + + public synchronized static void addLogListener(LogListener ll){ + logListener.add(ll); + } + + public synchronized static void removeLogListener(LogListener ll) { + logListener.remove(ll); + } + + public synchronized static void addByteCountListener(ByteCountListener bcl) { + bcl.updateByteCount(mlastByteCount[0], mlastByteCount[1], mlastByteCount[2], mlastByteCount[3]); + byteCountListener.add(bcl); + } + + public synchronized static void removeByteCountListener(ByteCountListener bcl) { + byteCountListener.remove(bcl); + } + + + public synchronized static void addStateListener(StateListener sl){ + if(!stateListener.contains(sl)){ + stateListener.add(sl); + if(mLaststate!=null) + sl.updateState(mLaststate, mLaststatemsg, mLastStateresid, mLastLevel); + } + } + + private static int getLocalizedState(String state){ + if (state.equals("CONNECTING")) + return R.string.state_connecting; + else if (state.equals("WAIT")) + return R.string.state_wait; + else if (state.equals("AUTH")) + return R.string.state_auth; + else if (state.equals("GET_CONFIG")) + return R.string.state_get_config; + else if (state.equals("ASSIGN_IP")) + return R.string.state_assign_ip; + else if (state.equals("ADD_ROUTES")) + return R.string.state_add_routes; + else if (state.equals("CONNECTED")) + return R.string.state_connected; + else if (state.equals("DISCONNECTED")) + return R.string.state_disconnected; + else if (state.equals("RECONNECTING")) + return R.string.state_reconnecting; + else if (state.equals("EXITING")) + return R.string.state_exiting; + else if (state.equals("RESOLVE")) + return R.string.state_resolve; + else if (state.equals("TCP_CONNECT")) + return R.string.state_tcp_connect; + else + return R.string.unknown_state; + + } + + public static void updateStatePause(OpenVPNManagement.pauseReason pauseReason) { + switch (pauseReason) { + case noNetwork: + VpnStatus.updateStateString("NONETWORK", "", R.string.state_nonetwork, ConnectionStatus.LEVEL_NONETWORK); + break; + case screenOff: + VpnStatus.updateStateString("SCREENOFF", "", R.string.state_screenoff, ConnectionStatus.LEVEL_VPNPAUSED); + break; + case userPause: + VpnStatus.updateStateString("USERPAUSE", "", R.string.state_userpause, ConnectionStatus.LEVEL_VPNPAUSED); + break; + } + + } + + private static ConnectionStatus getLevel(String state){ + String[] noreplyet = {"CONNECTING","WAIT", "RECONNECTING", "RESOLVE", "TCP_CONNECT"}; + String[] reply = {"AUTH","GET_CONFIG","ASSIGN_IP","ADD_ROUTES"}; + String[] connected = {"CONNECTED"}; + String[] notconnected = {"DISCONNECTED", "EXITING"}; + + for(String x:noreplyet) + if(state.equals(x)) + return ConnectionStatus.LEVEL_CONNECTING_NO_SERVER_REPLY_YET; + + for(String x:reply) + if(state.equals(x)) + return ConnectionStatus.LEVEL_CONNECTING_SERVER_REPLIED; + + for(String x:connected) + if(state.equals(x)) + return ConnectionStatus.LEVEL_CONNECTED; + + for(String x:notconnected) + if(state.equals(x)) + return ConnectionStatus.LEVEL_NOTCONNECTED; + + return ConnectionStatus.UNKNOWN_LEVEL; + + } + + + + + public synchronized static void removeStateListener(StateListener sl) { + stateListener.remove(sl); + } + + + synchronized public static LogItem[] getlogbuffer() { + + // The stoned way of java to return an array from a vector + // brought to you by eclipse auto complete + return logbuffer.toArray(new LogItem[logbuffer.size()]); + + } + + public static void updateStateString (String state, String msg) { + int rid = getLocalizedState(state); + ConnectionStatus level = getLevel(state); + updateStateString(state, msg, rid, level); + } + + public synchronized static void updateStateString(String state, String msg, int resid, ConnectionStatus level) { + // Workound for OpenVPN doing AUTH and wait and being connected + // Simply ignore these state + if (mLastLevel == ConnectionStatus.LEVEL_CONNECTED && + (state.equals("WAIT") || state.equals("AUTH"))) + { + newLogItem(new LogItem((LogLevel.DEBUG), String.format("Ignoring OpenVPN Status in CONNECTED state (%s->%s): %s",state,level.toString(),msg))); + return; + } + + mLaststate= state; + mLaststatemsg = msg; + mLastStateresid = resid; + mLastLevel = level; + + + + for (StateListener sl : stateListener) { + sl.updateState(state,msg,resid,level); + } + //newLogItem(new LogItem((LogLevel.DEBUG), String.format("New OpenVPN Status (%s->%s): %s",state,level.toString(),msg))); + } + + public static void logInfo(String message) { + newLogItem(new LogItem(LogLevel.INFO, message)); + } + + public static void logInfo(int resourceId, Object... args) { + newLogItem(new LogItem(LogLevel.INFO, resourceId, args)); + } + + public static void logDebug(int resourceId, Object... args) { + newLogItem(new LogItem(LogLevel.DEBUG, resourceId, args)); + } + + + private synchronized static void newLogItem(LogItem logItem) { + logbuffer.addLast(logItem); + if(logbuffer.size()>MAXLOGENTRIES) + logbuffer.removeFirst(); + + for (LogListener ll : logListener) { + ll.newLog(logItem); + } + } + + public static void logError(String msg) { + newLogItem(new LogItem(LogLevel.ERROR, msg)); + + } + + public static void logWarning(int resourceId, Object... args) { + newLogItem(new LogItem(LogLevel.WARNING, resourceId, args)); + } + + public static void logWarning(String msg) { + newLogItem(new LogItem(LogLevel.WARNING, msg)); + } + + + public static void logError(int resourceId) { + newLogItem(new LogItem(LogLevel.ERROR, resourceId)); + } + public static void logError(int resourceId, Object... args) { + newLogItem(new LogItem(LogLevel.ERROR, resourceId, args)); + } + + public static void logMessageOpenVPN(LogLevel level, int ovpnlevel, String message) { + newLogItem(new LogItem(level, ovpnlevel, message)); + + } + + + public static synchronized void updateByteCount(long in, long out) { + long lastIn = mlastByteCount[0]; + long lastOut = mlastByteCount[1]; + long diffIn = mlastByteCount[2] = in - lastIn; + long diffOut = mlastByteCount[3] = out - lastOut; + + + + mlastByteCount = new long[] {in,out,diffIn,diffOut}; + for(ByteCountListener bcl:byteCountListener){ + bcl.updateByteCount(in, out, diffIn,diffOut); + } + } + + + +} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/X509Utils.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/X509Utils.java new file mode 100644 index 00000000..35e53c08 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/X509Utils.java @@ -0,0 +1,155 @@ +package de.blinkt.openvpn.core; + +import android.content.Context; +import android.text.TextUtils; + +import se.leap.bitmaskclient.R; +import de.blinkt.openvpn.VpnProfile; +import org.spongycastle.util.io.pem.PemObject; +import org.spongycastle.util.io.pem.PemReader; + + +import javax.security.auth.x500.X500Principal; +import java.io.*; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.security.cert.Certificate; +import java.security.cert.CertificateException; +import java.security.cert.CertificateFactory; +import java.security.cert.X509Certificate; +import java.util.Hashtable; + +public class X509Utils { + public static Certificate getCertificateFromFile(String certfilename) throws FileNotFoundException, CertificateException { + CertificateFactory certFact = CertificateFactory.getInstance("X.509"); + + InputStream inStream; + + if(VpnProfile.isEmbedded(certfilename)) { + // The java certifcate reader is ... kind of stupid + // It does NOT ignore chars before the --BEGIN ... + int subIndex = certfilename.indexOf("-----BEGIN CERTIFICATE-----"); + subIndex = Math.max(0,subIndex); + inStream = new ByteArrayInputStream(certfilename.substring(subIndex).getBytes()); + + + } else { + inStream = new FileInputStream(certfilename); + } + + + return certFact.generateCertificate(inStream); + } + + public static PemObject readPemObjectFromFile (String keyfilename) throws IOException { + + Reader inStream; + + if(VpnProfile.isEmbedded(keyfilename)) + inStream = new StringReader(VpnProfile.getEmbeddedContent(keyfilename)); + else + inStream = new FileReader(new File(keyfilename)); + + PemReader pr = new PemReader(inStream); + PemObject r = pr.readPemObject(); + pr.close(); + return r; + } + + + + + public static String getCertificateFriendlyName (Context c, String filename) { + if(!TextUtils.isEmpty(filename)) { + try { + X509Certificate cert = (X509Certificate) getCertificateFromFile(filename); + + return getCertificateFriendlyName(cert); + + } catch (Exception e) { + VpnStatus.logError("Could not read certificate" + e.getLocalizedMessage()); + } + } + return c.getString(R.string.cannotparsecert); + } + + public static String getCertificateFriendlyName(X509Certificate cert) { + X500Principal principal = cert.getSubjectX500Principal(); + byte[] encodedSubject = principal.getEncoded(); + String friendlyName=null; + + /* Hack so we do not have to ship a whole Spongy/bouncycastle */ + Exception exp=null; + try { + Class X509NameClass = Class.forName("com.android.org.bouncycastle.asn1.x509.X509Name"); + Method getInstance = X509NameClass.getMethod("getInstance",Object.class); + + Hashtable defaultSymbols = (Hashtable) X509NameClass.getField("DefaultSymbols").get(X509NameClass); + + if (!defaultSymbols.containsKey("1.2.840.113549.1.9.1")) + defaultSymbols.put("1.2.840.113549.1.9.1","eMail"); + + Object subjectName = getInstance.invoke(X509NameClass, encodedSubject); + + Method toString = X509NameClass.getMethod("toString",boolean.class,Hashtable.class); + + friendlyName= (String) toString.invoke(subjectName,true,defaultSymbols); + + } catch (ClassNotFoundException e) { + exp =e ; + } catch (NoSuchMethodException e) { + exp =e; + } catch (InvocationTargetException e) { + exp =e; + } catch (IllegalAccessException e) { + exp =e; + } catch (NoSuchFieldException e) { + exp =e; + } + if (exp!=null) + VpnStatus.logException("Getting X509 Name from certificate", exp); + + /* Fallback if the reflection method did not work */ + if(friendlyName==null) + friendlyName = principal.getName(); + + + // Really evil hack to decode email address + // See: http://code.google.com/p/android/issues/detail?id=21531 + + String[] parts = friendlyName.split(","); + for (int i=0;i allEntries=new Vector(); + + private Vector currentLevelEntries=new Vector(); + + private Handler mHandler; + + private Vector observers=new Vector(); + + private int mTimeFormat=0; + private int mLogLevel=3; + + + public LogWindowListAdapter() { + initLogBuffer(); + if (mHandler == null) { + mHandler = new Handler(this); + } + + VpnStatus.addLogListener(this); + } + + + + private void initLogBuffer() { + allEntries.clear(); + Collections.addAll(allEntries, VpnStatus.getlogbuffer()); + initCurrentMessages(); + } + + String getLogStr() { + String str = ""; + for(LogItem entry:allEntries) { + str+=getTime(entry, TIME_FORMAT_ISO) + entry.getString(getActivity()) + '\n'; + } + return str; + } + + + private void shareLog() { + Intent shareIntent = new Intent(Intent.ACTION_SEND); + shareIntent.putExtra(Intent.EXTRA_TEXT, getLogStr()); + shareIntent.putExtra(Intent.EXTRA_SUBJECT, getString(R.string.ics_openvpn_log_file)); + shareIntent.setType("text/plain"); + startActivity(Intent.createChooser(shareIntent, "Send Logfile")); + } + + @Override + public void registerDataSetObserver(DataSetObserver observer) { + observers.add(observer); + + } + + @Override + public void unregisterDataSetObserver(DataSetObserver observer) { + observers.remove(observer); + } + + @Override + public int getCount() { + return currentLevelEntries.size(); + } + + @Override + public Object getItem(int position) { + return currentLevelEntries.get(position); + } + + @Override + public long getItemId(int position) { + return ((Object)currentLevelEntries.get(position)).hashCode(); + } + + @Override + public boolean hasStableIds() { + return true; + } + + @Override + public View getView(int position, View convertView, ViewGroup parent) { + TextView v; + if(convertView==null) + v = new TextView(getActivity()); + else + v = (TextView) convertView; + + LogItem le = currentLevelEntries.get(position); + String msg = le.getString(getActivity()); + String time = getTime(le, mTimeFormat); + msg = time + msg; + + int spanStart = time.length(); + + SpannableString t = new SpannableString(msg); + + //t.setSpan(getSpanImage(le,(int)v.getTextSize()),spanStart,spanStart+1, Spanned.SPAN_INCLUSIVE_INCLUSIVE); + v.setText(t); + return v; + } + + private String getTime(LogItem le, int time) { + if (time != TIME_FORMAT_NONE) { + Date d = new Date(le.getLogtime()); + java.text.DateFormat timeformat; + if (time== TIME_FORMAT_ISO) + timeformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault()); + else + timeformat = DateFormat.getTimeFormat(getActivity()); + + return timeformat.format(d) + " "; + + } else { + return ""; + } + + } + + private ImageSpan getSpanImage(LogItem li, int imageSize) { + int imageRes = android.R.drawable.ic_menu_call; + + switch (li.getLogLevel()) { + case ERROR: + imageRes = android.R.drawable.ic_notification_clear_all; + break; + case INFO: + imageRes = android.R.drawable.ic_menu_compass; + break; + case VERBOSE: + imageRes = android.R.drawable.ic_menu_info_details; + break; + case WARNING: + imageRes = android.R.drawable.ic_menu_camera; + break; + } + + Drawable d = getResources().getDrawable(imageRes); + + + //d.setBounds(0, 0, d.getIntrinsicWidth(), d.getIntrinsicHeight()); + d.setBounds(0, 0, imageSize, imageSize); + ImageSpan span = new ImageSpan(d, ImageSpan.ALIGN_BOTTOM); + + return span; + } + + @Override + public int getItemViewType(int position) { + return 0; + } + + @Override + public int getViewTypeCount() { + return 1; + } + + @Override + public boolean isEmpty() { + return currentLevelEntries.isEmpty(); + + } + + @Override + public boolean areAllItemsEnabled() { + return true; + } + + @Override + public boolean isEnabled(int position) { + return true; + } + + @Override + public void newLog(LogItem logMessage) { + Message msg = Message.obtain(); + assert (msg!=null); + msg.what=MESSAGE_NEWLOG; + Bundle bundle=new Bundle(); + bundle.putParcelable("logmessage", logMessage); + msg.setData(bundle); + mHandler.sendMessage(msg); + } + + @Override + public boolean handleMessage(Message msg) { + // We have been called + if(msg.what==MESSAGE_NEWLOG) { + + LogItem logMessage = msg.getData().getParcelable("logmessage"); + if(addLogMessage(logMessage)) + for (DataSetObserver observer : observers) { + observer.onChanged(); + } + } else if (msg.what == MESSAGE_CLEARLOG) { + for (DataSetObserver observer : observers) { + observer.onInvalidated(); + } + initLogBuffer(); + } else if (msg.what == MESSAGE_NEWTS) { + for (DataSetObserver observer : observers) { + observer.onInvalidated(); + } + } else if (msg.what == MESSAGE_NEWLOGLEVEL) { + initCurrentMessages(); + + for (DataSetObserver observer: observers) { + observer.onChanged(); + } + + } + + return true; + } + + private void initCurrentMessages() { + currentLevelEntries.clear(); + for(LogItem li: allEntries) { + if (li.getVerbosityLevel() <= mLogLevel || + mLogLevel == VpnProfile.MAXLOGLEVEL) + currentLevelEntries.add(li); + } + } + + /** + * + * @param logmessage + * @return True if the current entries have changed + */ + private boolean addLogMessage(LogItem logmessage) { + allEntries.add(logmessage); + + if (allEntries.size() > MAX_STORED_LOG_ENTRIES) { + Vector oldAllEntries = allEntries; + allEntries = new Vector(allEntries.size()); + for (int i=50;i parent, View view, + int position, long id) { + ClipboardManager clipboard = (ClipboardManager) + getActivity().getSystemService(Context.CLIPBOARD_SERVICE); + ClipData clip = ClipData.newPlainText("Log Entry",((TextView) view).getText()); + clipboard.setPrimaryClip(clip); + Toast.makeText(getActivity(), R.string.copied_entry, Toast.LENGTH_SHORT).show(); + return true; + } + }); + } + + @Nullable + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + View v = inflater.inflate(R.layout.log_fragment, container, false); + + setHasOptionsMenu(true); + + ladapter = new LogWindowListAdapter(); + ladapter.mTimeFormat = getActivity().getPreferences(0).getInt(LOGTIMEFORMAT, 0); + int logLevel = getActivity().getPreferences(0).getInt(VERBOSITYLEVEL, 0); + ladapter.setLogLevel(logLevel); + + setListAdapter(ladapter); + + mTimeRadioGroup = (RadioGroup) v.findViewById(R.id.timeFormatRadioGroup); + mTimeRadioGroup.setOnCheckedChangeListener(this); + + if(ladapter.mTimeFormat== LogWindowListAdapter.TIME_FORMAT_ISO) { + mTimeRadioGroup.check(R.id.radioISO); + } else if (ladapter.mTimeFormat == LogWindowListAdapter.TIME_FORMAT_NONE) { + mTimeRadioGroup.check(R.id.radioNone); + } else if (ladapter.mTimeFormat == LogWindowListAdapter.TIME_FORMAT_SHORT) { + mTimeRadioGroup.check(R.id.radioShort); + } + + mSpeedView = (TextView) v.findViewById(R.id.speed); + + mOptionsLayout = (LinearLayout) v.findViewById(R.id.logOptionsLayout); + mLogLevelSlider = (SeekBar) v.findViewById(R.id.LogLevelSlider); + mLogLevelSlider.setMax(VpnProfile.MAXLOGLEVEL-1); + mLogLevelSlider.setProgress(logLevel-1); + + mLogLevelSlider.setOnSeekBarChangeListener(this); + + if(getResources().getBoolean(R.bool.logSildersAlwaysVisible)) + mOptionsLayout.setVisibility(View.VISIBLE); + + mUpStatus = (TextView) v.findViewById(R.id.speedUp); + mDownStatus = (TextView) v.findViewById(R.id.speedDown); + mConnectStatus = (TextView) v.findViewById(R.id.speedStatus); + if (mShowOptionsLayout) + mOptionsLayout.setVisibility(View.VISIBLE); + return v; + } + + @Override + public void onAttach(Activity activity) { + super.onAttach(activity); + if(getResources().getBoolean(R.bool.logSildersAlwaysVisible)) { + mShowOptionsLayout=true; + if (mOptionsLayout!= null) + mOptionsLayout.setVisibility(View.VISIBLE); + } + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + //getActionBar().setDisplayHomeAsUpEnabled(true); + + } + + + @Override + public void updateState(final String status, final String logMessage, final int resId, final ConnectionStatus level) { + if (isAdded()) { + getActivity().runOnUiThread(new Runnable() { + + @Override + public void run() { + if (isAdded()) { + String prefix = getString(resId) + ":"; + if (status.equals("BYTECOUNT") || status.equals("NOPROCESS")) + prefix = ""; + if (resId == R.string.unknown_state) + prefix += status; + if (mSpeedView != null) + mSpeedView.setText(prefix + logMessage); + + if (mConnectStatus != null) + mConnectStatus.setText(getString(resId)); + } + } + }); + } + } + + + @Override + public void onDestroy() { + VpnStatus.removeLogListener(ladapter); + super.onDestroy(); + } + +} diff --git a/ics-openvpn-stripped/main/src/main/res/layout-sw600dp-port/log_fragment.xml b/ics-openvpn-stripped/main/src/main/res/layout-sw600dp-port/log_fragment.xml new file mode 100644 index 00000000..ddf0506b --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/layout-sw600dp-port/log_fragment.xml @@ -0,0 +1,42 @@ + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/ics-openvpn-stripped/main/src/main/res/layout-sw600dp/log_fragment.xml b/ics-openvpn-stripped/main/src/main/res/layout-sw600dp/log_fragment.xml new file mode 100644 index 00000000..c4e1355c --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/layout-sw600dp/log_fragment.xml @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + diff --git a/ics-openvpn-stripped/main/src/main/res/layout/log_fragment.xml b/ics-openvpn-stripped/main/src/main/res/layout/log_fragment.xml new file mode 100644 index 00000000..0b428070 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/layout/log_fragment.xml @@ -0,0 +1,29 @@ + + + + + + + + + + + + + \ No newline at end of file diff --git a/ics-openvpn-stripped/main/src/main/res/layout/log_window.xml b/ics-openvpn-stripped/main/src/main/res/layout/log_window.xml new file mode 100644 index 00000000..56c3e349 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/layout/log_window.xml @@ -0,0 +1,7 @@ + \ No newline at end of file diff --git a/ics-openvpn-stripped/main/src/main/res/values-ca/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-ca/strings.xml new file mode 100755 index 00000000..554b4816 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-ca/strings.xml @@ -0,0 +1,120 @@ + + + + + OpenVPN per Android + Adreá del servidor: + Port del servidor: + Lloc + Selecciona + Cancel·la + Sense informació + Compresió LZO + Sense Certificat + Certificat Client + Clau del certificat client + Fitxer PKCS12 + Certificat CA + Quan a + Tipus + Contrasenya PKCS12 + Selecciona… + Utiltiza autenticació TLS + Direcció TLS + Introduïu l\'adreça/mascara de xarxa IPv6 en format CIDR Format (e.g. 2000:dd::23/64) + Introduïu l\'adreça/mascara de xarxa IPv4 en format CIDR (e.g. 1.2.3.4/24) + Adreça IPv4 + Adreça IPv6 + Usuari + Contrasenya + Configura la VPN + Afegeix un perfil + Introduïu un nom identificant el perfil + Nom del perfil + No s\'ha trobat cap error + S\'ha trobat un error a la configuració + Acces directe de OpenVPN + Conecta a la VPN + No s\'ha trobat el perfil especificat a l\'accès directe + Prefix aleatoria del host + La ruta ha estat refusas per Android + Desconecta + Neteja el registre + Cancela la confirmació + Desconcta la conexió VPN/cancela l\'intent de conexió? + Eliminar VPN + DNS + Servidor DNS a utilitzar. + Servidor DNS + Redirecciona tot el trafic a través de la VPN + Utilitza la ruta per defecte + Rutes personalitzadse + Nivell de detall del registre + Opcions personalitzades + Edita la configuració VPN + "Error: " + Neteja + Envia el fitxer de registre + Envia + Fitxer de registre de ICS OpenVPN + S\'ha copiat l\'entrada al porta-retalls + Mode Tap + No es pot utiltizar el mode tap amb la api no rootejada. L\'aplicació no suporta tap + FAQ + Copiant entrades de registre + Acces directe per inciar + Encriptació + Introduïu el mètode d\'encriptació + Autentificació/Encriptació + Explorador de fitxers + Fitxer en linea + Error important el fitxer + No s\'ha pogut importar el fitxer del sistema de fitxers + [[Inline file data]] + Importa el perfil d\'un fitxer ovpn + Importa + No s\'ha pogut llegir el fitxer a importar + Error llegint el fitxer de configuració + afegir un Perfil + S\'ha llegit el fitxer de configuració. + Importa + IPv4 + IPv6 + Esperant el missatge d\'estat… + Perfil importat + Perfil importat %d + Imatges trencades + Contrasenya de la clau privada + Contrasenya + Icona del fitxer + Autentificació TLS + Configuració generada + Corregir els permisos de /dev/tun + Mostra el fitxer de configuració d\'OpenVPN generat + Editant \"%s\" + Construint la configuració… + Reconecta al canviar de xarxa + Estat de la xarxa %s + Selecciona + Mostra la finestra de registre + Traducció al catala per Sergi Almacellas +<sergi@koolpi.com> + IP i DNS + Bàsic + Ruting + Avançat + Inici rapid + Utilitzant el proxy %1$s %2$d + Utiliza el proxy del sistema + Torna a conectar al reiniciar + Ignorar + Reinicia + Els canvis de configuració s\'apliquen desprès de reinicar la VPN. (Re)inicar la VPN ara? + S\'ha canviat la configuració + Notificacions duplicades + No s\'han definit cap perfil. + Configuració del Ruting/Interficies + Registre OpenVPN + Importa la configuració OpenVPN + Consum de la bateria + diff --git a/ics-openvpn-stripped/main/src/main/res/values-cs/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-cs/strings.xml new file mode 100755 index 00000000..2377062e --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-cs/strings.xml @@ -0,0 +1,320 @@ + + + + + OpenVPN pro Android + Adresa serveru: + Port serveru: + Lokace + Nelze přečíst adresář + Zvolit + Storno + Žádná data + LZO komprese + Žádný certifikát + Klientský certifikát + Klientský klíč + PKCS12 soubor + CA certifikát + Je třeba vybrat certifikát + Zdrojové kódy a seznam problémů je na http://code.google.com/p/ics-openvpn/ + Tento program používá následující komponenty; viz zdrojový kód pro detaily o licenci + O programu + Profily + Typ + PKCS12 heslo + Vyber… + Je třeba vybrat soubor + Použij TLS autentikaci + TLS řízení + Zadej IPv6 adresu/masku v CIDR formátu (tj. 2000:dd::23/64) + Zadej IPv4 adresu/masku v CIDR formátu (tj. 1.2.3.4/24) + IPv4 adresa + IPv6 adresa + Zadat vlastní nastavení. Používat opatrně. Poznámka, mnoho voleb okolo tun adaptéru nemůže být podporováno. Pokud si myslíte, že chybí podstatná volba, kontaktujte autora + Jméno + Heslo + Pro statickou konfiguraci bude jako klíč použit autentizační klíč TLS + Konfigurace VPN + Přidat profil + Zadej jméno identifikující nový profil + Zadej prosím unikátní jméno profilu + Jméno profilu + Je třeba vybrat uživatelský certifikát + Bez chyb + Chyba v konfiguraci + Chyba při zpracování IPv4 adresy + Chyba při zpracování vlastního směrování + (nechej prázdné pro dotazování, až bude potřeba) + OpenVPN zkratka + Připojit k VPN + Profil zvolený ve zkratce nenalezen + Náhodný prefix klienta + Přidej 6 náhodných znaků před jméno klienta (hostname) + Povolit vlastní nastavení + Zadat vlastní nastavení. Používat opatrně! + Směrování odmítnuto Androidem + Odpojit + Odpojit VPN + vymazat log + Zrušit potvrzení + Odpojit/Zrušit připojování? + Odstranit VPN + Kontrolovat, zda server používá certifikát s rozšířením TLS Server (--remote-cert-tls server) + Očekávat serverový TLS certifikát + Kontrola DN v certifikátu vzdáleného serveru + Ověření jména certifikátu + Specifikuj způsob kontroly DN v certifikátu vzdáleného serveru (př. C=DE, L=Paderborn, OU=Avian IP Carriers, CN=openvpn.blinkt.de)\n\nSpecifikuj kompletní DN nebo RDN (openvpn.blinkt.de v příkladu) nebo RDN prefix pro verifikaci.\n\nPři použití RDN prefixu, \"Server\" sedí na \"Server-1\" i \"Server-2\"\n\nJe-li RDN pole prázdné, kontroluje se proti jménu serveru.\n\nPro více detailů, viz manuálová stránka OpenVPN 2.3.1+, přepínač —verify-x509-name + Předmět vzdáleného certifikátu + Zapnout autentikaci pomocí TLS klíče + TLS autentikační soubor + Použít IP adresu, směrování a časování přijaté od serveru. + Žádné informace od serveru nevyžadovat. Nastavení je potřeba zadat níže. + Automaticky + DNS + Přepsat DNS nastavení + Použit vlastní DNS server + Doména pro hledání + Adresa primárního DNS serveru + Primární DNS server + Adresa záložního DNS serveru, pokud se nelze připojit k primárnímu. + Záložní DNS server + Ignorovat přijaté + Ignorovat směrování, které zaslal server. + Přesměrovat všechen provoz skrz VPN + Použít jako výchozí + Zadat vlastní směrování. Zadej cíle v CIDR formátu. \"10.0.0.0/8 2002::/16\" nasměruje sítě 10.0.0.0/8 a 2002::/16 skrz VPN. + Trasy, které NEmají být směrovány skrze VPN. Použij stejnou syntaxi jako pro zahrnuté trasy. + Vlastní směrování + Vyloučené sítě + Ukecanost logu + Povol autentifikované pakety z libovolné IP + Povol plovoucí server + Vlastní nastavení + Změnit nastavení VPN + Odstranit VPN profil \'%s\'? + Na některých ICS systémech může být oprávnění pro /dev/tun špatně nastavené, nebo tun modul může zcela chybět. Pro systém s CM9 zkus využít opravy vlastnictví v obecném nastavení + Chyba při otvírání tun zařízení + "Chyba: " + Vymazat + Otevření rozhraní tun: + Místní IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + DNS server: %1$s, Doména: %2$s + Trasy: %1$s %2$s + Vyloučené trasy: %1$s %2$s + Instalované VPNService trasy: %1$s%2$s + Získány informace o rozhraní %1$s a %2$s, předpokládám, že druhá adresa je adresa vzdáleného kolegy. Používám /32 masku pro místní IP adresu. Mód OpenVPN je \"%3$s\". + %1$s a %2$s jako IP adresy s CIDR maskou nedávají smysl, používám /32 jako masku. + Směrování opraveno z %1$s/%2$s na %3$s/%2$s + Nelze přistoupit k Androidímu úložišti certifikátů. To může být způsobeno aktualizací firmwaru nebo obnovováním aplikace a jejího nastavení ze zálohy. Uprav VPN profil a znovu vyber certifikát pro vytvoření patřičných povolení. + %1$s %2$s + Odeslat soubor s logem + Odeslat + ICS OpenVPN logovací soubor + Záznam z logu zkopírován do schránky + Tap mód + Tap mód není možný bez rootovského VPN API, proto tato aplikace nemá podporu pro tap + Opět? Děláš si srandu? Ne, tap mód opravdu není podporován a další maily na tom nic nezmění. + Potřetí? Ve skutečnosti, šlo by napsat emulátor tap zařizení pomocí tun, které by patřičně zpracovávalo informace z druhé vrstvy. Ale tento emulátor by také musel implementovat ARP a DHCP. Nejsem si vědom, že by někdo tímto směrem něco podnikl. Kontaktuj mne, pokud máš zájem toto naprogramovat. + FAQ + Kopírování záznamů z logu + Pro zkopírování jednoho záznamu stačí dlouze zmáčknout požadovaný záznam. Pro zkopírování/odeslání celého logu použij možnost Odeslat soubor s logem. Pokud není tlačítko viditené v uživatelském rozhraní, zkus použít to hardwarové. + Zkratka na spuštění + Můžeš umístit zástupce pro spuštění OpenVPN na plochu. V závislosti na úvodní obrazovce budeš muset přidat buď zástupce nebo widget. + Tvůj obrázek není podporovaný rozhraním VPNService, je mi líto :-( + Šifrování + Zadej šifrovací metodu + Zadej šifrovací algoritmus. Ponech prázdné pro výchozí šifru. + Zadej algoritmus pro autentizaci. Nech prázdné pro výchozí algoritmus. + Autentizace/Šifrování + Prohlížeč souború + Vložený soubor + Chyba při importu souboru + Nemohu importovat soubor ze souborového systému + [[Vložená data]] + Odmítám otevřít tun zařízení bez informace o IP + Importovat profil z ovpn souboru + Import + Nemohu přečíst profil k importu + Chyba při čtení konfiguračního souboru + přidat profil + Nemohu najít soubor %1$s zmiňovaný v importovaném profilu + Importuji nastavení z %1$s + V konfiguraci bylo několik nastavení, která nejsou mapována na uživateské rozhraní. Toto nastavení bylo přidáno jako vlastní konfigurace. Vlastní konfigurace je zobrazena níže: + Dočetl jsem konfigurační soubor. + Nevázat se k místní adrese a portu + Nesvazovat se + Importovat nastavení ze souboru + Úvaha o bezpečnosti + \"Protože OpenVPN je citlivá na bezpečnost je na místě několik poznámek. Všechna data na SD kartě jsou už z principu nezabezpečená. Každá aplikace je může číst (například ani tento program nepotřebuje žádná speciǎlní práva pro SD kartu). Data této aplikace může přečist jen aplikace sama. Použitím importu pro certifikáty/klíče jsou data uložena do VPN profilu. VPN profily jsou přístupné pouze pro tuto aplikaci. (Nezapomeň ale potom smazat kopie z SD karty.) Ale i když jsou data čitelná jen touto aplikací, nejsou nijak šifrována. Je-li zařízení rootnuté nebo nějak jinak upravené, existuje možnost získat tyto data. Uložená hesla jsou také v čitelné podobě. Pro pkcs12 certifikáty je velmi doporučeno využít importu do androidího úložiště. + Import + Chyba při zobrazení výběru certifikátu + Vyjímka při pokusu o zobrazení Android 4.0+ dialogu pro výběr certifikátu. Toto je standardní funkce Androidu 4.0+, takže k této chybě nemělo vůbec dojít, možná je chyba v podpoře certifikátů ve tvém systému + IPv4 + IPv6 + Čekám na zprávu o stavu… + importovaný profil + importovaný profil %d + Rozbité systémy + <p> Oficiální HTC obrazy jsou známy tím, že mají zvláštní problémy se směrováním síťového tok skrze tunel (viz také < href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=18\" > problém 18 </a> v bug trackeru.)</p> <p> Starší oficiální obrazy SONY Xperia Arc S a Xperia Ray zcela postrádaly VPNService. (Viz také < href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=29\" > problém 29 </a> v bug trackeru.)</p> <p> Na vlastních obrazech Tun modul může chybět nebo mít špatně nastavená práva. Některé obrazy CM9 potřebují povolené \"Opravit vlastnictví\" v nastavení.</p> <p>Nejdůležitější: Pokud má zařízení poškozený Android obraz, oznam to výrobci. Čím více lidí oznámí problém výrobci, tím větší je pravděpodobnost, že to opraví.</p> + Šifrovací klíč PKCS12 + Heslo k soukromému klíči + Heslo + ikona souboru + TLS autentikace + Vygenerované nastavení + Nastavení + Pokusit se nastavit vlastníka /dev/tun zařízení. Na některých systémech s CM9 je toto potřeba pro zprovoznění VPNService API. Vyžaduje root zařízení. + Opravit vlastnictví /dev/tun + Zobrazí vygenerované nastavení OpenVPN + Úprava \"%s\" + Vytvářím konfiguraci… + Zapnutím této volby bude vynuceno opětovné připojení, pokud se změní stav sítě (např. z WiFi na mobilní síť a zpět) + Opětovně připojit při změně sítě + Stav sítě: %s + CA certifikát je obvykle získán z Androidího úložiště. Zadej samostatný certifikát, pokud dostáváš chybu při verifikaci. + Vyber + Žádný CA certifikát nebyl získán z úložiště, autentikace pravděpodobně selže. + Zobrazit okno s logem při připojování. okno lze vždy otevřít z notifikace. + Zobrazit okno s logem + Spuštěno na %1$s (%2$s) %3$s, Android API %4$d + Chyba při podepisování klíčem %1$s: %2$s + VPN varování při připojování oznamující o možnosti přesměrování veškerého provozu je vynuceno systémem, aby se zabránilo zneužití VPNService API.\nNotifikace (symbol s klíčem) je také vynucena systémem, aby signalizovala odchozí VPN spojení. Na některých systémech přehrává notifikace i zvuk.\nAndroid zavedl tyto dialogy pro tvoji osobní bezpečnost a ujistil se, že nejdou obejít. (Někdu to bohužel zahrnuje i zvuk notifikace.) + Varování při připojení a zvuková notifikace + Českou lokalizaci zpracoval Jan Baier <baier.jan@gmail.com> + IP a DNS + Základní nastavení + Směrování + Skryté OpenVPN volby. Normálně nejsou nutné. + Pokročilé + ICS OpenVPN nastavení + Žádné DNS servery nejsou použity. Překlad jmen nemusí fungovat. Zvaž nastavení vlastních DNS serverů. Též dbej na to, že Android bude nadále používat nastavení proxy určené pro mobilní/Wi-Fi připojení, pokud nejsou nastaveny žádné servery DNS. + Nemohu přidat DNS server \"%1$s\", odmítnuto systémem: %2$s + Nelze nastavit IP adresu \"%1$s\", odmítnuto systémem: %2$s + <p>Získej fungující nastavení (otestované na tvém počítači nebo stažené od poskytovatele/zaměstnavatele).</p><p>Pokud je to jeden soubor bez extra pem/pks12 souborů, můžeš ho poslat emailem jako přílohu. Pokud je souborů více, ulož je na SD kartu.</p><p>Klepni na přilohu mailu/Použij ikonu adresáře v seznamu VPN pro import nastavení.</p><p>Pokud se zobrazí chyby o chybějících souborech, ulož je na SD kartu.</p><p>Pro přidání importované VPN do seznamu, klepni na symbol pro uložení.</p><p>Pro připojení k VPN klepni na její jméno.</p><p>Pokud se v logu objeví varování nebo chyby, pokus se jim porozumět a opravit nastavení.</p> + Rychlý start + pokus se nahrát jaderný modul tun.ko před pokusem o připojení. Vyžaduje rootnuté zařízení. + Nahrát tun modul + Importovat PKCS12 z konfigurace do Andoidího úložiště + Chyba při zjišťování nastavení proxy: %s + Používám proxy %1$s %2$d + Použít systémovou proxy + K připojení použít systémové nastavení pro HTTP/HTTPS. + K přispění můžeš využít <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">PayPal</a> + OpenVPN se opětovně připojí k VPN, pokud byla aktivní před vypnutím/restartem systému. Přečti si oddíl o varování před připojením než použiješ tuto možnost. + Znovu připoj po restartu + Ignorovat + Restartovat + Změna nastavení začne platit až po restartu VPN. Restartovat teď? + Nastavení změněno + Nemohu zjistit naposledy připojený profil k úpravě + Zdvojená notifikace + Pokud je Android pod velkým tlakem (na RAM paměť), aplikace a služby, které nejsou zrovna potřeba, jsou odstraněny z aktivní paměti. To ukončí odchozí VPN spojení. K zajištění, že OpenVPN spojení přežije, služba běží s vysokou prioritou. Aby mohla služba běžet s vysokou prioritou, musí zobrazit notifikaci. Notifikace s klíčem je vynucena systémem (jak je popsáno v jiném oddílu) a nepočítá se jako aplikační notifikace pro účely běhu s vysokou prioritou. + není definován VPN profil. + Použij ikonu <img src=\"ic_menu_add\"/> k přidání nové VPN + Použij ikonu <img src=\"ic_menu_archive\"/> k imporu existujícího (.ovpn nebo .conf) profilu z SD karty. + Ujisti se, že jsi si pročetl FAQ. Je zde nápověda pro rychlý start. + Nastavení směrování/rozhraní + Nevracej se ke spojení mimo VPN, zatímco se OpenVPN připojuje. + Trvalý tun + OpenVPN Log + Importovat OpenVPN nastavení + Spotřeba baterie + V testech se jako hlavní důvod vysoké spotřeby baterie ukázaly keepalive pakety. Většina OpenVPN serverů má v konfiguraci něco jako \'keepalive 10 60\', což znamená posílání paketů každých deset vteřin. <p> Tyto pakety jsou malé a neznamenají velký provoz, ale udržují mobilní síť aktivní a zvyšují spotřebu energie. (Viz také <a href=\"http://developer.android.com/training/efficient-downloads/efficient-network-access.html#RadioStateMachine\">The Radio State Machine | Android Developers</a>)<p> Toto nastavení nelze změnit na klientské straně. Jen administrátor OpenVPN může toto nastavení změnit. <p> Bohužel používání keepalive hodnot větších než 60 vteřin spolu s UDP může způsobovat problémy s některými NATy, které ukončují po krátkém čase spojení. Použití TCP s dlouhým keepalive funguje, ale má problém \"TCP přes TCP\" (Viz <a href=\"http://sites.inka.de/bigred/devel/tcp-tcp.html\">Proč je TCP přes TCP špatný nápad</a>) + Androidí funkce tetheringu (přes WiFi, USB, nebo Bluetooth) a VPService API (používané tímto programem) spolu nepracují. Více detailů viz <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\">problém #34</a> + VPN a tethering + Opakování připojení + Nastavení obnovení + Počet vteřin mezi pokusy o připojení. + Vteřin mezi připojeními + OpenVPN neočekávaně havarovalo. Zvaž možnost použití volby poslat Minidump z hlavního menu + Poslat Minidump vývojáři + Poslat ladící informace o poslední havárii vývojáři + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + Připojuji se + Čekání na odpověď serveru + Ověřuji autorizaci + Stahuji konfiguraci klienta + Nastavuji IP adresu + Přidávám trasy + Připojeno + Odpojit + Obnovuji připojení + Ukončuji + Neběží + Překlad názvů + Připojuji (TCP) + Přihlášení nebylo úspěšné + Čekání na použitelnou síť + ↓%2$s/s %1$s - ↑%4$s/s %3$s + Nepřipojeno + Připojování k VPN %s + Připojování k VPN %s + Některé verze Androidu 4.1 mají problém, pokud je ve jméně certifikátu obsažen jiný než alfanumerický znak (mezera, podtržítko, mínus). Zkus reimportovat certifikát bez speciálních znaků + Šifrovací algoritmus + Ověřování paketů + Zadej způsob ověřování paketů + Běží na %1$s (%2$s) %3$s, Android API %4$d, verze %5$s, %6$s + sestaveno od %s + ladící verze + oficiální verze + Zkopírovat do profilu + Havarijní výpis + Přidat + Odeslat konfigurační soubor + Kompletní DN + Tvá importovaná konfigurace používá ZASTARALÉ nastavení tls-remote, které používá jiný formát DN. + RDN (běžné jméno) + RDN prefix + tls-remote (ZASTARALÉ) + Můžeš pomoci s překladem, navštiv http://crowdin.net/project/ics-openvpn/invite + %1$s se pokouší o kontrolu %2$s + Pokračováním dáváš aplikaci oprávnění pro kompletní kontrolu OpenVPN a k zachytávání veškerého síťového provozu. Nepotvrzuj, pokud nevěříš aplikaci. V opačném případě riskuješ napadení nebezpečným softwarem + Věřím této aplikaci. + Žádné aplikaci není povoleno použít externí API + Povolené aplikace: %s + Vyčistit seznam povolených aplikací?\nSoučasný seznam povolených aplikací:\n\n%s + \"Pozastavit VPN, pokud je obrazovka vypnutá a za posledních 60 vteřin se přeneslo méně než 64 kB. Pokud je volba \"Trvalé TUN\" povolena, pozastavení VPN dostane zařízení do stavu BEZ konektivity. Bez \"Trvalé TUN\" možnosti nebude mít zařízení VPN připojení (ochranu). + Pozastavit VPN připojení při vypnutí obrazovky + Pozastavit připojení při vypnuté obrazovce: méně než %1$s za %2$s vteřin + Varování: \"Trvalý TUN\" není pro tuto VPN povolen. Provoz použije při vypnuté obrazovce normální internetové připojení. + Uložit heslo + Pozastavit VPN + Obnovit VPN + Pozastavení VPN vyžádáno uživatelem + VPN pozastaveno - vypnutá obrazovka + Hacky specifické pro zařízení + Nelze zobrazit informace o certifikátu + Chování aplikace + Chování VPN + Povolit změny VPN profilů + Hardwarové úložiště: + Ikona aplikace snažící se použít OpenVPN pro Android + "Počínaje Androidem 4.3, VPN konfirmace je chráněná proti \"překryvným aplikacím\". Výsledkem je dialog nereagující na dotyk. Pokud máš aplikaci používající překryv, může to způsobit toto chování. Pokud nalezneš škodlivou aplikaci, kontaktuj jejího autora. Tento problém ovlivňuje všechny VPN aplikace na Androidu 4.3 a vyšší. Viz také <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=185\">Problém 185<a> pro další detaily." + VPN potvrzovací dialog na Androidu 4.3 a vyšší + Případně mě můžete sponzorovat přes Play Store: + Díky za sponzorováni %s! + Log vyčištěn. + Ukázat heslo + Chyba přístupu ke KeyChain: %s + Krátký + ISO + Časové značky + Žádný + Nahrávání + Stahování + VPN stav + Zobrazit možnosti + Neošetřená výjimka: %1$s\n\n%2$s + %3$s: %1$s\n\n%2$s + Pokud máš rootnuté zařízení, můžeš nainstalovat <a href=\"http://xposed.info/\">Xposed framework</a> a <a href=\"http://repo.xposed.info/module/de.blinkt.vpndialogxposed\">VPN potvrzovací modul</a> na vlastní nebezpečí\" + Plné licence + Sítě přímo připojené na lokální interface nebudou směrovány skrze VPN. Odškrtnutím této volby bude přesměrován všechen lokální provoz do VPN. + Nepoužívat VPN pro lokální sítě + Soubor pro Jméno/Heslo + [Importováno z: %s] + Některé soubory nemohly být nalezeny. Prosím vyberte profil, který chcete importovat: + Import logu: + diff --git a/ics-openvpn-stripped/main/src/main/res/values-de/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-de/strings.xml new file mode 100755 index 00000000..ef9fb9d6 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-de/strings.xml @@ -0,0 +1,322 @@ + + + + + OpenVPN für Android + Server: + Server Port: + Ort + Verzeichnis kann nicht gelesen werden + Auswählen + Abbrechen + Keine Daten + LZO Komprimierung + Kein Zertifikat + Clientzertifikat + Clientzertifikatsschlüssel + PKCS12 Datei + CA Zertifikat + Kein Zertifikat ausgewählt + Quellcode und Issue Tracker sind verfügbar unter http://code.google.com/p/ics-openvpn/ + Dieses Programm nutzt die folgenden Komponenten. Die kompletten Lizenzdetails sind im Quelltext verfügbar. + Über + Profile + Typ + PKCS12 Passwort + Auswählen… + Nichts ausgewählt + Benutze TLS Authentifizierung + TLS Richtung + Tragen Sie die IPv6 Adresse und Netzmaske im CIDR Format ein (z.B. 2000:dd::23/64) + Tragen Sie die IPv4 Adresse und Netzmaske im CIDR Format ein (z.B. 1.2.3.4/24) + IPv4 Adresse + IPv6 Adresse + Tragen Sie eigene OpenVPN Optionen ein. Beachten Sie, dass einige (vor allem tun spezifische) Optionen von der Android Version nicht unterstützt werden können. Wenn Sie denken, dass eine wichtige Option fehlt, kontaktieren Sie den Autor + Benutzername + Passwort + Für die statische Konfiguration werden die TLS Auth Schlüssel als statische Schlüssel benutzt + VPN konfigurieren + Profil hinzufügen + Geben Sie einen Namen für das neue Profil an + Profilname bereits vorhanden. Bitte vergeben Sie einen eindeutigen Profilnamen. + Profilname + Kein Benutzerzertifikat ausgewählt + Kein Fehler. + Fehler in der Konfiguration + Fehler beim Auflösen der IPv4-Adresse + Kann die manuell angegeben Routen nicht parsen + (Leer lassen um nicht zu speichern) + OpenVPN Verknüpfung + VPN verbinden + Von der Verknüpfung referenziertes Profil konnte nicht gefunden werden + Random Host Präfix + Verwürfelt den Hostnamen mit zufälligen Präfix + Eigene Konfigurationsoptionen + Geben Sie eigene Konfigurationsoptionen an. Seien Sie vorsichtig! + Route von Android zurückgewiesen. + Trennen + VPN Verbindung trennen + Log löschen. + Trennungsbestätigung + Möchten Sie das VPN trennen bzw. den Verbindungsversuch abbrechen? + VPN löschen + Überprüfe, ob der Server ein Zertifikat mit TLS-Servererweiterungen verwendet (--remote-cert-tls server) + TLS-Serverzertifikat erwarten + Server Zertifikatssubjekt überprüfen + Zertifikat Namen überprüfen + Spezifizieren Sie die Methode mit welcher der DN des Serverzertifikates (z. B. C=DE, L=Paderborn, OU=Avian IP-Carrier, CN=openvpn.blinkt.de) überprüft wird.\n\nSie können den vollständigen DN oder den RDN (openvpn.blinkt.de im Beispiel) oder ein RDN-Präfix angeben.\n\nDer RDN Präfix \"Server\" erlaubt z.B. \"Server-1\" und \"Server-2\" \n\nWenn Sie das Eingabefeld leer lassen, wird der RDN gegen den Servernamen geprüft.\n\n Für weitere Details sehen Sie die Manpage von OpenVPN 2.3.1+ unter —verify-x509-name + Serverzertifikat Subject + Benutzte TLS Schlüssel Authentifizierung + TLS Auth Datei + Fordert IP Adressen, Routen und andere Optionen vom Server an. + Keine Informationen werden vom Server bezogen. Geben Sie manuell die Optionen an. + Pull Settings + DNS + Eigene DNS Server. + Eigene DNS Server benutzen. + DNS Such Domäne + Primärer DNS Server + DNS Server + Sekundärer DNS Server. Wird genutzt falls der normale DNS Server nicht erreicht werden kann + Backup DNS Server + Ignoriere gepushte Routen + Ignoriere die Routen, die der Server dem Client sendet. + Leitet allen Internet Verkehr über das VPN + Benutze Default Route + Benutze eigene Routen. Geben Sie Zielnetzwerk im CIDR Format an. Z.b. \"10.0.0.0/8 2002::/16\" würde die Netzwerke 10.0.0.0/8 und 2002::/16 über das VPN routen. + Netze, die nicht über das VPN weitergeleitet werden sollen. Nutzt die gleiche Syntax wie die eigenen Routen. + Eigene Routen + Ausgeschlossene Netze + Log Detail Level + Erlaube authentifizierte Pakete von jeder IP + Erlaube floating Server + Eigene Optionen + Ändere VPN Einstellungen + VPN Profile \'%s\' löschen? + Auf manchen ROM Version sind eventuell die Zugriffsrechte von /dev/tun falsch oder das tun Kernel Modul fehlt. Für Cyanogenmod 9 ROMs mit root gibt einen provisorischen Fix in den generellen Einstellungen. + Das Öffnen des tun Interfaces ist katastrophal gescheitert + "Fehler: " + Clear + Öffne tun Netzwerkinterface: + Lokale IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + DNS-Server: %1$s, Domäne: %2$s + Routen: %1$s %2$s + ausgeschlossene Routen: %1$s %2$s + Installierte Routen (VpnService): %1$s %2$s + Interface Information %1$s und %2$s, nehme an, die zweite Adresse ist die Peer Adresse. Benutze /32 Netzmaske für die lokale IP Adresse. Interface Modus spezifiziert von OpenVPN ist \"%3$s\". + Die Route %1$s mit der Netzmaske %2$s ist keine Route mit einer CIDR Netzmaske, benutze /32 als Netzmaske. + Route %1$s/%2$s korrigiert zu %3$s/%2$s + Kann nicht auf die Android Keychain Zertifikate zugreifen (dies kann durch ein System Update oder durch Zurücksichern der Anwendung aus einem Backup hervorgerufen werden). Bitte editieren Sie das VPN und wählen Sie erneut das Zertifikat in dem Grundeinstellungen aus, um die Zugriffsberechtigung für das Zertifikat wieder herzustellen. + %1$s %2$s + Sende Logdatei + Sende + ICS OpenVPN log Datei + Log Eintrag in die Zwischenablage kopiert + Tap Mode + Die VPN API von Android, die ohne rooten des Telefons funktioniert, unterstützt nur den tun Modus. Das Unterstützen des Tap Modus ist daher nicht möglich. + Die gleiche Frage nochmal? Meinen Sie das ernst? Ohne root kann tap wirklich nicht unterstützt werden. Emails an mich, mit der Frage, wann tap unterstützt wird, helfen hier kein Stück. + Ein drittes Mal? Nun gut, theoretisch kann tap mit einem tun Gerät emuliert werden. Dieser tap Emulator müsste die Layer 2 Informationen beim Senden hinzufügen und beim Empfangen wieder entfernen. Zusätzlich muss noch ARP und sinnvollerweise auch ein DHCP Client implementiert werden. Mir ist niemand bekannt, der etwas in dieser Richtung unternimmt. Kontaktieren Sie mich, falls Sie so etwas implementieren möchten. + FAQ + Kopieren von Log Einträgen + Um einen einzelnen Log Eintrag zu kopieren berühren Sie den Log Eintrag und halten Sie gedrückt. Um das ganze Log zu Kopieren/Versenden benutzen Sie die \"Sende Log\" Option. Falls Sie Option nicht im in der GUI sehen, drücken Sie die Menü Taste am Gerät. + Verknüpfung zu einem VPN + Sie können ein Shortcut zum Starten des VPN auf Ihren Startbildschirm ablegen. Abhängig von der verwendeten Benutzeroberfläche müssen Sie ein Widget, einen Shortcut oder eine Verknüpfung hinzufügen. + Dieses Android ROM enthält keine VPNService API. Sorry :( + Verschlüsselung + Geben Sie die Verschlüsslungsmethode an + Geben sie den Verschlüsslungsalgorithmus an, der von OpenVPN genutzt werden soll. Lassen sie das Feld frei, um den Standardalgorithmus zu verwenden. + Geben Sie den Hashalgorithmus der zur Nachrichtenauthentifizierung benutzt wird an. Leer lassen um den Standard Algorithmus zu nutzen. + Authentifizierung/Verschlüsselung + Datei auswählen… + Eingebettete Datei + Fehler beim importieren der Datei + Konnte Datei nicht vom Dateisystem importieren + [[Eingebettete Datei]] + Verweigere tun Gerät zu öffnen ohne IP Information + Importiere Profil von .ovpn Datei + Import + Konnte zu importierendes Profil nicht lesen + Fehler beim Lesen der Konfigurationsdatei + Profil hinzufügen + Konnte die Datei %1$s, die in der importierten Konfiguration angeben war, nicht finden + Importiere Konfigurationsdatei aus %1$s + Ihre Konfiguration hatte ein paar Konfigurationsoptionen, die nicht direkt mit der GUI konfigurierbar sind. Diese Optionen wurden als benutzerdefinierte Konfigurationsoptionen hinzugefügt. Dies sind: + Konfigurationsdatei lesen abgeschlossen. + Binde nicht an lokalen Port und IP Adresse + Kein lokales Binden + Importiere Konfigurationsdatei + Bemerkungen zur Sicherheit + Da OpenVPN sicherheitsrelevant ist, sind einige Worte zur Sicherheit der Anwendung angebracht. Alle Daten, die sich auf der SD Karte befinden sind als absolut unsicher anzusehen. Jede Anwendung kann diese lesen. (Diese Anwendung braucht zum Beispiel keine SD Karten Berechtigung). Die restlichen Konfiguration dieser Anwendung kann nur von der Anwendung selbst gelesen werden. Wenn die Option genutzt wird, dass die Zertifikate und Schlüssel eingebettet werden, werden diese im VPN Profil gespeichert. Die VPN Profile sind nur von der Anwendung selbst lesbar. (Vergessen Sie nicht die ursprünglichen Zertifikate/Schlüssel von der SD Karte zu löschen). Die Daten die Anwendung selbst speichert sind unverschlüsselt. Es besteht die Möglichkeit diese mittels \"rooten\" des Telefons/Tablets oder anderen Schwachstellend diese Daten auszulesen. Gespeicherte Passwörter werden auch im Klartext gespeichert. Es wird dringend empfohlen die Zertifikate in dem Android Keystore zu speichern.\" + Importieren + Fehler beim Anzeigen des Zertifikatsauswahlbildschirmes + Android hat einen Fehler beim Anzeigen des Zertifikat Dialog gemeldet. Dies sollte nie passieren, da dies ein Standard Feature von Android 4.0+ ist. Eventuell ist Unterstützung von Zertifikaten in Ihrer Firmware fehlerhaft + IPv4 + IPv6 + Warte auf OpenVPN Status Nachricht… + Importiertes Profil + Importiertes Profil %d + Fehlerhafte Images + <p>Von offiziellen HTC Firmwares ist bekannt, dass diese teilweise merkwürdige Routing Probleme haben, die dafür sorgen, dass der Verkehr nicht durch den Tunnel fließt. (Siehe auch <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=18\">Issue 18</a> im Bug Tracker.)</p><p>Bei älteren Version der offiziellen SONY Firmwares für das Xperia arc S and Xperia Ray scheint der VPNService Support komplett zu fehlen. (Siehe auch <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=29\">Issue 29</a> im Bug Tracker.)</p><p>Auf anderen (insbesondere Custom ROMS) fehlt teilweise das tun Kernel Modul oder die Rechte von /dev/tun sind falsch gesetzt. Auf einigen CM9 Firmware wird die \"/dev/tun Eigentümer setzen\" Option in den Allgemeinen Einstellungen benötigt.</p><p>Am wichtigsten ist aber, falls Sie eine fehlerhafte Firmware haben, melden Sie dies Ihrem Hersteller. Desto mehr Leute den Fehler dem Hersteller melden desto wahrscheinlicher werden Sie eine Fehlerkorrektur bekommen.</p> + PKCS12 Veschlüsslungspassword + Passphrase privater Schlüssel + Passwort + Datei Symbol + TLS Authentifizierung + Generierte Konfiguration + Einstellungen + Versucht den Eigentümer von /dev/tun auf system zu ändern. Einige Cyanogenmod 9 ROM Versionen benötigen diese Option, damit die VPN API funktioniert. Benötigt root. + /dev/tun Eigentümer setzen. + Zeigt die generierte Konfigurationsdatei + Editiere \"%s\" + Generiere OpenVPN Konfiguration… + Aktivieren dieser Option zwingt OpenVPN dazu, beim Wechsel des Netzwerkes (WLAN zu Mobilfunk und umgekehrt), neu zu verbinden + Netzwerkänderungen beachten + Netzwerkstatus: %s + Das CA Zertifikat wird meist aus dem Zertifikatsspeicher automatisch ausgewählt. Sollte dies nicht funktionieren und Sie Verifizierungsprobleme erhalten(self signed certificate), wählen Sie manuell ein Zertifikat aus. + Auswählen + Beim Abfragen des Android KeyStore wurde kein CA Zertifikat zurückgegeben. Überprüfen des Serverzertifikat wird wahrscheinlich fehlschlagen. Geben Sie manuell ein CA Zertifikat an. + Zeigt das Status Log, wenn ein VPN verbunden wird. Das Status log kann immer über die Benachrichtigung aufgerufen werden. + Zeige Log + Modell %1$s (%2$s) %3$s, Android API %4$d + Fehler beim Zugriff auf den Android Keystore %1$s: %2$s + Die Meldung, dass OpenVPN versucht eine VPN-Verbindung aufzubauen und dabei den gesamten Netzwerkverkehr abhören kann, wird vom Android System selbst erzeugt. Diese wird vom System erzwungen, damit keine Anwendung vom Benutzer unbemerkt eine VPN Verbindung aufbauen kann\Die VPN Benachrichtigung (Das Schlüssel Symbol) wird genauso vom Android System angezeigt um eine bestehende VPN anzuzeigen.\nDiese beiden Features wurden in Android für die Sicherheit des Nutzers implementiert und können nicht umgangen werden. (Auf machen Telefon/Tablets wird die Benachrichtigung leider mit einem Ton signalisiert.) + Warnung beim Verbinden und Benachrichtigungston + Deutsche Übersetzung von Arne Schwabe <arne@rfc2549.org> + IP und DNS + Grundeinstellungen + Routing + Obskure OpenVPN Einstellungen, die normalerweise nicht benötigt werden. + Erweitert + ICS OpenVPN Konfiguration + Es werden keine DNS Server für die VPN Verbindung genutzt. Die Namensauflösung wird möglicherweise nicht funktionieren. Ziehen Sie in Erwähung selbst DNS Server in den Optionen zu setzen. Beachten Sie weiterhin, dass Android die Proxyeinstellungen für Handy/WLAN weiterhin benutzt, falls keine DNS Server für das VPN festgelegt sind. + Konnte den DNS Server \"%1$s\" nicht hinzufügen, da das System ihn zurückweist mit %2$s + Konnte nicht die IP Adresse \"%1$s\" nicht setzen. Fehlermeldung des Systems: %2$s + <p>Benutzen Sie eine funktionierende Konfiguration (getestet auf einem Computer, oder von Ihrer Organisation/Ihrem Provider bereitgestellt)</p><p>Falls Sie nur eine einzelne Datei benötigen, können Sie sich diese als Email-Anhang zuschicken. Falls Ihre OpenVPN Konfiguration aus mehreren Dateien besteht, müssen Sie alle Dateien auf die SD Karte kopieren.</p><p>Klicken Sie auf den Email Anhang im Android Mail Programm bzw. benutzen Sie das Ordner Symbol in der VPN Liste und wählen Sie die .ovpn bzw. .conf Konfigurationsdatei aus.</p><p>Falls der Import fehlende Dateien anmerkt, kopieren Sie diese auf die SD Karte und starten den Import erneut.</p><p>Benutzen Sie anschließend das Speichern Symbol um das VPN zur VPN Liste hinzuzufügen</p><p>Tippen Sie den Namen des VPNs an, um das VPN zu starten</p><p>Achten Sie auf Fehler und Warnungen im Verbindungslog.</p> + Schnellstart + Versuche das tun.ko Kernel Modul zu laden. Benötigt root. + Lade tun Modul + Importiere die PKCS12 Datei, die in der Konfiguration angegeben ist, in den Android Keystore + Fehler beim Ermitteln der Proxy Einstellungen: %s + Benutzt Proxy %1$s %2$d + Benutze System Proxys + Benutze die System weiten Einstellungen für HTTP/HTTPS Proxys beim Verbinden. + <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">Spenden mit PayPal</a> + OpenVPN wird bei einem Neustart des Telefon das beim herunterfahren/neu starten aktive VPN wieder verbinden. Bitte lesen Sie die FAQ \"Warnung beim Verbinden\" FAQ bevor Sie diese Option verwenden. + Nach Neustart verbinden + Ignorieren + Neu verbinden + Konfigurationsänderungen werden erst nach einem VPN Neustart aktiv. Jetzt neu verbinden? + Konfiguration geändert + Konnte das zuletzt verbundene Profile beim Versuch des Editieren nicht ermitteln. + Doppelte Benachrichtigungen + Android beendet automatisch Anwendungen und Dienste, die im Hintergrund laufen, wenn der Arbeitsspeicher knapp wird. Wird dabei OpenVPN beendet, bricht die VPN Verbindung ab. Um dies zu vermeiden, läuft der VPN Prozess mit einer höheren Priorität. Um eine höhere Priorität nutzen zu können, muss die Anwesenheit des Prozesses dem Benutzer im Form einer Benachrichtigung mitgeteilt werden. Daher zeigt OpenVPN für Android immer seine eigene Benachrichtigung an. Die Schlüssel Benachrichtigung, die auch im letzten Eintrag erklärt wird, zählt leider nicht als Benachrichtigung, die der Anwendung erlaubt mit höherer Priorität zu arbeiten. + Keine VPN Profile definiert. + Benutzen Sie <img src=\"ic_menu_add\"/> um ein neues VPN anzulegen + Benutzen Sie <img src=\"ic_menu_archive\"/> um ein vorhandenes (.ovpn oder .conf) Profil von Ihrer SD Karte zu importieren + Lesen Sie auch die FAQ. Dort befindet sich eine Schnellstart Anleitung + Routing/Netzwerk Konfiguration + In dieser Anwendung wird die Routing und Netzwerkkonfiguration nicht mit den traditionellen ifconfig/route Kommandos konfiguriert sondern mittels der VPNService API. Diese erwartet eine Tunnel IP Adresse und die Netzwerke, die über den Tunnel geroutet werden sollen. Insbesondere wird keine Gateway oder Peer IP Adresse benötigt. Die Anwendung ignoriert diese daher auch beim Import. Dass die Verbindung zum VPN Server nicht über den Tunnel geroutet wird, wird auch über die VPNService API sichergestellt ohne dass hierfür spezielle Routen nötig sind. Da nur Netzwerke, die über den Tunnel geroutet werden sollen, angeben werden können, ist es nicht möglich andere Routen zu unterstützen. Die Anwendung versucht daher andere Routen (wie z.B. route x.x.x.x y.y.y.y net_gateway)\" die nicht über den Tunnel geroutet werden sollen zu erkken und eine Menge von Routen zu berechnen die das Verhalten auf anderen Plattformen emulieren. Das Verbindungslog zeigt die genaue Konfiguration und die errechneten Routen beim Verbinden an. + Verhindere Zurückfallen auf nicht VPN Verbindungen während OpenVPN neu verbindet. + Persistentes tun Device + OpenVPN-Log + OpenVPN Konfiguration importieren + Energieverbrauch + In meinen eigenen Tests ist der Hauptgrund für den hohen Stromverbrauch von OpenVPN das Senden und Empfangen der Keepalive-Pakete. Die meisten OpenVPN-Server haben eine Konfigurationsoption wie \'keepalive 10 60\', was bedeutet, dass vom Client an den Server und vom Server an den Client alle zehn Sekunden ein Paket geschickt wird. <p> Diese Pakete sind klein und erzeugen keine große Datenmenge. Sie sorgen allerdings dafür, dass permanent Daten übertragen werden und somit auch die Mobilfunk- bzw. WLAN Einheit aktiv ist und steigern damit den Energieverbrauch. (Siehe auch <a href=\"http://developer.android.com/training/efficient-downloads/efficient-network-access.html#RadioStateMachine\">The Radio State Machine | Android Developers</a>)<p> Diese keepalive Einstellung kann nicht auf dem Client geändert werden. Nur der Systemadministrator des VPN Servers kann die Einstellung ändern. lt;pgt; Leider hat eine keepalive Einstellung von mehr als 60 Sekunden unter udp Probleme mit einigen NAT-Gateways, die für inaktive Verbindungen nur eine sehr kurze Haltzeit haben und danach verwerfen (60s in meinen Tests). Benutzen von TCP mit langen Keep-Alive-Timeouts funktioniert, hat aber das TCP über TCP Problem. (Siehe <a href=\"http://sites.inka.de/bigred/devel/tcp-tcp.html\" > Why TCP Over TCP Is A Bad Idea </a>) + Die Funktion \"Anbindung & mobiler WLAN-Hotspot\" und die VPNService-API, die von diesem Programm verwendet wird, funktionieren nicht zusammen. Für weitere Details siehe <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\"> Issue #34 </a> + VPN und \"Anbindung & mobiler WLAN-Hotspot\" + Anzahl Verbindungsversuche + Einstellungen für das Neuverbinden + Anzahl von Sekunden zwischen Verbindungsversuchen. + Sekunden zwischen Verbindungsversuchen + Der OpenVPN Prozess ist unerwartet abgestürzt. Bitte erwägen Sie die Option \"Minidump senden\" im Hauptmenü + Minidump an Entwickler senden + Sendet Debugging Informationen des letzten Absturzes an den Entwickler + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + Verbinde + Warte auf Serverantwort + Authentifiziere + Warte auf Clientkonfiguration + Weise IP Adressen zu + Hinzufügen von Routen + Verbunden + Trennen + Wiederverbinden + Beende + Kein OpenVPN Prozess + Löse Hostnamen auf + Verbinde (TCP) + Authentifizierung fehlgeschlagen + Warte auf Internetverbindung + ↓%2$s/s %1$s - ↑%4$s/s %3$s + Nicht verbunden + Verbinde mit VPN %s + Verbinde mit VPN %s + Einige Versionen von Android 4.1 haben Probleme, wenn der Name des im Zertifikat Keystore gespeicherten Zertifikates nicht alphanumerische Zeichen (wie Leerzeichen, Unterstriche oder Bindestriche) enthält. Probieren Sie das Sie das Zertifikat mit einem Namen ohne Sonderzeichen zu importieren. + Verschlüsslungsalgorithmus + Packetauthentifizierung + Geben Sie den Authentifizierungsalgorithmus an + Modell %1$s (%2$s) %3$s, Android API %4$d, version %5$s, %6$s + compiliert von %s + Testversion + offizielle Version + Ins Profil einbetten + Crashlog + Hinzufügen + Konfigurationsdatei senden + Völlständiger DN + Ihre importierte Konfiguration verwendete die alte VERALTETE tls-remote-Option, die ein anderes DN-Format verwendet. + RDN (common name) + RDN Präfix + tls-remote (VERALTET) + Sie können helfen die Übersetzung zu verbessern auf der Website http://crowdin.net/project/ics-openvpn/invite + %1$s versucht %2$s zu steuern + Wenn Sie fortfahren, gestatten Sie der App OpenVPN für Android komplett zu kontrollieren und den gesamten Netzwerkverkehr abzufangen. Akzeptieren Sie nur, wenn Sie der App vertrauen. Anderenfalls riskieren Sie, dass Ihre Daten von schädlicher Software manipuliert werden + Ich vertraue dieser App. + Keine App für die Verwendung der API freigegeben + Freigegebene Apps: %s + Liste der freigegeben externen Apps löschen? \nAktuelle Liste der freigegebenen Apps:\n\n%s + Pausiert das VPN, wenn der Bildschirm aus ist und weniger als 64 kB in 60 Sekunden übertragen wurden. Falls die Option \"Persistentes tun Device\" ausgewählt wird durch das Pausieren des VPNs das Gerät KEINE Netzwerkverbindung haben. Ohne die \"Persistentes tun Device\" Option, benutzt das Gerät die normal (ungesicherte) Internetverbindung, wenn das VPN pausiert wird. + Bei ausgeschalteten Bildschirm VPN Verbindung pausieren + Pausiere VPN Verbindung da weniger als %1$s in %2$ss. + Warnung: Persistentes tun Device für dieses VPN nicht aktiviert. Der Netzwerkverkehr nutzt die normale Internet Verbindung, wenn der Bildschirm aus ist. + Passwort merken + VPN pausieren + VPN fortsetzen + VPN Verbindung durch Benutzer pausiert + VPN pausiert wegen Inaktitvität pausiert (Bildschirm aus) + Geräte spezifische Hacks + Kann Zertifikatsinformationen nicht anzeigen. + Anwendung + VPN + Änderungen an VPN-profilen zulassen + Im Hardware Keystore gespeichert: + Symbol der Anwendung, die versucht OpenVPN für Android zu kontrollieren + Beginnend mit Android 4.3 wird der VPN-Bestätigungsdialog vor \"überlappenden Anwendungen\" geschützt. Dadurch kann es vorkommen, dass der Dialog nicht auf Eingaben reagiert. Eine Anwendung benutzen, die Overlays verwendet, kann es dieses Verhalten verursachen. Sollten Sie die verursachende Anwendung finden, kontaktieren Sie dessen Author. Dieses Problem betrifft alle VPN-Anwendungen ab Android 4.3. Siehe auch <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=185\" > Issue 185 <a> für zusätzliche Details \" + VPN-Bestätigungsdialog ab Android 4.3 + Alternativ können Sie mir per Play Store Geld zukommen lassen: + Vielen Dank für die %s Spende! + Protokoll gelöscht. + Passwort anzeigen + KeyChain Zugriffsfehler: %s + Kurze + ISO + Zeitstempel + Keine + Hochgeladen + Heruntergeladen + VPN-Status + Ansichtsoptionen + Unbehandelte Ausnahme: %1$s\n\n%2$s + %3$s: %1$s\n\n%2$s + Wenn Sie ihr Gerät gerootet haben können Sie das <a href=\"http://xposed.info/\">Xposed Framework</a> und das <a href=\"http://repo.xposed.info/module/de.blinkt.vpndialogxposed\">VPN Dialog confirm Modul</a> auf eigene Gefahr installieren. + Komplette Lizenzen + Netze, die direkt über ein lokales Interfaces erreicht werden können werden nicht über das VPN gerottet. Deaktivieren dieser Option leitet allen Verkehr, der für lokale Netzwerke bestimmt ist, über das VPN. + VPN für lokale Netzwerke umgehen + Datei mit Benutzername und Passwort + [Importiert aus %s] + Einige Dateien konnten nicht gefunden werden. Bitte wählen Sie diese manuell aus: + Um diese Anwendung nutzen zu können brauchen Sie einen OpenVPN fähigen Server. Diese werden häufig von Ihrer Firma oder Universität bereitgestellt. Besuchen Sie http://community.openvpn.net/ um mehr über OpenVPN zu erfahren und wie Sie Ihren eigenen Server aufsetzen können. + Import-Protokoll: + diff --git a/ics-openvpn-stripped/main/src/main/res/values-es/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-es/strings.xml new file mode 100755 index 00000000..5ad33bbd --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-es/strings.xml @@ -0,0 +1,317 @@ + + + + + OpenVPN para Android + Dirección del servidor: + Puerto del servidor: + Ubicación + No se puede leer el directorio + Seleccionar + Cancelar + No hay datos + Compresión LZO + Sin Certificado + Certificado de Cliente + Llave del Certificado de Cliente + Archivo PKCS12 + Certificado de la CA + Debe seleccionar un certificado + Codigo fuente y sistema de reporte de errores disponibles en http://code.google.com/p/ics-openvpn/ + El programa utiliza los siguientes componentes. Vea los códigos fuentes para obtener más información sobre las licencias + Acerca de + Perfiles + Tipo + Contraseña PKCS12 + Seleccionar… + Debe seleccionar un archivo + Utilizar la autenticación TLS + Dirección TLS + Introduzca la dirección/máscara de red IPv6 en formato CIDR (por ejemplo, 2000:dd::23/64) + Introduzca la dirección/máscara de red IPv4 en formato CIDR (por ejemplo, 1.2.3.4/24) + Dirección IPv4 + Dirección IPv6 + Introduzca las opciones personalizadas de OpenVPN. Úselas con mucho cuidado. Además, tenga en cuenta que muchas de las configuraciones de OpenVPN relacionadas con tun no pueden ser soportadas por el diseño de VPNSettings. Si cree que falta una función importante, contacte al autor + Nombre de usuario + Contraseña + Para la configuración estática las claves de autenticación TLS se utilizaran como claves estáticas + Configurar la VPN + Agregar perfil + Escriba un nombre que identifica el nuevo perfil + Por favor, introduzca un nombre de perfil único + Nombre del Perfil + Debe seleccionar un certificado de usuario + No se encontraron errores + Error en la configuración + Error al analizar la dirección IPv4 + Error al analizar las rutas personalizadas + (Deje en blanco para consultar sobre demanda) + Acceso directo de OpenVPN + Conectar a VPN + Perfil especificado en el acceso directo no encontrado + Prefijo aleatorio de Host + Agrega 6 caracteres al azar delante del nombre de host + Habilitar opciones personalizadas + Especificar opciones personalizadas. ¡Use con cuidado! + Ruta rechazada por Android + Desconectar + Desconectar VPN + Limpiar registro + Cancelar confirmación + ¿Desconectar la conexión VPN/cancelar el intento de conexión? + Eliminar VPN + Comprueba si el servidor utiliza un certificado con las extensiones TLS de servidor (--remote-cert-tls server) + Espere certificado de servidor TLS + Checar el sujeto del DN del Certificado del Servidor Remoto + Comprobación del certificado de nombre de host + Especifica el chequeo usado para verificar el certificado remoto DN (ej. C=DE, L=Paderborn, OU=Avian IP Carriers, CN=openvpn.blinkt.de)\n\nEspecifica el DN completo o el RDN (openvpn.blinkt.de en el ejemplo) o un prefijo RDN para la verificación.\n\nCuando se usa un prefijo RDN como \"Server\" este coincide también con \"Server-1\" y \"Server-2\"\n\nDejando el campo de texto vacío verificara el RDN contra el nombre host del servidor.\n\nPara más detalles ve la página de manual (manpage) de OpenVPN 2.3.1+ en --verify-x509-name + Sujeto del Certificado Remoto + habilita la autenticación de clave TLS + Archivo de autenticación TLS + Obtener Direcciones IP, rutas y opciones de sincronizacion del servidor. + No se pedira informacion del servidor. Necesita especifiar la configuracion abajo. + Obtener Configuracion + DNS + Reemplazar la configuración DNS del Servidor + Usar sus propios servidores DNS + Dominio de busqueda + Servidor DNS a ser usado. + Servidor DNS + El servidor DNS secundario se utiliza si el servidor DNS normal falla. + Servidor DNS de respaldo + Ignorar rutas obtenidas + Ignorar rutas obtenidas del servidor. + Redirige todo el tráfico a través de VPN + Usar ruta predeterminada + Introduzca las rutas personalizadas. Sólo introduzca destinos en formato CIDR. \"10.0.0.0/8 2002:: / 16\" dirigiría las redes 10.0.0.0/8 y 2002::/16 sobre la VPN. + Rutas que NO deberían ser enrutadas a través de la VPN. Use la misma sintaxis que para las rutas incluidas. + Rutas personalizadas + Redes Excluidas + Nivel de detalle del registro + Permite paquetes autenticados desde cualquier IP + Permitir servidor flotante + Opciones personalizadas + Modificar la configuración de VPN + ¿Eliminar el perfil VPN %s? + En algunas ROMS personalizadas de ICS los permisos sobre /dev/tun podrían ser incorrectos, o el módulo tun podría faltar. Para imágenes de CM9 pruebe la opción \"arreglar la propiedad de /dev/tun\" ubicada en la configuración general + No se puede abrir interfaz tun + "Error: " + Limpiar + Abriendo interfaz tun: + Local IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + Servidor DNS : %1$s, Dominio: %2$s + Rutas: %1$s %2$s + Rutas excluidas: %1$s %2$s + Rutas instaladas por VpnService: %1$s %2$s + Información de la interfaz obtenida %1$s and %2$s, asumiendo que la segunda dirección es una dirección equivalente del remoto. Usando una máscara de red /32 para la IP local. El modo dado por OpenVPN es \"%3$s\". + No tienen sentido %1$s y %2$s como ruta IP con máscara de red CIDR, usando /32 como máscara de red. + Ruta conectada de %1$s/%2$s a %3$s/%2$s + No se puede acceder a los certificados de Android. Puede ser causado por una actualización de firmware o por restaurar una copia de seguridad de la aplicación/configuración de la aplicación. Por favor edite la VPN y vuelva a seleccionar el certificado bajo meltdownajustes básicos para recrear los permisos para acceder al certificado. + %1$s %2$s + Enviar el archivo de registro + Enviar + Archivo de registro de OpenVPN de ICS + Entrada de registro copiada al Portapapeles + Modo Tap + El Modo tap no es posible sin la API VPN de root. Por lo tanto la aplicacion no puede dar soporte a tap + ¿Otra vez? ¿Estás bromeando? No, el modo tap realmente no está soportado y enviar más correos preguntando si será soportado no ayudará. + ¿Una tercera vez? En realidad se podría escribir un emulador de tap basado en tun que podria agregar información layer2 al enviar y obtener información layer2 al recibir. Pero este emulador tap tendría que implementar también ARP y posiblemente un cliente DHCP. No sé de alguien que este realizando trabajo en esa dirección. Ponte en contacto conmigo si deseas iniciar la codificación de esto. + P+F + Copiar las entradas del registro + Para copiar una sola entrada de registro presione y mantenga pulsado sobre la entrada del registro. Para copiar y enviar el registro completo use la opción Enviar registro. Utilice el botón fisico de menú si no visible en la interfaz. + Acceso directo para iniciar + Puede colocar un acceso directo para iniciar OpenVPN desde el escritorio. Dependiendo del launcher tiene que añadir un acceso directo o un widget. + Su imagen no es compatible con la API de VPNService, lo siento :( + Cifrado + Especifique el método de cifrado + Proporcione el algoritmo de cifrado usado por OpenVPN. Deje en blanco para usar el cifrado de fábrica. + Introduce la autenticacion digest usada por OpenVPN. Deja en blanco para usar el digest predeterminado. + Autenticación/Cifrado + Administrador de archivos + Archivo en línea + Error al importar el archivo + No se pudo importar el archivo del sistema de archivos + [[Datos de archivo en línea]] + Negandose a abrir el dispositivo tun sin información de IP + Importar perfil de un archivo ovpn + Importar + No se pudo leer el perfil a importar + Error al leer el archivo de configuración + Agregar perfil + No se pudo encontrar el archivo %1$s mencionado en el archivo de configuracion importado + Importando archivo de configuración del origen %1$s + Su configuración tiene algunas opciones de configuración que no están establecidas en la interfaz de usuario . Estas opciones fueron agregadas como opciones de configuración personalizadas. A continuación se muestra la configuración personalizada: + Se termino de leer el archivo de configuración. + No enlazar con el puerto y la dirección local + Ningún enlace local + Importar archivo de configuracion + Consideraciones de seguridad + "Como OpenVPN es sensible a la seguridad, son razonables algunas notas acerca de seguridad. Todos los datos en la tarjeta SD son inherentemente inseguros. Cualquier aplicación puede leerla (por ejemplo, esta aplicación no requiere ningún permiso especial sobre la tarjeta SD). Los datos de esta aplicación sólo pueden ser leidos por la misma aplicación. Al utilizar la opción importar para el certificado de la CA/certificado/llave, en la ventana de diálogo para selección de archivos, los datos se almacenan en el perfil de la VPN. Los perfiles de VPN sólo son accesibles por esta aplicación. (No olvide después borrar las copias de la tarjeta SD). Aunque sólo sea accesible por esta aplicación, los datos aún están sin encriptar. Al acceder el dispositivo portátil como root u otro medio, es posible recuperar estos datos. Las contraseñas guardadas son almacenadas también en texto plano. Para archivos pkcs12 es muy recomendable que los importe al repositorio de llaves de Android." + Importar + Error mostrando la seleccion de certificados + Se obtuvo una excepción al intentar mostrar el diálogo de selección de certificado de Android 4.0+. Esto nunca debería ocurrir por ser una funcionalidad estándar de Android 4.0+. Quizás el respaldo ROM para almacenamiento de certificados de su Android está arruinado + IPv4 + IPv6 + Esperando el mensaje de estado… + perfil importado + perfil importado %d + Imágenes rotas + <p>Las imágenes oficiales de HTC son conocidas por tener un extraño problema de enrutamiento, causando que el tráfico no fluya a través del túnel (Ver también <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=18\">Issue 18</a> en el bug tracker.)</p><p> Han reportado que el VPNService hace falta completamente de las imagenes oficiales de SONY más viejas del XPeria Arc S y Xperia Ray. (Ver también <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=29\">Issue 29</a> en el bug tracker.)</p><p>Puede faltar el módulo tun o los permisos de /dev/tun/ pueden estar incorrectos. Algunas imágenes de CM9 necesitan habilitada la opcion \"Fix ownership\" option bajo \"Hacks específicos del dispositivo\".</p><p>De mayor importancia: Si tu dispositivo tiene una imágen corrupta de Android, reportalo a tu proveedor. Entre mayor gente reporte el problema al proveedor, mayores son las probabilidades de que lo reparen.</p> + Clave PKCS12 de cifrado de archivos + Contraseña de clave privada + Contraseña + icono de archivo + Autenticación TLS + Configuración generada + Preferencias + Intenta establecer el propietario de /dev/tun a system. Algunas imágenes de CM9 lo necesitan hacer funcionar la API de VPNService. Requiere permisos root. + Arreglar la propiedad de /dev/tun + Muestra el archivo de configuración OpenVPN generado + Editando \"%s\" + Construyendo configuracion… + Turning this option on will force a reconnect if the network state is changed (e.g. WiFi to/from mobile) + Reconectar en cambio de red + Estado de la red: %s + El certificado de la CA usualmente es recuperado del almacén de claves de Android. Especifique un certificado diferente si obtiene errores de verificación de certificado. + Seleccionar + No se obtuvo ningún certificado de CA al leer el almacén de claves de Android. La autenticación probablemente fallará. + Muestra la ventana de registro el conectarse. La ventana de registro siempre puede accederse desde el estado de la notificación. + Mostrar ventana de registro + Ejecutándose en %1$s (%2$s) %3$s, API de Android %4$d + Error al firmar con la llave del almacén de llaves de Android %1$s: %2$s + El aviso de conectividad VPN que esta aplicación puede interceptar todo el trafico esta impuesta por el sistema para evitar abusos de la API VPNService.\nLa notificación de conectividad (El símbolo de llave) también esta impuesta por el sistema Android para notificar una conexión VPN en curso. En algunas imágenes, esta notificación también emite un sonido.\nAndroid ha introducido estos diálogos de sistema para su seguridad e se ha asegurado que no pueden ser evitados. (En algunas imágenes, esto incluye la notificación sonora) + Advertencia de conexión y sonido de notificación + Traducción al español por José Luis Bandala Perez<luis.449bp@gmail.com> + IP y DNS + Básico + Enrutamiento + Configuraciones oscuras de OpenVPN. Normalmente no se necesitan. + Avanzado + Configuracion Openvpn de ICS + No hay servidores DNS a utilizar. La Resolución de nombres puede no funcionar. Considere configurar servidores DNS personalizados. Tenga en cuenta que Android sigue usando la configuración de proxy especificada para su conexión móvil/Wi-Fi cuando no hay servidores DNS establecidos. + No se puede agregar el servidor DNS \"%1$s\", rechazado por el sistema: %2$s + No se pudo configurar la dirección IP \"%1$s\", rechazada por el sistema: %2$s + <p>Obtén una configuración funcionando (probada en tu computadora o descargada de tu proveedor/organización)</p><p>Si es un solo archivo sin archivos pem/pks12 puedes enviar en un correo tu mismo el archivo y abrir el adjunto. Si tienes varios archivos ponlos en tu tarjeta SD.</p><p>Da clic en el adjunto de tu correo/Usa el icono de carpeta en la lista de VPN para importar el archivo de configuración </p><p>Si hay errores de archivos faltantes pon los archivos que faltan en tu tarjeta SD.</p><p>Da clic en el símbolo de guardar para agregar la VPN importada a tu lista de VPN</p><p>Conéctate a la VPN dando clic en el nombre de la VPN</p><p>Si hay errores o advertencias en el registro intenta comprender los errores/advertencias e intenta solucionarlos</p> + Inicio rápido + Intente cargar el módulo del kernel tun.ko antes de intentar conectarse. Necesita dispositivos rooteados. + Cargar modulo tun + Importar PKCS12 de la configuración en el almacén de claves de Android + Error al obtener la configuración de proxy: %s + Usando proxy %1$s %2$d + Usar el proxy del sistema + Utilice la configuración del sistema para los proxies HTTP/HTTPS a conectar. + Usted puede <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">donar con PayPal</a> + OpenVPN volvera a conectar a una VPN si estaba activa en el apagado/reinicio del sistema. Por favor lea la P+F de advertencia de conexión antes de usar esta opción. + Vuelva a conectar al reiniciar + Ignorar + Reiniciar + Los cambios de configuración se aplican después de reiniciar la VPN. ¿(Re)iniciar la VPN ahora? + Configuración cambiada + No se pudo determinar el último perfil conectado para editar + Notificaciones duplicadas + Si Android está bajo presión de memoria del sistema (RAM), las aplicaciones y servicios que no estén siendo usados en el momento son removidos de la memoria activa. Esto termina una conexión VPN en marcha. Para asegurarse que la conexión/OpenVPN sobreviva el servicio tiene que ejecutarse con prioridad alta. Para ejecutarse con prioridad alta la aplicación debe de mostrar una notificación. El icono de notificación de llave es impuesto por el sistema como se describió en la entrada de FAQ anterior. Esta con cuenta como notificación de la aplicación con el propósito de ejecutarse con prioridad alta. + No hay perfiles VPN definidos. + Use el icono <img src=\"ic_menu_add\"/> para agregar una nueva VPN + Use el icono <img src=\"ic_menu_archive\"/> para importar un perfil existente (.ovpn or .conf) de tu tarjeta. + Asegúrese de checar también las preguntas frecuentes. Hay una guía de inicio rápido. + Configuración de enrutamiento o interfaz + No regresar a modo sin conexión VPN cuando OpenVPN esta volviendose a conectar. + Tun persistente + Registro de OpenVPN + Importar configuración de OpenVPN + Consumo de batería + En mis pruebas personales, la mayor razón de el alto consumo de batería de OpenVPN son los paquetes keepalive. La mayoría de los servidores OpenVPN tienen una directiva de configuración como \'keepalive 10 60\' la cual causa que el cliente y el servidor intercambien paquetes cada diez segundos. <p> Mientras estos paquetes sean pequeños y no utilicen mucho tráfico, mantienen la red móvil de radio ocupada e incrementan el consumo de energía. (Ver también <a href=\"http://developer.android.com/training/efficient-downloads/efficient-network-access.html#RadioStateMachine\">The Radio State Machine | Android Developers</a>) <p> Dicha configuración keepalive no puede ser cambiada en el cliente. Solo el administrador de OpenVPN puede hacerlo. <p> Infortunadamente, usar un keepalive mayor a 60 segundos con UDP puede causar que algunas puertas de enlace NAT cierren la conexión debido a inactividad. Usar TCP con largos periodos de inactividad keepalive funciona, pero el tuneleo TCP sobre TCP resulta en conexiones extremadamente pobres con alta pérdida de paquetes. (Ver <a href=\"http://sites.inka.de/bigred/devel/tcp-tcp.html\">Why TCP Over TCP Is A Bad Idea</a>) + La funcionalidad de Tethering de Android (sobre WiFi, USB o Bluetooth) y la API del servicio de VPN (utilizada por esta aplicación) no pueden trabajar juntas. Para más detalles vea el <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\">problema #34</a> + VPN y Tethering + Reintentos de conexión + Configuración de reconexión + Número de segundos de espera entre intentos de conexión. + Segundos entre las conexiones + OpenVPN falló inesperadamente. Por favor considere usar la opción envío de minivolcado en el menú principal + Enviar minivolcado al desarrollador + Enviar información de depuración sobre último fallo al desarrollador + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + Conectando + Esperando respuesta del servidor + Autenticando + Obteniendo información del cliente + Asignando direcciones IP + Añadiendo rutas + Conectado + Desconectar + Reconectando + Saliendo + Proceso terminado + Resolviendo nombres de host + Conectando (TCP) + Fallo de autenticación + Esperando por una red que se pueda usar + ↓%2$s/s %1$s - ↑%4$s/s %3$s + No conectado + Conectando a VPN %s + Conectando a VPN %s + Algunas versiones de Android 4.1 experimentan problemas si el nombre del almacén de certificados contiene caracteres no alfanuméricos (como espacios, subrayados o barras). Intente volver a importar el certificado sin caracteres especiales + Algoritmo de encriptación + Autenticación de paquetes + Introduzca método de autenticación de paquetes + Corriendo sobre %1$s (%2$s) %3$s, API Android %4$d, versión %5$s, %6$s + compilado por %s + versión de depuración + versión oficial + Copiar en perfil + Volcado de fallo + Añadir + Enviar el archivo de configuración + DN Completo + La configuracion que importaste usa la opcion OBSOLETA tls-remote que usa un formato diferente para DN. + RDN (nombre comun) + Prefijo RDN + tls-remote (OBSOLETO) + Tu puedes ayudar traduciendo visitando http://crowdin.net/project/ics-openvpn/invite + %1$s intentos de controlar %2$s + Al proceder, le estás proporcionando permiso a la aplicación para controlar completamente OpenVPN for Android e interceptar todo el tráfico de la red.NO aceptar a menos que confíes en la aplicación. De otro modo, corres el riesgo de que tus datos se vean comprometidos por software malicioso.\" + Confío en esta aplicación. + La aplicación no permite usar API externo + Aplicaciones autorizadas: %s + ¿Borrar la lista de aplicaciones externas permitidas?\nLista de aplicaciones permitidas:\n\n%s + Pausa la VPN cuando la pantalla está apagada y se transfieren menos de 64 Kb de datos en 60 segundos. Cuando la opción \"TUN persistente\" está habilitada, pausar la VPN dejará tu dispositivo sin conexión a la red. Sin la opción \"TUN persistente\" el dispositivo carecerá de la conexión/protección de la VPN. + Pausar conexión de VPN cuando se apaga la pantalla + Conexión en pausa si el estado de la pantalla es apagado: menos de %1$s en %2$ss + Advertencia: TUN persistente no habilitado para esta VPN. El tráfico usará la conexión normal a Internet cuando la pantalla esté apagada. + Guardar contraseña + Pausar VPN + Reanudar VPN + VPN pausado por solicitud del usuario + VPN pausado - pantalla fuera + Hacks específicos del Dispositivo + No se puede mostrar la información del certificado + Comportamiento de la aplicación + Comportamiento de VPN + Permitir cambios a los perfiles VPN + Tecla Física: + Ícono de la aplicación intentando usar OpenVPN for Android + "Empezando con Android 4.3, la confirmación de VPN está protegida contra \"aplicaciones superpuestas\". Esto resulta en que la ventana de diálogo no reaccione a los toques de pantalla. Si tienes una aplicación que sea superpuesta, es lo que puede ocasionar este problema. Si encuentras una aplicación ofensiva, contactar al autor de la misma. Este problema afecta a todas las aplicaciones VPN en Android 4.3 y superior. Ver también <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=185\">Issue 185<a> para más detalles" + Ventana de diálogo de confirmación VPN en Android 4.3 y superior + Alternativamente usted puede enviar una donación con el Play Store: + Gracias por su donación %s! + Registro borrado. + Mostrar contraseña + Error de acceso al llavero: %s + Corto + ISO + Marcas de tiempo + Ninguno + Subir + Descargar + Estado de VPN + Opciones de visualización + Excepcion no controlada: %1$s\n\n%2$s + %3$s: %1$s\n\n%2$s + Si ha rooteado su dispositivo Android, puede instalar el <a href=\"http://xposed.info/\">framework Xposed</a> y añadir el <a href=\"http://repo.xposed.info/module/de.blinkt.vpndialogxposed\">módulo de confirmación de Diálogo VPN</a> bajo su propio riesgo\" + Licencias completas + Las redes conectadas directamente a los interfaces locales no serán enrutadas a través de la VPN. Al desmarcar esta opción, todo el tráfico previsto para las redes locales será redirigido a la VPN. + Evitar la VPN para las redes locales + Archivo de Usuario/Contraseña + diff --git a/ics-openvpn-stripped/main/src/main/res/values-et/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-et/strings.xml new file mode 100755 index 00000000..61f8556c --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-et/strings.xml @@ -0,0 +1,317 @@ + + + + + OpenVPN Androidile + Serveri aadress: + Serveri port: + Asukoht + Kataloog pole loetav + Vali + Tühista + Andmed puuduvad + LZO pakkimine + Puudub sertifikaat + Kliendisertifikaat + Kliendisertifikaadi võti + PKCS12 fail + CA sertifikaat + Peate valima sertifikaadi + Lähtetekst ja probleemihaldur asuvad veebilehel http://code.google.com/p/ics-openvpn/ + Programmis kasutatakse järgnevaid komponente. Detailse litsenseerimisinfo leiate lähtekoodist + Lähemalt + Profiilid + Tüüp + PKCS12 salasõna + Vali… + Valige fail + Kasuta TLS autentimist + TLS suund + Sisesta IPv6 Aadress/Võrgumask CIDR formaadis (nt. 2000:dd::23/64) + Sisesta IPv4 Aadress/Võrgumask CIDR formaadis (nt. 1.2.3.4/24) + IPv4 aadress + IPv6 aadress + Sisestage OpenVPN kohandatud valikud. Ettevaatlikkus ei tee paha. Palun samuti tähele panna et VPNSettings API ei toeta paljusid tun liidesega seotud OpenVPN seadistusi. Siiski, kui te leiate et mõni oluline seadistusvalik on puudu, siis kontakteeruge programmi autoriga + Kasutajanimi + Salasõna + Staatilise konfiguratsiooni puhul kasutatakse TLS Auth võtmeid staatiliste võtmetena + Konfigureeri VPN + Lisa profiil + Lisage uuele profiilile osutav nimi + Palun sisestage unikaalne profiilinimi + Profiili nimi + Peate valima kasutaja sertifikaadi + Vigu ei leitud + Konfiguratsiooni viga + Sisestatud IPv4 aadress ei allu süntaksianalüüsile + Kohandatud marsruudid ei allu süntaksianalüüsile + (jäta tühjaks, küsitakse vajadusel) + OpenVPN kiirkäivitus + Ühendu VPN\'iga + Lühivalikus määratud profiil puudub + Juhuslik serveri eesliide + Lisab 6 juhuslikku tähte serveri nime ette + Luba kohandatud valikud + Määrake kohandatud valikud. Kasutage ettevaatlikult! + Androidi poolt keelatud ruutingud + Katkesta ühendus + Katkesta VPN + Tühjenda logi + Loobu kinnitusest + Katkesta VPN ühendus/tühista ühendumise katse? + Eemalda VPN + Kontrollitakse, kas server kasutab sertifikaati koos TLS Server laiendustega (--remote-cert-tls server) + Oodata TLS serveri sertifikaati + Kontrollib eemalasuva serveri sertifikaadi subjekti DN\'i + Sertifikaadi domeeninime kontroll + Määrake meetod millega kontrollida eemalasuva sertifikaadi DN (n.: C=DE, L=Paderborn, OU=Avian IP Carriers, CN=openvpn.blinkt.de)\n\nMäärata saab kas täieliku DN, RDN (openvpn.blinkt.de eelmises näites) või eesliitega RDN kontrolli.\n\nRDN eesliite kasutamisel vastab sellele nii \"Server\", \"Server-1\" kui ka \"Server-2\"\n\nTekstivälja tühjaks jätmisel kontrollitakse kas RDN on vastavuses serveri nimega.\n\nDetailsema info leiate OpenVPN 2.3.1+ käsiraamatust —kinnita-x509-nimi all + Eemalasuva sertifikaadi subjekt + Lubab TLS võtmega autentimise + TLS Auth fail + Küsib serverist IP aadresse, marsruute ja ajastusvalikuid. + Andmeid ei küsita serverist. Seadistused tuleb määrata allpool. + Sikuta seadistused + DNS + Eira serveri pakutavaid DNS seadeid + Kasuta oma DNS servereid + otsinguDomeen + Kasutatav DNS server. + DNS server + Sekundaarne DNS server mida kasutatakse kui vaikimisi DNS server on kättesaamatu. + VaruDNS server + Ignoreeri serveri pakutavaid marsruute + Ignoreeri serveri \'push\' direktiivi ruutinguid. + Suuna kogu võrguliiklus VPN kaudu + Kasuta vaikeruutingut + Sisesta oma personaalsed ruutingud. Sihtkoht peab olema CIDR formaadis. \"10.0.0.0/8 2002::/16\" suunab võrgud 10.0.0.0/8 ja 2002::/16 VPN kaudu. + Marsruudid mida EI TOHI suunata üle VPN\'i. Kasuta sama süntaksit kui kaasatud marsruutide jaoks. + Marsruutide kohandamine + Välistatud võrgud + Logimise detailsus + Suvalise IP autenditud paketid on lubatud + Luba \'ujuv\' server + Kohandatud valikud + Muuda VPN seadistusi + Kas eemaldada VPN profiil \'%s\'? + Mõnel modifitseeritud ICS versioonil võivad /dev/tun õigused olla valed, või selle moodul sootuks puududa. CM9 puhul võib probleemi lahendada üldiste seadistuste alt omanikuõiguste parandamine + Tun liidese avamine ebaõnnestus + "Viga:" + Tühjenda + tun liidese avamine: + Lokaalne IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + DNS server: %1$s, Domeen: %2$s + Marsruudid: %1$s %2$s + Välistatud marsruudid: %1$s %2$s + Määratud VpnService marsruudid: %1$s %2$s + Liidese andmed on %1$s ja %2$s, eeldades et teine aadress on eemalasuva serveri aadress. Lokaalse IP jaoks kasutatakse /32 võrgumaski. OpenVPN teatab režiimiks %3$s\". + %1$s ja %2$s on mõttetud CIDR võrgumaskiga IP marsruutidest, võrgumaskiks määratakse /32. + %1$s/%2$s marsruut parandatud: %3$s/%2$s + Androidi Keychain sertifikaadid on kättesaamatud. See võib olla põhjustatud püsivara uuendamisest või appide/apiseadistuste taastamisest. Sertifikaatide pääsuõiguste taastamiseks redigeerige palun VPN seadistusi ja valige uuesti üldiste seadistuste alt sertifikaat. + %1$s %2$s + Saada logifail + Saada + ICS OpenVPN logifail + Logikirje kopeeriti lõikepuhvrisse + Tap liides + VPNService API ei toeta tap liidest. Seega ei ole ruutimata seadmel selle programmiga tap liidese kasutamine võimalik + Jälle? Kas teete nalja? Tap režiim pole tõepoolest toetatud ja selle lunimine e-kirjade vahendusel ei anna tulemusi. + Ja juba kolmas kord? Noh, kui päris aus olla, siis tun liidesel töötava tap emulaatori kirjutamine, mis lisaks saatmisel layer2 informatsiooni ja eemaldaks selle taas vastuvõtmisel, on muidugi võimalik. Aga see emulaator peaks sisaldama ka ARP ja DHCP klienti. Mul ei ole andmeid et keegi selle kallal töötaks. Aga kui soovite selle töö ette võtta, siis kontakteeruge palun minuga. + KKK + Logikirjete kopeerimine + Ühe logikirje kopeerimiseks vajuta ja hoia sellel kirjel. Kogu logi kopeerimiseks/saatmiseks kasuta Saada Logi valikut. Kui see valik puudub GUI all, siis kasuta riistvaralist menüünuppu. + Kiirkäivitus + Saate paigaldada seadme töölauale OpenVPN kiirkäivituse. Selleks tuleb sõltuvalt teie seadme ekraanihalduri programmist kasutada kas kiirkäivitusikooni või vidinat. + Teie süsteemitarkvara ei toeta VPNService API\'t, vabandame :( + Krüpteerimine + Vali krüpteerimismeetod + Sisestage OpenVPN poolt kasutatav krüptošifri algoritm. Tühi väli tähendab vaikešifrit. + Sisestage OpenVPN poolt kasutatav autentimise räsifunktsioon. Tühi väli tähendab vaikeräsi. + Autentimine/Krüpteerimine + Failihaldur + Integreeritud fail + Viga faili importimisel + Faili importimine failisüsteemist ebaõnnestus + [[tekstisisene faili info]] + IP andmeteta keeldutakse tun liidese avamisest + Impordi profiil ovpn failist + Impordi + Imporditava faili lugemine ebaõnnestus + Viga konfiguratsioonifaili lugemisel + lisa profiil + Ei õnnestunud leida imporditavas konfiguratsioonifailis mainitud faili: %1$s + Allikast %1$s imporditakse konfiguratsioonifaili + Teie konfiguratsioon sisaldas seadistusi mida ei saa liigitada ühegi graafilise kasutajaliidese poolt pakutava seadistuse alla. Need valikud lisati kui kohandatud seadistusvalikud. Kohandatud konfiguratsiooni kuvatakse allpool: + Konfiguratsioonifail loetud. + Ära seo lokaalse aadressi ja pordiga + Lokaalne sidumine puudub + Impordi konfiguratsioonifail + Turvakaalutlused + "Kuna OpenVPN puhul on turvalisus oluline siis on õigustatud mõned märkused. Kõik sdcard seadmel asuvad andmed on iseenesest ebaturvalised kuna suvaline programm saab neid lugeda (näiteks käesolev programm ei vaja spetsiifilisi sd card õiguseid). Samas, kindla programmi andmed on loetavad ainult sellesama programmi poolt. Kui importida cacert/cert/key andmed faili dialoogi abil, siis salvestatakse need andmed VPN profiili mis on loetav ainult käesoleva programmi poolt. (Pärast andmete importimist ära unusta kustutada koopiad sd kaardilt). Ehkki profiili andmed on loetavad ainult käesoleva programmi poolt, on nad siiski krüpteerimata ja ruuditud seade või mõni exploit võimaldab neid sellegipoolest lugeda. Sealhulgas ei ole krüptitud ka salvestatud paroolid. Pkcs12 failide puhul on tungivalt soovitatav nende importimine android keystore\'sse." + Impordi + Viga sertifikaadivaliku näitamisel + Android 4.0+ sertifikaadivaliku dialoogi näitamise katsel tekkis erandolukord. Seda ei tohiks kunagi juhtuda kuna tegu on Android 4.0+ standardfunktsiooniga. Ehk on teie Androidi sertifikaadihoidla ROM tugi riknenud + IPv4 + IPv6 + Ootan olekuteadet… + imporditud profiil + imporditud profiil %d + Probleemsed Androidi püsivara versioonid + <p>Ametlikel HTC versioonidel teatakse olevat kummaline marsruutimisprobleem, mille tulemusel ei liigu andmevoog läbi tunneli (Vaata ka <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=18\">Issue 18</a> veahalduses.)</p><p>Ametlike vanemate SONY Xperia arc S ja Xperia Ray versioonide puhul on raporteeritud ka täielikku VPNService API puudumist. (Vaata ka <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=29\">Issue 29</a> veahalduses.)</p><p>Kohandatud tarkvaraversioonides võib puududa tun moodul või /dev/tun õigused võivad olla valed. Mõned CM9 versioonid nõuavad \"seadmespetsiifiliste häkkide\" alt \"õiguste parandamise\" valiku kasutamist.</p><p>Aga mis kõige olulisem: kui teil juhtub olema vigane tarkvaraversioon, siis teatage sellest oma tarnijale. Mida rohkem kliente tarnijat seadme probleemidest teavitab, seda suurema tõenäosusega tehakse seadme tarkvara ka korda.</p> + PKCS12 faili krüpteerimisvõti + Privaatse võtme salasõna + Salasõna + faili ikoon + TLS autentimine + Genereeritud konfiguratsioon + Seaded + Püütakse seada /dev/tun omanikku system\'iks. VPNService API nõuab seda mõne CM9 versiooni puhul. Seade peab olema ruuditud. + Korrasta /dev/tun omanikuõigused + Näitab genereeritud OpenVPN konfiguratsioonifaili + Redigeeritakse \"%s\" + Koostatakse konfiguratsiooni… + Selle valiku aktiveerimine kutsub esile VPN uuestiühendumise kui võrgu olek muutub (nt. WIFI peale/pealt mobiilile) + Uuestiühendus võrgu oleku muutumisel + Võrgu olek: %s + CA sertifikaat saadakse tavaliselt Androidi võtmehoidlast. Kui sertifikaadi kontrollimisel esineb probleeme, siis määrake palun sertifikaat ise. + Vali + Androidi võtmehoidlast lugemine ei andnud ühtegi CA sertifikaati. Suure tõenäosusega autentimine ebaõnnestub. + Näitab ühendumisel logiakent. Logiakna saab alati ette manada VPN teatisealast. + Näita logiakent + Töötamas %1$s (%2$s) %3$s peal, Android API %4$d + Viga allkirjastamisel Androidi võtmehoidla võtmega %1$s: %2$s + VPN ühendumisel ilmub ekraanile hoiatus et see programm võib pealt kuulata kogu võrguliiklust. Tegemist on VPNService API süsteemse hoiatusega et hoida ära väärkasutust.\nVPN ühenduse teatis (Võtme sümbol) on samuti VPNService API poolt kuvatav aktiivse VPN ühenduse indikaator. Mõne süsteemitarkvara puhul võib see indikaator anda märku ka heliga.\nNeed teatised on Androidi süsteemile lisatud teie turvalisuse tagamiseks ja samuti on välistatud nende kasutamisest mööda minemine. (Kahjuks tähendab see seda et mõne süsteemitarkvara puhul kaasneb ühendusega alati ka heliteade) + Hoiatused ja helimärguanded ühenduse loomisel + Eesti keelde tõlkis Robert Tiismus + IP ja DNS + Põhilised seaded + Marsruutimine + Harvaesinevad OpenVPN seaded. Tavaliselt ebavajalikud. + Põhjalikum + ICS OpenVPN konfiguratsioon + Kasutuses pole ühtegi DNS serverit. Nimelahendus ei pruugi töötada. Kaaluge kohandatud DNS serverite konfiguratsiooni. Pange tähele et DNS seadete puudumisel jätkab Android teie mobiilse/Wi-Fi proxy seadete kasutamist. + DNS serveri \"%1$s\" lisamine ebaõnnestus, süsteemi poolt keelduti: %2$s + IP aadressi \"%1$s\" seadistamine ei õnnestunud, süsteemi poolt välja praagitud: %2$s + <p>Hankige töötav konfiguratsioon (kas arvutis järele proovitud või alla laetud võrguteenusepakkuja/organisatsiooni veebilehelt)</p><p>Kui tegu on ainult ühe failiga millega ei kaasne pem/pkcs12 faile, siis saad selle saata e-kirjas manusena iseendale. Kui faile on mitu, saab need kopeerida sdcard peale.</p><p>Kliki saabunud e-kirja manusele ja kasuta konfiguratsiooni importimiseks vpn kaustaikooni.</p><p>Kui siiski esineb puuduvatele failidele viitavaid vigu, siis kopeeri puuduvad failid sdcard peale.</p><p>Imporditud VPN lisamiseks ühenduste nimekirjale, klikkige salvestussümbolile.</p><p>VPN ühenduse loomiseks kliki loodud VPN ühenduse nimele.</p><p>Ekraanil nähtav logi lihtsustab esineda võivate probleemide/vigade lahendamist.</p> + Kasutamise lühijuhend + Proovi enne ühendumist laadida tun.ko tuumamoodul. Nõuab ruuditud seadet. + Laadi tun moodul + Lae PKCS12 OpenVPN konfiguratsioonist Androidi võtmehoidlasse + Viga proxy seadistuste vastuvõtul: %s + Kasutusel proxy %1$s %2$d + Kasuta süsteemset proxy\'t + Kasuta ühendumisel süsteemse HTTP/HTTPS proxy konfiguratsiooni. + Sul on võimalus <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">annetada PayPal vahendusel</a> + Kui VPN oli süsteemi uuestilaadimisel/sulgemisel aktiivne siis taastatakse seadme käivitamisel OpenVPN ühendus. Palun lugege enne selle valiku kasutamist läbi ühendumise hoiatuse KKK. + Uuestilaadimisel ühendu uuesti + Ignoreeri + Uuestilaadimine + Konfiguratsioonimuudatused rakendatakse peale VPN uuestilaadimist. Kas soovite VPN kohe (uuesti)laadida? + Konfiguratsiooni muudeti + Viimast kasutatud profiili pole redigeerimiseks võimalik tuvastada + Mitu teatisikooni + Kui Androidi süsteemimälu (RAM) on täitumas, siis eemaldatakse aktiivsest kasutusest hetkel ebavajalikud programmid ja teenused. Sellega võib kaasneda muu hulgas ka VPN ühenduse katkemine. Katkestuste välistamiseks töötab OpenVPN teenus kõrgendatud prioriteediga. Kuid prioriteeti tõstmisel kuvab Androidi süsteem sellekohane teavitusikooni. Võtme ikooniga teavitus on määratud VPNService API poolt, millest oli juttu ka eelmises KKK lõigus ja see ei lähe arvesse programmi kõrgendatud prioriteedist teatava ikoonina. + VPN profiile pole defineeritud. + Kasuta uue VPN lisamiseks <img src=\"ic_menu_add\"/> ikooni + Kasuta olemasoleva (.ovpn või .conf) profiili importimiseks sdcard pealt <img src=\"ic_menu_archive\"/> ikooni. + Kindlasti vaata KKK\'d. See sisaldab ka alustamise lühijuhendit. + Marsruutimine ja võrguliidese konfigureerimine + Ära taasta otseühendust kui OpenVPN on taasühendumas. + Katkematu tun + OpenVPN Logi + Impordi OpenVPN konfiguratsioon + Akukasutus + Minu isiklike testide põhjal kulutavad akut peamiselt OpenVPN ülalhoide (keepalive) paketid. Enamik OpenVPN serverieid kasutab sarnast direktiivi nagu \'keepalive 10 60\' mis määrab kliendilt serverile ja serverilt kliendile saadetavate keepalive pakettide intervalliks 10 sekundit. <p> Ehkki ülalhoidepaketid on väikesed ja ei põhjusta märgatavat võrguliiklust, ei lase nad mobiilse ühenduse raadiovõrgukiibil lülituda energiasäästurežiimi. (Vaata ka <a href=\"http://developer.android.com/training/efficient-downloads/efficient-network-access.html#RadioStateMachine\">The Radio State Machine | Android Developers</a>) <p> Nimetatud ülalhoidepaketi seadistused ei ole kliendi poolt muudetavad ja neid seadistusi saab muuta ainult OpenVPN serveri süsteemiadministraator. <p> Kahjuks esineb üle 60 sekundi pikkuse keepalive puhul probleeme UDP protokolliga üle mõnede NAT võrguväratite ühenduse aegumise tõttu. TCP protokolliga seda probleemi ei esine, kuid TCP üle TCP tunnel töötab üüratult viletsasti üle kõrge paketikaoga linkide. (Vaata <a href=\"http://sites.inka.de/bigred/devel/tcp-tcp.html\">Miks TCP üle TCP on halb mõte</a>) + Android Tethering (üle WiFi, USB või Bluetoothi) ja VPNService API (mida käesolev programm kasutab) ei ole koos kasutatavad. Täpsemad detailid leiad <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\">issue #34</a> + VPN ja tether + Ühendumise korduskatseid + Taasühendusseaded + Mitu sekundit oodata ühendumiskatsete vahel. + Sekundeid ühenduste vahel + OpenVPN jooksis ootamatult kokku. Palun kaaluge \"saada Minitõmmis\" valiku lubamist peamenüüs + Saada arendajale minitõmmis + Saada eelmise kokkujooksmise kohta käiv silumisinfo arendajale + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + Ühendumine + Serveri vastuse ootamine + Autentimine + Kliendikonfiguratsiooni lugemine + IP-aadressite omistamine + Marsruutide lisamine + Ühendatud + Katkesta ühendus + Taasühendumine + Väljumine + Ei tööta + Arvutinimede lahendamine + Ühendumine (TCP) + Autentimine ebaõnnestus + Oodatakse kasutatavat võrku + ↓%2$s/s %1$s - ↑%4$s/s %3$s + Pole ühendatud + Ühendumine VPN %s külge + Ühendumine VPN %s külge + Mõnede Android 4.1 versioonide puhul esineb probleeme kui võtmehoidla sertifikaadi nimi sisaldab mittetähestikulisi sümboleid (nagu tühikud, alakriipsud või sidekriipsud). Proovige selline sertifikaat erisümboliteid kasutamata uuesti importida + Krüptošiffer + Pakettide autentimine + Sisestage pakettide autentimismeetod + Töötab seadmel %1$s (%2$s) %3$s, Android API %4$d, versioon %5$s, %6$s + Kompileerija: %s + Silumisversioon + Ametlik versioon + Kopeeri profiili + Pangestustõmmis + Lisa + Saada konfiguratsioonifail + Täielik DN + Teie imporditud konfiguratsioon kasutab vana ja TAUNITAVAT tls-remote valikut mis kasutab erinevat DN kuju. + RDN (ühine nimi) + RDN eesliide + tls-remote (TAUNITAV) + Tõlkimisel saate abi pakkuda külastades veebilehte http://crowdin.net/project/ics-openvpn/invite + %1$s katset et juhtida %2$s + Jätkates annate sellele programmile täieliku kontrolli üle Androidi OpenVPN-i ja samuti õiguse jälgida kogu võrguliiklust. Kui te ei usalda seda programmi, siis ÄRGE NÕUSTUGE. Vastasel juhul seate oma andmed pahatahtliku tarkvara poolt ohtu.\" + Ma usaldan seda programmi. + Ühelgi programmil pole luba kasutada välist API-t + Lubatud programmid: %s + Kas tühjenda lubatud väliste programmide nimekiri?\nKehtiv lubatud programmide nimekiri:\n\n%s + \"Peata VPN kui ekraan on välja lülitatud ja viimase 60s jooksul on üle kantud alla 64kB anmeid. Kui \"Katkematu Tun\" valik on sees, siis jätab VPN peatamine teie seadme ilma võrguühenduseta. \"Katkematu Tun\" valikuta ei ole aga seadmel VPN ühendust/kaitset. + Peata VPN ühendus peale ekraani välja lülitamist + Ühenduse peatamine väljalülitatud ekraani korral: vähem kui %1$s %2$ss jooksul + Hoiatus: Katkematu tun ei ole sellel seadmel sisse lülitatud. Andmed liiguvad ekraani välja lülitamisel tavalise Internetiühenduse kaudu. + Salvesta parool + Peata VPN + Jätka VPN + Kasutaja nõudis VPN peatamist + VPN peatatud - ekraan väljas + Seadmespetsiifilised häkid + Sertifikaadiinfo kuvamine ei õnnestu + Rakenduse käitumine + VPN käitumine + Luba muudatused VPN profiilides + Riistvaraline võtmehoidla: + \'OpenVPN Androidile\' üritatakse kasutada programmi ikooni poolt + "Alates Android 4.3 versioonist kaitstakse VPN kinnitust \"kattuvate programmide\" eest. Selle tulemusena ei reageeri dialoog puutesisendile. Võite sattuda sellisele probleemile kui teil on programm, mis kasutab kattumist. Leides sellise häiriva programmi, teavitage sellest programmi autorit. Nimetatud probleem mõjutab kõiki VPN programme alates Android 4.3 versioonist. Lisadetailid: <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=185\"> teema 185</a>" + Android 4.3 (ja hilisemate) VPN kinnitusdialoog + Võite saata mulle annetusena raha ka Play Store kaudu: + Aitäh annetatud %s eest! + Logi tühjendatud. + Näita salasõna + Viga KeyChain poole pöördumisel: %s + Lühike + ISO + Ajatemplid + Ükski + Üleslaadimine + Allalaadimine + Vpn olek + Kuva valikud + Käsitlematu erand: %1$s\n\n%2$s + %3$s: %1$s\n\n%2$s + Kui olete ome Androidiseadme ruutinud, saate paigaldada omal riisikol <a href=\"http://xposed.info/\">Xposed framework</a> ja <a href=\"http://repo.xposed.info/module/de.blinkt.vpndialogxposed\">VPN Dialoogi kinnitusmooduli</a>\" + Kõik litsentsid + Kohaliku liidese külge ühendatud võrkude ühendusi ei suunata üle VPN\'i. Selle valiku keelamisel suunatakse ka kohaliku võrgu andmeliiklus VPN\'i. + Keela VPN kohalike võrkude jaoks + Kasutajanimede/Paroolide fail + diff --git a/ics-openvpn-stripped/main/src/main/res/values-fr/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-fr/strings.xml new file mode 100755 index 00000000..140ac977 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-fr/strings.xml @@ -0,0 +1,318 @@ + + + + + "OpenVPN pour Android" + "Adresse du serveur:" + "Port du serveur:" + "Emplacement" + "Le dossier ne peut être lu !" + "Sélectionner" + "Annuler" + "Aucune donnée" + "Compression LZO" + "Aucun certificat" + "Certificat client" + "Clé du certificat client" + "Fichier PKCS12" + "Certificat CA" + "Vous devez sélectionner un certificat" + "Le code source et le tracker de bugs est disponible ici: http://code.google.com/p/ics-openvpn/ " + "Le programme utilise les composants suivants. Voir le code source pour plus de détails sur les licences." + "À propos" + Profils + "Type" + "Mot de passe PKCS12" + "Sélectionner…" + Vous devez sélectionner un fichier + "Utiliser l\'authentification TLS" + "Direction de l\'authentification TLS" + "Entrez l\'adresse IPv6 / masque de réseau au format CIDR (ex.: 2000:jj::23/64)" + "Saisissez l\'adresse IPv4 / masque de réseau au format CIDR (ex.: 1.2.3.4/24)" + "Adresse IPv4" + "Adresse IPv6" + "Entrez les options d\'OpenVPN personnalisés. A manipuler avec le plus grand soin. A noter également que de nombreux paramètres Tun d\'OpenVPN ne sont pas pris en charge à cause de la conception de \"VPNSettings\". Si vous pensez qu\'une option importante manque, veuillez contacter l\'auteur" + "Nom d\'utilisateur" + "Mot de passe" + "Pour la configuration statique, des clés d\'authentification TLS seront utilisés comme des clés statiques." + "Configurer le VPN" + "Ajouter un profil" + "Entrez un nom identifiant le nouveau profil" + Veuillez entrer un nom de profil unique + "Nom de profil" + "Aucun certificat utilisateur sélectionné." + "Aucune erreur" + "Erreur dans la configuration" + "Impossible d\'analyser l\'adresse IPv4" + "Impossible d\'analyser les règles de redirection personnalisés" + "Laissez vide pour définir si nécessaire" + "Raccourci OpenVPN" + "Se connecter au VPN" + "Profil spécifié dans raccourci introuvable" + "Préfixe de l\'hôte au hasard" + "Ajoute 6 caractères aléatoires en face du nom d\'hôte" + "Activer les options personnalisées" + "Spécifiez les options personnalisées. A utiliser avec précaution !" + "Route rejetée par Android" + "Déconnecter" + Déconnecter le VPN + "Effacer les logs" + "Annuler la confirmation" + "Déconnecter le VPN connecté / annuler la tentative de connexion ?" + "Retirer le VPN" + Vérifier si le serveur utilise des certificats avec les extensions TLS serveur (--remote-cert-tls serveur) + Attendre un certificat de serveur TLS + Vérifie l\'objet du certificat serveur distant DN + "Vérification du certificat de l\'hôte" + Spécifiez le contrôle utilisé pour vérifier le certificat à distance DN (par exemple, C=DE, L=Paderborn, OU =Avian IP Carriers, CN=openvpn.blinkt.de)\n\nIndiquez le DN complet ou le RDN (openvpn.blinkt.de dans l\'exemple) ou un préfixe RDN pour vérification.\n\nEn utilisant le préfixe RDN \"Server\" correspond à \"Server-1\" et \"Server 2\"\n\nSi vous laissez le champ de texte vide, cela vérifiera le RDN contre le nom du serveur.\n\nPour plus de détails, voir la page du manuel OpenVPN 2.3.1 sous —verify-x509-name + Objet du certificat distant + "Activer l\'authentification par clé TLS" + "Fichier d\'authentification TLS" + "Demande les adresses IP, les règles de redirection et les options de synchronisation du serveur." + "Aucune information n\'est demandée par le serveur. Les paramètres doivent être spécifiés ci-dessous." + "Réglages \"Pull\"" + "DNS" + "Remplacer les paramètres DNS par le serveur" + "Utilisez vos propres serveurs DNS" + "Domaine" + "Serveur DNS à utiliser." + "Serveur DNS" + "Serveur DNS secondaire utilisé si le serveur DNS principal ne peut pas être atteint." + "Serveur DNS secondaire" + "Ignorer les règles envoyées" + "Ignorer les règles de redirection de ports envoyées par le serveur." + "Redirige tout le trafic sur la connexion VPN" + "Utiliser la redirection par défaut" + "Entrez les règles de redirection. N\'entrez la destination qu\'au format CIDR. \"10.0.0.0 / 8 2002::/16\" redirigerait les réseaux 10.0.0.0/8 et 2002::/16 via le VPN." + Routes qui ne devraient pas être routés via le VPN. Utilisez la même syntaxe que pour les routes incluses. + "Règles personnalisés" + Réseaux exclus + "Niveau de verbosité des logs" + "Autorise les paquets authentifiés à partir de n\'importe quelle adresse IP" + "Permettre des serveur flottants" + "Options personnalisées" + "Modifier les paramètres VPN" + \"Effacer le profil VPN %s ?\"? + "Sur certaines ROMs ICS les permissions de /dev/tun peuvent être incorrectes, ou le module Tun peut être manquant. Pour les ROMs CM9, essayez de corriger les options dans \"General Settings\"" + "L\'ouverture de l\'interface Tun a échoué." + "Erreur: " + "Effacer" + Ouverture de l\'interface tun: + "IPv4 locale: %1$s/%2$d IPv6: %3$s MTU: %4$d" + Serveur DNS: %1$s, Domaine: %2$s + Routes : %1$s %2$s + Routes exclues : %1$s %2$s + Routes VpnService installés : %1$s %2$s + "Informations récupérées de l\'interface: %1$s et %2$s , en supposant que la seconde adresse est l\'adresse peer du réseau distant. Utilisation du masque de réseau /32 pour l\'IP locale. Mode donné par OpenVPN: \"%3$s\"." + "Ne peut pas donner un sens à %1$s et %2$s comme routage IP avec masque réseau de type CIDR, en utilisant /32 comme masque de réseau." + "Règle de redirection corrigée: %1$s / %2$s en %3$s / %2$s" + \"Impossible d\'accéder aux certificats \"Android Keychain\". (Peut être causé par une mise à jour du firmware ou par une restauration d\'une sauvegarde des paramètres de l\'application). Veuillez modifier le profil VPN et sélectionnez de nouveau le certificat dans les réglages de base pour recréer l\'autorisation d\'accéder au certificat.\". + "%1$s %2$s" + "Envoyer le fichier de log" + "Envoyer" + "Fichier de log OpenVPN ICS" + "Entrée du log copiée" + "Mode TAP" + "Le mode TAP est indisponible avec l\'API non root VPN. Par conséquent, cette application ne peut pas supporter TAP" + \"Encore une fois? Vous plaisantez? Le mode TAP n\'est absolument pas pris en charge et l\'envoi de plus d\'e-mails demandant si il sera intégré ne va en rien aider.\". + \"Encore une fois ? En fait il est possible que quelqu\'un puisse écrire un émulateur TAP basé sur TUN qui pourrait analyser des informations de type \"layer2\". Mais cet émulateur devrait aussi implémenter ARP et un client DHCP. Je ne suis actuellement pas au courant que quelqu\'un travail dessus. Contactez moi si vous voulez m\'aider là dessus\". + "FAQ" + "Copie des entrées du log" + "Pour copier une seule entrée du log restez appuyé sur celle-ci. Pour copier ou envoyer le log au complet utilisez l\'option \"Envoi du Log\". Utilisez le bouton matériel s\'il n\'est pas visible." + "Raccourci pour démarrer" + Vous pouvez placer un raccourci pour démarrer OpenVPN sur l\'écran d\'accueil. En fonction du programme gérant votre écran d\'accueil, vous devez soit ajouter un raccourci, soit un widget. + "Votre ROM ne prend pas en charge l\'API VPNService, désolé :(" + "Cryptage" + "Entrez la méthode de cryptage" + Entrer l\'algorithme de chiffrement utilisé par OpenVPN. Laisser vide pour utiliser l\'algorithme par défaut. + Entrer le digest à utiliser par OpenVPN pour l\'authentification. Laisser vide pour utiliser l\'algorithme par défaut. + "Authentification / Cryptage" + "Explorateur de fichiers" + "Fichier personnalisé" + "Impossible d\'importer le fichier" + "Impossible d\'importer le fichier depuis le système de fichiers" + "[[Fichier de données personnalisé]]" + "Impossible d\'ouvrir le périphérique TUN sans informations IP" + "Importer un profil depuis un fichier .ovpn" + "Importer" + "Impossible de lire le profil à importer" + "Erreur de lecture du fichier de configuration" + "Ajouter un profil" + "Impossible de trouver le fichier %1$s mentionné dans le fichier de configuration importé" + "Importation du fichier de configuration depuis %1$s" + Votre configuration a quelques options qui ne sont pas prises en compte par l\'interface utilisateur. Ces options ont donc été ajoutées comme des options de configuration personnalisées: + "Fin de la lecture du fichier de configuration." + "Ne pas se lier à l\'adresse locale et au port" + "Aucune liaison locale" + "Importer un fichier de configuration" + "Considérations de sécurité" + "La stratégie de sécurité d\'OpenVPN amène quelque remarques concernant la sécurité des données saisies. En général, toutes les informations stockées sur la carte SD ne sont pas sécurisées. Toute application peut en obtenir l\'accès (par exemple, ce programme ne requiert aucun droit particulier d\'accès à la carte SD). Dans le cas de ce programme, il est le seul à avoir accès à ces données. En utilisant l\'option d\'importation pour les CaCert/Cert/Key, les données sont stockées dans le porfile VPN. Ce dernier est seulement accessible à cette application. Ainsi, veuillez ne pas oublier de supprimer les copies sur la carte SD après importation. Car, même si l\'application en a l\'exclusivité, les données ne sont pas pour autant cryptées. En \"rootant\" l\'appareil ou par d\'autres exploits il est toujours possible d\'accéder à ces informations. A titre d\'exemple, les mots de passe sont stockés en clair. Pour les fichiers de type Pkfcs12, il est fortement recommandé que vous les importiez dans le gestionnaire de clées d\'Android." + "Importer" + "Erreur d\'affichage certificat sélectionné" + "Exception en essayant d\'afficher le dialogue de sélection du certification d\'Android 4.0+. Ceci ne devrait pas se produire car c\'est une des fonctionnalités de base de ce système. Il est donc possible que votre ROM ne supporte pas le stockage de certfiicats." + "IPv4" + "IPv6" + Attente du status… + "profil importé" + "profil importé: %d" + "Images corrompues " + <>Les ROMs officielles HTC sont connues pour avoir des problèmes de routage entraînant que le trafic ne passe pas par le tunnel VPN. (C.f.: <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=18\">Issue 18</a> dans le \"bug tacker\")</p><p>Les ROMs officielles de SONY pour le Xperia Arc S et le Xperia Ray ont été signalé comme ne possédant pas le service VPN. Toute autre ROM SONY peut avoir le même problème. (C.f.: <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=29\">Issue 29</a> dans le \"bug tacker\")</p><p>Sur les ROM personnalisées le module TUN peut être manquant ou les droits de /dev/tun peuvent être incorrects. Certaines ROM CM9 peuvent nécessiter d\'utiliser l\'option de correction des droits de /dev/tun accessible depuis les \"Options générales\"/</p><p>Important: Si votre ROM a un problème, contactez le vendeur, il se peut que qu\'il vous fournisse un patch.</p> + "Fichier de clé de cryptage PKCS12" + "Mot de passe de clé privée" + "Mot de passe" + "icône du fichier" + "Authentification TLS" + "Configuration générée" + Paramètres + "Tente de définir le propriétaire de /dev/tun. Certaines ROMs CM9 en ont besoin pour faire fonctionner l\'API VPNService. Nécessite les droits root." + "Corriger le propriétaire de /dev/tun" + "Affiche le fichier de configuration OpenVPN généré" + "Modification \"%s\"" + "Création de la configuration…" + "L\'activation de cette option forcera l\'appareil à se reconnecter si l\'état du réseau change (ex.: WIFI/Mobile)" + "Reconnexion lors de changement du réseau" + "État du réseau: %s" + "Le certificat CA est généralement renvoyé par le gestionnaire de clés Android. Spécifiez un certificat distinct si vous obtenez des erreurs de vérification de certificat." + "Sélectionner" + "Aucun certificat CA renvoyée lors de la lecture depuis le gestionnaire de clés. L\'authentification échouera probablement." + "Affiche la fenêtre de log à la connexion. Cette fenêtre peut toujours être consultée à partir de la notification d\'état." + "Afficher la fenêtre de log" + "Fonctionnant sur %1$s (%2$s) %3$s , Android API %4$d" + "Erreur de signature de la clé %1$s : %2$s par le gestionnaire d\'Android" + \"L\'avertissement de connexion au VPN qui vous informe que cette application peut intercepter tout le trafic est imposé par le système pour éviter les abus de l\'API du service VPN.\nLa notification de connexion au VPN (Le symbole qui ressemble à une clé) est aussi imposé par le système Android pour signaler une connexion VPN en cours de fonctionnement. +Sur certaines images, cette notification joue un son.\nAndroid à introduit ces dialogues système pour votre propre sécurité et à fait en sorte d\'être impossible à contourner. (Cela peut inclure en plus une notification sonore pour certaines images)\" + "Avertissement de connexion et son de notification" + French translation by Stanislas Bach<stanislasbach@gmail.com> + "IP et DNS" + "Base" + "Redirection de ports" + "Réglages OpenVPN avancés" + "Avancé" + "Configuration ICS OpenVPN " + Aucun serveur DNS utilisé. La résolution de noms de domaines peut ne pas fonctionner. Envisager d\'ajouter des serveurs DNS personnalisés. Veuillez également noter que Android va continuer à utiliser vos paramètres de proxy spécifiés pour votre connexion Wi-Fi/mobile lorsque aucun serveur DNS n\'est défini. + "Impossible d\'ajouter le serveur DNS \"%1$s\", rejetés par le système: %2$s" + Impossible de configurer l\'adresse IP \"%1$s\", rejetées par le système : %2$s + "<p>Obtenez une configuration fonctionnelle (testé sur un ordinateur ou téléchargé depuis le site de votre fournisseur/entreprise)</p><p>S\'il s\'agit d\'un seul fichier avec aucun fichier Pem/Pks12 supplémentaire, vous pouvez vous envoyer celui par mail et l\'ouvrir directement. Si vous avez plusieurs fichiers de configuration, mettez les sur votre carte SD.</p><p>Cliquez sur la pièce jointe de votre e-mail / Utilisez l\'icône du dossier dans la liste des VPN pour importer le fichier de configuration.</p><p>Si des erreurs concernant des fichiers manquants apparaissent, veuillez mettre les fichiers manquant sur la carte SD.</p><p>Cliquez sur l\'icône \"enregistrer\" pour ajouter le profil VPN importé à la liste.</p><p>Connectez le VPN en cliquant sur son nom dans cette liste.</p><p>Si vous rencontrez des erreurs ou des avertissements, veuillez lire ce qu\'il y a d\'écrit dans le log pour les corriger.</p> " + "Démarrage rapide" + "Essayez de charger le module du noyau \"tun.ko\" avant d\'essayer de vous connecter. Requiert des droits root." + "Charger le module TUN" + "Importer PKCS12 de la configuration dans le gestionnaire de clés Android" + "Erreur d\'obtention des paramètres de proxy: %s" + "Utilisation du proxy %1$s %2$d" + "Utiliser le proxy système" + "Utiliser la configuration générale du système pour que les proxy HTTP / HTTPS se connectent." + "Vous pouvez faire un <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&cmd=_s-xclick\">don avec PayPal</ a> " + "Reconnecter OpenVPN automatiquement si une connexion était active lors de l\'extinction/redémarrage de l\'appareil. Veuillez lire l\'avertissement de connexion dans la FAQ avant d\'utiliser cette option." + "Connexion automatique au redémarrage" + "Ignorer" + "Redémarrer" + "Les changements de configuration sont appliquées après redémarrage du VPN. (Re)démarrer le VPN maintenant?" + "Configuration modifiée" + "Impossible de déterminer le dernier profil connecté pour l\'édition" + "Notifications multiples" + "Si Android tourne sur la mémoire du système (RAM), les application et les services qui ne sont pas nécessaires à un moment sont automatiquement supprimés de la mémoire. Cela stoppe donc la connexion VPN en cours. Pour s\'assurer que celle-ci reste toujours lancée, le service est lancé avec une priorité plus élevée. Pour cela, l\'application doit afficher une notification permanente. L\'icône de \"clé\" dans la notification est imposée par le système comme expliqué dans l\'entrée de la FAQ précédente." + "Pas de profils VPN définis." + "Utilisez l\'icône <img src=\"ic_menu_add\"/ pour ajouter un nouveau VPN" + "Utilisez l\'icône <img src=\"ic_menu_archive\"/> pour importer un fichier profil (.opvpn ou .conf) de votre carte SD." + "Veillez également à consulter la FAQ. Il s\'y trouve un guide de démarrage rapide." + "Redirections / Configuration de l\'interface" + Ne pas couper la connexion VPN lors de la reconnexion d\'OpenVPN. + Persistance de l\'interface TUN + Log OpenVPN + "Importer une configuration OpenVPN" + "Consommation de la batterie" + In my personal tests the main reason for high battery consumption of OpenVPN are the keepalive packets. Most OpenVPN servers have a configuration directive like \'keepalive 10 60\' which causes the client and server to exchange keepalive packets every ten seconds. <p> While these packets are small and do not use much traffic, they keep the mobile radio network busy and increase the energy consumption. (See also <a href=\"http://developer.android.com/training/efficient-downloads/efficient-network-access.html#RadioStateMachine\">The Radio State Machine | Android Developers</a>) <p> This keepalive setting cannot be changed on the client. Only the system administrator of the OpenVPN can change the setting. <p> Unfortunately using a keepalive larger than 60 seconds with UDP can cause some NAT gateways to drop the connection due to an inactivity timeout. Using TCP with a long keepalive timeout works, but tunneling TCP over TCP performs extremely poorly on connections with high packet loss. (See <a href=\"http://sites.inka.de/bigred/devel/tcp-tcp.html\">Why TCP Over TCP Is A Bad Idea</a>) + La fonctionnalité de Tethering Android (sur WiFi, USB ou Bluetooth) et l\'API VPNService (utilisé par ce programme) ne fonctionnent pas ensemble. Pour plus de détails, voir la <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\" > page #34 </a> + VPN et Tethering + "Tentatives de connexion" + "Paramètres de reconnexion" + Nombre de secondes d\'attente entre chaque tentative de connexion. + "Temps, en secondes, entre deux connexions" + OpenVPN s\'est écrasé de façon inattendue. S\'il vous plaît, envisagez d\'utiliser l\'option de Minidump depuis le menu principal + Envoyer le Minidump au développeur + Envoyer les informations de débogage à propos du dernier accident au développeur + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + Connexion + En attente de la réponse du serveur + Authentification + Obtention de la configuration du client + Attribution de l\'adresses IP + Ajout des routes + Connecté + Déconnecter + Reconnexion + Fermeture + Eteint + Résolution des noms d\'hôtes + Connexion (TCP) + Echec de l\'authentification + En attente d\'un réseau utilisable + ↓%2$s/s %1$s - ↑%4$s/s %3$s + Non connecté + Connexion au VPN %s + Connexion au VPN %s + Certaines versions d\'Android 4.1 rencontrent des problèmes si le nom du certificat du trousseau de clé contient des caractères non alphanumériques (comme des espaces, des caractères de soulignement ou des tirets). Essayez de réimporter le certificat sans caractères spéciaux + Chiffrement de cryptage + Authentification des paquets + Méthode d\'authentification des paquets + Environnement: %1$s (%2$s) %3$s, Android API %4$d, version %5$s, %6$s + compilé par %s + version de debug + version officielle + Copier dans le profil + Vidage sur incident + Ajouter + Envoyer le fichier de config + DN complet + La configuration que vous avez importée utilise l\'option désuette tls-remote qui utilise un format de DN différent. + RDN (nom commun) + Préfixe RDN + tl-remote (OBSOLETE) + Vous pouvez aider à traduire en visitant http://crowdin.net/project/ics-openvpn/invite + %1$s essais de controler %2$s + En poursuivant vous donnez la permission a l\'application de contrôler complètement OpenVPN pour Android et d\'intercepter tout le trafic réseau.N\'acceptez que si vous faite confiance à l\'application. Sinon vous vous exposez au risque de voir vos données compromises par un logiciel malveillant.\" + Faire confiance à cette application. + Aucune application n\'est autorisée à utiliser l\'API externe + Applications autorisées: %s + Effacer la liste des appli. externes?\nListe des appli. autorisées:\n\n%s + \"Mettre le VPN en pause lorsque l\'écran est éteint et moins de 64ko de données sont transférées dans les 60s. Lorsque l\'option \"Persistance Tun\" est activée, la pause laissera votre appareil SANS connectivité réseau. Sans l\'option \"Persistance Tun\" le dispositif n\'aura pas connexion/protection VPN. + Mettre la connection VPN en pause à l\'exctinction de l\'écran + Connexion en pause quand l\'écran est éteint : moins de %1$s en %2$ss + Attention: tun persistant pas activé pour ce VPN. Le trafic utilisera la connexion Internet normale lorsque l\'écran est éteint. + Enregistrer le mot de passe + Pause du VPN + Reprendre VPN + Pause du VPN demandé par l\'utilisateur + VPN en pause - écran eteint + Hacks spécifiques à l\'appareil + Ne peut pas afficher les informations de certificat + Comportement de l\'application + Comportement du VPN + Autoriser les modifications des profils VPN + Clés du matériel : + Icône de l\'application qui essaie d\'utiliser OpenVPN for Android + "À partir d\'Android 4.3 la confirmation VPN est gardée contre les \"applications recouvrante\". Cela se traduit par la boîte de dialogue qui ne réagi pas à la saisie tactile. Si vous avez une application qui utilise des superpositions, elle peut causer ce comportement. Si vous trouvez une application délinquante contacter l\'auteur de l\'application. Ce problème affecte toutes les applications VPN sur Android 4.3 et plus. Voir aussi <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=185\">Issue 185<a> pour plus de détails" + Dialogue de confirmation du VPN sur Android 4,3 et plus + Sinon, vous pouvez m\'envoyer un don avec le Play Store : + Merci pour le don %s! + Journal effacé. + Afficher le mot de passe + Erreur d\'accès de KeyChain : %s + Court + ISO + Horodateurs + Aucun + Envoyé + Téléchargé + État VPN + Options d\'affichage + Exception non gérée : %1$s\n\n%2$s + %3$s: %1$s\n\n%2$s + Si vous avez \"rooté\" votre Android vous pouvez installer <a href=\"http://xposed.info/\">Xposed framework</a> et <a href=\"http://repo.xposed.info/module/de.blinkt.vpndialogxposed\">le module de confirmation VPN</a> à vos risques et périls\" + Licences complètes + Les réseaux directement connectés aux interfaces locales ne seront pas routés via le VPN. Décochez cette option pour rediriger tout le trafic local vers le VPN. + Ne pas utilisé le VPN pour les réseaux locaux + Fichier Nom d\'utilisateur/Mot de passe + diff --git a/ics-openvpn-stripped/main/src/main/res/values-id/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-id/strings.xml new file mode 100755 index 00000000..0a7d32b0 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-id/strings.xml @@ -0,0 +1,285 @@ + + + + + OpenVPN untuk Android + Alamat Server: + Port server: + Lokasi + Gagal membaca direktori + Pilih + Batal + Tak ada data + Kompresi LZO + Tanpa Sertifikat + Sertifikat Klien + Kunci Sertifikat Klien + Berkas PKCS12 + Sertifikat CA + Anda harus memilih sertifikat + Kode program dan perekam masalah tersedia di + Aplikasi memakai komponen berikut; lihat kode program untuk lebih jelas mengenai lisensi + Tentang… + Profil + Tipe + Password PKCS12 + Pilih… + Anda harus memilih berkas (file) + Pakai otentikasi TLS + Pengarah TLS + Masukkan IPv6 Address/Netmask dalam format CIDR (contoh: 2000:dd::23/64) + Masukkan IPv4 Address/Netmask dalam format CIDR (contoh: 1.2.3.4/24) + Alamat IPv4 + Alamat IPv6 + Masukan seting openvpn. Gunakan dengan hati-hati. Harap dicatat, TUN yanng terkait seting OpenVPN tidak didukung oleh VPNsettings. Jika anda berpikir ada hal penting belum tersedia, hubungi pembuatnya + Nama Penguna + Password + Untuk konfigurasi statis, kunci otentifikasi TLS akan digunakan sebagai kunci konfigurasi statis + Konfigurasi VPN + Tambah Profil + Masukkan nama profil yang baru + Silakan masukan UPN (Unique Profile Name) + Nama profil + Anda harus memilih sertifikat pengguna + Tidak ada kesalahan + Konfigurasi Salah + Gagal menganalisa alamat IPV4 + Gagal menganalisa rute buatan + (biarkan kosong untuk antrian permintaan) + Jalan Pintas OpenVPN + Hubungkan VPN + Profil di shrotcut tidak ada + Acak awalan Host + Tambah 6 karakter acak di depan nama host + Aktifkan pilihan buatan + Tentukan seting buatan. Gunakan hati-hati + Rute ditolak Android + Putus + Memutuskan sambungan VPN + Bersihkan catatan + Batal Konfirmasi + Putuskan sambungan VPN/Batalkan usaha menyambungkan VPN? + Singkirkan VPN + Memeriksa apakah server menggunakan sertifikat dengan ekstensi TLS Server (--server remote-cert-tls) + Mengharapkan sertifikat server TLS + Memeriksa sertifikat Remote Server Subjek DN + Cek nama sertifikat Host + Tentukan nilai ynag digunakan untuk memverifikasi sertifikat remote DN (misal C=nama perusahaan, L=Kota lokasi, OU=nama departemen perusahaan, CN=openvpn.blinkt.de. Tentukan DN atau RDN yang lengkap (dalam contoh : openvpn.blinkt.de) atau sebuah awalan RDN untuk verifikasi. Saat memakai RDN awalan \"server\" cocok dengan \"server-1\" dan \"server-2\". Mengosongkan field akan membuat RDN diperiksa dengan nama host server. Lebih jelasnya lihat OpenVPN 2.3.1 manpage di bagian -verify-x509-name + Subyek sertifikat remote + Aktifkan otentifikasi kunci TLS + Berkas otintikasi TLS + Meminta pilihan alamat IP, rute dan waktu dari server. + Tidak ada informasi diminta dari server. Seting harus ditentukan di bawah ini + Tarik pengaturan + DNS + Menimpa pengaturan DNS oleh Server + Gunakan server DNS pribadi + Cari domain + Server DNS yang akan digunakan + Server DNS + Server DNS sekunder digunakan jika Server DNS yang normal tidak dapat dicapai. + Server DNS cadangan + Abaikan rute yang diberikan + Abaikan rute yang diberikan server + Alihkan semua lalulintas data melalui VPN + Gunakan rute standar + Masukkan rute butan sendiri. Masukkan tujuan dalam format CIDR. \"10.0.0.0/8 2002:: / 16\" akan mengarahkan jaringan 10.0.0.0/8 dan 2002:: / 16 melalui jaringan VPN + Rute buatan sendiri + Tingkat rincian catatan + Ijinkan paket terotentifikasi dari semua IP + Ijinkan server mengambang + Pilihan buatan + Ubah seting OpenVPN + Hapus profil \'%s\'? + Pada beberapa setelan manual gambar ICS izin pada/dev/tun mungkin salah, atau modul tun mungkin hilang sepenuhnya. Untuk gambar CM9, coba perbaiki pilihan kepemilikannya di bawah pengaturan umum + Gagal membuka layanan antarmuka TUN + "Kesalahan: " + Bersihkan + Membuka interface tun : + IPv4 lokal : %1$s/%2$d IPv6: %3$s MTU: %4$d + DNS Server: %1$s, Domain: %2$s + Memilki informasi antarmuka %1$s dan %2$s, asumsi alamat kedua adalah alamat remote. Menggunakan netmask /32 untuk IP lokal. Mode yang diberikan oleh OpenVPN adalah \"%3$s\". + Tidak masuk akal membuat %1$s dan %2$s sebagai rute IP dengan netmask CIDR, Gunakan /32 sebagai netmask. + rute yang diperbaiki %1$s/%2$s hingga %3$s/%2$s + Tidak dapat mengakses sertifikat Keychain Android. Dapat disebabkan karena upgrade firmware atau pengembalian backup pengaturan app. Mohon ubah VPN, dan pilih ulang sertifikat berbasis pengaturan dasar agar izin mengakses sertifikat dapat dibuat ulang. + %1$s %2$s + Kirim berkas catatan + Kirim + Berkas catatan ICS OpenVPN + Salin catatan masuk ke clipboard + Mode TAP + Mode TAP tidak diijinkan tanpa VPN API non admin/root. Karena itu aplikasi ini tidak dapat memberikan dukungan mode TAP + Lagi ? Becanda ? mode TAP benar-benar tidak didukung dan mengirim email menanyakan apakah akan ada dukungan TAP, tidak akan membantu + Untuk ketiga kalinya? Sebenarnya, seseorang bisa menulis emulator TAP berdasarkan tun yang akan menambahkan lapisan2 informasi pengiriman dan lapisan2 informasi penerimaan. Tapi emulator TAP ini juga harus menerapkan ARP dan mungkin klien DHCP. Saya tidak tau apakah ada yang bekerja ke arah ini. Hubungi saya jika Anda ingin memulai menulis kode2 emulator TAP ini. + FAQ + Menyalin catatan + Untuk menyalin satu catatan masuk, Tekan dan tahan di catatan masuk. Untuk meyanlin\mengirim seluruh catatan, gunakan opsi Kirim Log. Gunakan tombol perangkat keras jika tidak terlihat di GUI. + Jalan pintas memulai + Anda dapat menempatkan jalan pintas untuk memulai OpenVPN pada desktop Anda. Tergantung pada program homescreen Anda, Anda harus menambahkan jalan pintas atau widget. + Gambar Anda tidak mendukung VPNService API, maaf:( + Enkripsi + Masukkan metode enkripsi + Masukkan sandi enkripsi algoritma yang digunakan oleh OpenVPN. Biarkan kosong untuk menggunakan sandi default. + Masukkan digest otentikasi yang digunakan OpenVPN. Biarkan kosong untuk menggunakan standar digest. + Otentikasi/Enkripsi + Penjelajah berkas + Inline File + Gagal mengambil berkas + Tidak dapat mengambil berkas dari filesystem + [[Inline file data]] + TUN tidak dapat dibuka tanpa informasi IP + Ambil profil dari berkas ovpn + Ambil + Tidak dapat membaca profil yang akan diambil + Kesalahan membaca berkas konfigurasi + Tambah Profil + Tidak dapat menemukan berkas %1$s yang disebut dalam berkas konfigurasi + Mengambil berkas konfigurasi dari sumber %1$s + Konfigurasi Anda memiliki beberapa pilihan konfigurasi yang tidak dipetakan ke konfigurasi UI. Pilihan ini ditambahkan sebagai opsi konfigurasi kustom. Konfigurasi kustom ditampilkan di bawah ini: + Berkas konfigurasi selesai dibaca + Jangan kaitkan ke alamat dan port lokal + Tidak ada ikatan lokal + Ambil berkas konfigurasi + Pertimbangan Keamanan + "Karena OpenVPN adalah sensitif pada isu keamanan, beberapa catatan tentang keamanan dianggap perlu. Semua data pada sdcard pada dasarnya tidak aman. Setiap app dapat membaca (misalnya program ini tidak perlu hak khusus untuk membaca sd-card). Data dari aplikasi ini hanya dapat dibaca oleh aplikasi itu sendiri. Dengan menggunakan opsi impor untuk cacert/cert/kunci dalam file dialog data yang disimpan dalam profil VPN. Profil VPN hanya dapat diakses oleh aplikasi ini. (Jangan lupa untuk menghapus salinan pada sd-card setelah itu). Bahkan meskipun dapat diakses hanya dengan aplikasi ini data masih tidak terenkripsi. Dengan melakukan rooting atau eksploitasi lainnya maka memungkinkan mengambil data. Sandi-sandi (passwords) juga tersimpan dalam teks biasa. Berkas pkcs12 sangat dianjurkan Anda mengimpornya ke android keystore." + Impor + Kesalahan menampilkan sertifikat + Mendapat pesan kesalahan saat berusaha menampilkan layar pemilihan sertifikat Android 4.0+. Ini seharusnya tidak terjadi karena ini fitur standar Android 4.0 +. Mungkin ROM Android anda yang mengurus penyimpanan sertifikat rusak + IPv4 + IPv6 + Menunggu pesan status… + Profil yang diambil + profil yang diambil %d + Gambar rusak + Image HTC yang resmi diketahui memiliki masalah routing yang ganjilyang menyebabkan trafik data tidak melalui tunnel (Lihat di <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=18\">Issue 18</a> di bagian bug tracker.))</p><p> Image SONY resmi yang lama dari Xperia Arc S and Xperia Ray telah dilaporkan tidak memiliki VPNService dalam Imagenya. (Lihat juga <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=29\">Issue 29</a> di bagian bug tracker.))</p><p>Pada image yang dibuat non resmi, modul TUN mungkin tak ada atau hak /dev/tun mungkin salah. Beberapa image CM9 memerlukan pilihan \"Fix ownership\" di bagian \"Device specific hacks\" diaktfikan. .</p><p> Lebih penting lagi, jika device anda memiliki image android yang lengkap, laporkan pada vendor anda. Semakin banyak laporan masuk, semakin tinggi kemungkinan vendor melakukan perbaikan.</p> + Berkas kunci enkripsi PKCS12 + Sandi kunci pribadi + Sandi + ikon berkas + Otentikasi TLS + Konfigurasi Dibuat + Pengaturan + Mencoba menetapkan pemilik /dev/tun ke sistem. Beberapa gambar CM9 memerlukan ini untuk membuat API VPNService bekerja. Memerlukan akses Root. + Perbaiki kepemilikan /dev/tun + Tunjukkan berkas konfigurasi OpenVPN yang dibuat + Mengubah \"%s\" + Membuat konfigurasi… + Menyalakan pilihan ini akan memaksa menyambung kembali jika keadaan jaringan berubah (misalnya WiFi dari mobile) + Koneksi ulang saat ganti jaringan + Status jaringan: %s + Sertifikat CA biasanya kembali dari Android Keystore. Tentukan sertifikat terpisah jika Anda mendapatkan kesalahan verifikasi sertifikat. + Pilih + Tidak ada sertifikat CA yang didapat saat membaca dari Android Keystore. Otentifikasi mungkin gagal + Tampilkan jendela catatan saat terkoneksi. Jendela catatan juga dapat diakses melalui status notifikasi + Tampilkan jendela catatan + Berjalan di %1$s (%2$s) %3$s, Android API %4$d + Kesalahan masuk dengan kunci Android keystore %1$s: %2$s + Peringatan sambungan VPN yang memberitahukan Anda bahwa aplikasi ini dapat mencegat semua lalu lintas dikeluarkan oleh sistem untuk mencegah penyalahgunaan dari sambungan VPNService API.\nPemberitahuan sambungan VPN (simbol kunci) juga dikeluarkan oleh sistem Android untuk memberitahu VPN yang sedang berlangsung. Pada beberapa gambar pemberitahuan ini memainkan suara. \nAndroid memperkenalkan sistem dialog ini untuk keselamatan Anda sendiri dan memastikan bahwa mereka tidak membuat masalah. (Pada beberapa gambar sayangnya ini termasuk peringatan suara) + Peringatan sambungan dan pemberitahuan melalui suara + Terjemah Bahasa Indonesia oleh Dayro + IP dan DNS + Dasar + Rute + Mengaburkan pengaturan OpenVPN. Biasanya tidak diperlukan. + Lanjutan + Konfigurasi ICS Openvpn + Tidak DNS server yang digunakan. Name Resolution mungkin akan gagal bekerja. Pertimbangkan pengaturan server DNS. Harap dicatat Android akan terus memakai pengaturan proxy untuk koneksi mobile/wifi saat tidak ada server DNS diatur. + Tak bisa menambahkan Server DNS \"%1$s\", ditolak oleh sistem: %2$s + <p> Ambil konfigurasi yang dapat berjalan (diuji pada komputer Anda atau download dari penyedia/organisasi) </p> <p> Satu file(berkas) saja tanpa tambahan berkas pem/pks12. Anda dapat kirim imel berkas dan membuka lampirannya. Jika Anda memiliki beberapa berkas, salin ke sd-card </p> <p> klik pada lampiran imel atau gunakan ikon folder dalam daftar vpn untuk mengimpor berkas konfigurasi </p> <p> jika ada berkas yang kurang, salin file hilang ke sd-card. </p> <p> klik pada simbol Simpan untuk menambahkan VPN yang diimpor ke daftar VPN </p> <p > Connect VPN dengan mengklik nama VPN </p> <p> jika ada kesalahan atau peringatan di catatan, coba pahami peringatannya dan coba untuk memperbaikinya </p> + Mulai Cepat + Coba pakai tun.ko kernel sebelum mencoba koneksi. Membutuhkan perangkat yang sudah diroot. Google: android superuser + Pakai modul TUN + Ambil PKCS12 dari konfigurasi ke Android Keystore + Gagal mendapatkan pengaturan proxy: %s + Menggunakan proxy %1$s %2$d + Gunakan sistem proxy + Gunakan konfigurasi lebih luas untuk menyambung system melalui proxy HTTP/HTTPS + Anda dapat melakukan donasi <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">dengan PayPal</a> + OpenVPN akan menyambung kembali VPN jika VPN aktif pada saat sistem reboot/shutdown. Silakan baca FAQ tentang peringatan sambungan sebelum menggunakan pilihan ini. + Koneksi ulang saat perangkat dihidupkan kembali + Abaikan + Restart + Perubahan konfigurasi baru diterapkan setelah restart VPN. Restart VPN sekarang? + Konfigurasi berubah + Tak bisa menentukan profil terhubung terakhir untuk diubah + Pemberitahuan berganda + Jika Android kekurangan sistem memori (RAM), aplikasi dan layanan yang tidak diperlukan pada saat itu akan dihapus dari memori aktif. Sambungan VPN yang sedang aktif juga ditutup. Untuk memastikan bahwa sambungan/OpenVPN tetap berjalan, OpenVPN diberikan prioritas yang lebih tinggi. Untuk menjalankan dengan prioritas lebih tinggi, aplikasi harus menampilkan pemberitahuan. Ikon pemberitahuan dijalankan oleh sistem seperti dijelaskan dalam FAQ entri sebelumnya. Ini tidak dihitung sebagai pemberitahuan app yang berjalan dengan prioritas lebih tinggi. + Tak ada profil VPN yang didefinisikan. + Gunakan ikon < img src = \"ic_menu_add\" / > untuk menambah VPN baru + Gunakan ikon < img src = \"ic_menu_archive\" / > untuk mengimpor profil (.ovpn atau .conf) yang ada dari sdcard Anda. + Pastikan untuk juga memeriksa FAQ. Ada petunjuk untuk memudahkan anda. + Konfigurasi rute\antarmuka + Jangan kembali ke status tidak ada koneksi VPN ketika OpenVPN mencoba terhubung kembali. + Paksa mode TUN + Catatan OpenVPN + Ambil konfigurasi VPN + Konsumsi baterai + Berdasarkan tes pribadi, alasan utama tingginya konsumsi baterai oleh OpenVPN adalah paket keepalive. Sebagian besar server OpenVPN memiliki parameter konfigurasi seperti \'keepalive 10 60\' yang membuat klien dan server bertukar paket keepalive setiap 10 detik. <p> Dengan kecilnya paket ini dan tidak memakai trafik terlalu banyak, mereka menjaga jaringan radio mobile tetap sibuk dan meningkatkan konsumsi energi. (See also <a href=\"http://developer.android.com/training/efficient-downloads/efficient-network-access.html#RadioStateMachine\">The Radio State Machine | Android Developers</a>) <p> Seting keepalive ini tidak bisa dirubah di klien. Hanya Admin sistem OpenVPN yang dapat merubah seting ini. <p> Sayangnya membuat keepalive lebih besar dari 60 detik tanpa UDP dapat membuat beberapa gateway NAT memutus koneksi karena anggapan tidak ada aktifitas pada periode tertentu (timeout). Memakai TCP dengan waktu timeout lebih lama dapat bekerja, tapi membuat tunnel TCP di jalur TCP menyebabkan koneksi yang buruk dan tingginya angka kehilangan paket data ((See <a href=\"http://sites.inka.de/bigred/devel/tcp-tcp.html\">Why TCP Over TCP Is A Bad Idea</a>) + Fitur penggandengan Android (melalui WiFi, USB atau Bluetooth) dan API VPNService (digunakan oleh program ini) tidak bekerja bersama-sama. Untuk keterangan lanjut lihat < href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\" > mengeluarkan #34 </a> + VPN dan penarikan + Mengulang koneksi + Pengaturan rekoneksi + Jumlah detik untuk menunggu antar usaha koneksi + Detik antar koneksi + OpenVPN crash tak terduga. Silakan mempertimbangkan mengirim menggunakan pilihan Minidump di Menu Utama + Mengirim MiniDump untuk pengembang + Mengirim informasi debug tentang kegagalan aplikasi yang terakhir ke pengembang + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + Menghubungkan + Menunggu jawaban server + Melakukan otentifikasi + Mengambil konfigurasi klien + Menetapkan alamat IP + Menambahkan rute + Terhubung + Putus + Menghubungkan kembali + Keluar + Tidak berjalan + Mengenali nama host + Menghubungkan (TCP) + Otentifikasi gagal + Menunggu jaringan yang dapat dipakai + ↓%2$s/s %1$s - ↑%4$s/s %3$s + Tidak terhubung + Menghubungkan ke VPN %s + Menghubungkan ke VPN %s + Beberapa versi Android 4.1 memiliki masalah jika nama sertifikat keystore berisi karakter non alfanumerik (seperti spasi, garis bawah atau tanda hubung). Cobalah import ulang sertifikat tanpa karakter khusus + Enkripsi sandi + Otentikasi paket + Masukkan metode otentikasi paket + Berjalan pada Android API %4$d, versi %5$s %1$s (%2$s) %3$s, %6$s + dibangun oleh %s + Pengembangan debug + Build Resmi + Salin ke profil + Data saat terjadi crash + Tambahkan + Mengirim config file + DN lengkap + Konfigurasi yang diimpor menggunakan opsi tls-remote DEPRECATED tua dengan menggunakan format DN yang berbeda. + RDN (nama umum) + RDN awalan + TLS-remote (DEPRECATED) + Anda dapat membantu menerjemahkan dengan mengunjungi http://crowdin.net/project/ics-openvpn/invite + %1$s berusaha mengendalikan %2$s + Saya percaya aplikasi ini. + App tidak diizinkan untuk menggunakan API eksternal + apps yang diijinkan : %s + Hapus daftar aplikasi eksternal yang dibolehkan? \nDaftar apps yang dibolehkan terkini:\n\n%s + \"Pause VPN ketika layar off dan data yang ditransfer dalam 60 detik kurang dari 64kB. Ketika opsi \"Persistent Tun\" diaktifkan, memberhentikan VPN akan membuat perangkat Anda tidak memiliki koneksi jaringan. Jika tidak memakai \"Persistent Tun\" maka perangkat akan menampilkan Tidak ada koneksi VPN. + Sambungan VPN jeda setelah layar mati + Hentikan sambungan dalam kondisi layar mati: kurang dari %1$s dalam %2$ss + Peringatan: Pemaksaan tun tidak diaktifkan untuk VPN ini. Lalu lintas akan menggunakan koneksi Internet normal ketika layar dimatikan. + Menyimpan sandi + Jeda VPN + Lanjutkan VPN + Pause VPN diminta oleh pengguna + VPN dijeda - layar off + Perangkat dengan spesifikasi Hacks + Tidak dapat menampilkan informasi sertifikat + Prilaku Aplikasi + Prilaku VPN + diff --git a/ics-openvpn-stripped/main/src/main/res/values-it/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-it/strings.xml new file mode 100755 index 00000000..b35fa480 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-it/strings.xml @@ -0,0 +1,310 @@ + + + + + OpenVPN per Android + Indirizzo server: + Porta del server: + Posizione + Impossibile leggere la directory + Seleziona + Annulla + Nessun dato + Compressione LZO + Nessun certificato + Certificato client + Chiave del certificato client + File PKCS12 + Certificato CA + Devi selezionare un certificato + Il codice sorgente e il bug tracker sono disponibili all\'indirizzo http://code.google.com/p/ics-openvpn/ + Questo programma usa i seguenti componenti; guarda il codice sorgente per i dettagli completi sulle licenze + Informazioni + Profili + Tipo + Password PKCS12 + Seleziona… + Devi selezionare un file + Usa autenticazione TLS + Direzione TLS + Inserire l\'indirizzo IPv6 e la maschera di rete in formato CIDR (ad esempio 2000:dd::23/64) + Inserire l\'indirizzo IPv4 e la maschera di rete in formato CIDR (ad esempio 1.2.3.4/24) + Indirizzo IPv4 + Indirizzo IPv6 + Inserire le opzioni personalizzate di OpenVPN. Usare con cautela. Si ricorda che molte delle impostazioni relative a OpenVPN non sono attualmente supportate da questo progetto. Se ritiene che manchi un\'opzione indispensabile, contatta l\'autore + Utente + Password + Per la configurazione statica le chiavi di autorizzazione TLS saranno usate come chiavi statiche + Configura la VPN + Aggiungi profilo + Immettere un nome per identificare il nuovo profilo + Si prega di inserire un nome univoco del profilo + Nome del profilo + Devi selezionare un certificato utente + Nessun errore trovato + Errore nella configurazione + Impossibile analizzare l\'indirizzo IPv4 + Errore durante la lettura delle regole di reindirizzamento (routing) + (non compilare perché venga sempre richiesto) + Collegamento a OpenVPN + Connetti alla VPN + Profilo indicato nel collegamento non trovato + Prefisso Host casuale + Aggiunge 6 caratteri casuali prima dell\'hostname + Abilita opzioni personalizzate + Specifica opzioni personalizzate. Utilizzare con cautela! + Reindirizzamento (route) rifiutato da Android + Scollega + Disconnettere VPN + Cancella registro + Conferma l\'annullamento + Disconnetti la VPN in uso/annulli il tentativo di connessione? + Rimuovi VPN + Controlla se il server utilizza un certificato con estensioni TLS (--remote-cert-tls server) + Attesa di un certificato server TLS + Controlla il soggetto DN del certificato del server remoto + Verifica il certificato dell\'Host + Specifica il controllo da effettuare per verificare il certificato DN remoto (e.g. C=DE, L=Paderborn, OU=Avian IP Carriers, CN=openvpn.blinkt.de)\n\nPer verifica specifica il DN o RDN completo (nell\'esempio openvpn.blinkt.de) oppure un prefisso RDN.\n\nQuando usi un prefisso RDN \"Server\" è valido per \"Server-1\" e \"Server-2\"\n\nLasciando la casella vuota verrà controllato l\'RDN con l\'hostname del server.\n\nPer maggiori informazioni consulta la manpage di OpenVPN 2.3.1+ sotto la voce —verify-x509-name + Soggetto del certificato remoto + Abilita l\'autenticazione tramite TLS + File di autenticazione TLS + Richiede indirizzi IP, instradamenti ed opzioni di sincronizzazione al server. + Nessuna informazione è richiesta al server. Le impostazioni devono essere specificate qui di seguito. + Richiedi impostazioni + DNS + Modifica DNS + Utilizza i propri server DNS + Dominio di ricerca + Server DNS da utilizzare. + Server DNS + Server DNS secondario utilizzato se il Server DNS primario non può essere raggiunto. + Server DNS secondario + Ignora gli instradamenti + Ignora impostazioni di routing comunicate dal server. + Reindirizza tutto il traffico sulla VPN + Utilizza il Routing di default + Inserisci instradamenti personalizzati. Usare il formato CIDR. \"10.0.0.0/8 2002::/16\" reindirizza le reti 10.0.0.0/8 e 2002::/16 sulla VPN. + Routing personalizzati + Livello di dettaglio del registro + Permette pacchetti autenticati da qualsiasi IP (consente che l\'IP del server possa cambiare) + Modalità float + Opzioni personalizzate + Modifica impostazioni VPN + Rimuovere il profilo VPN \'%s\'? + In alcune immagini ICS personalizzate i permessi su /dev/tun potrebbero essere errati, oppure il modulo TUN completamente assente. Per le immagini CM9 provare a correggere le opzioni Proprietà nella sezione impostazioni generali + Impossibile accedere all\'interfaccia tun + "Errore:" + Azzera + Apertura interfaccia tun in corso: + Indirizzi locali - IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + DNS Server: %1$s, Dominio: %2$s + Ottenute le informazioni sulle interfacce %1$s e %2$s, assumendo che il secondo indirizzo sia il peer remoto. Utilizzata la maschera /32 per l\'IP locale. La modalità impostata da OpenVPN è \"%3$s\". + Impossibile utilizzare %1$s e %2$s come reindirizzamenti IP con la maschera CIDR, è stata quindi usata la maschera /32. + Instradamento %1$s/%2$s corretto con %3$s/%2$s + Impossibile accedere ai certificati della Keychain di Android (può essere causato da un aggiornamento del firmware o dal ripristino di un backup dell\'applicazione o delle sue impostazioni). E\' necessario modificare le impostazioni della VPN e riselezionare il certificato nelle impostazioni principali per ricreare i permessi di accesso al certificato. + %1$s %2$s + Invia il file di log + Invia + File log di OpenVPN ICS + Voce di registro copiata negli appunti + Modalità TAP + La modalità TAP non è disponibile con le VPN API non root + Ancora? Stai scherzando? No, la modalità tap non è supportata e mandare nuove email chiedendo se sarà supportata non aiuterà. + Per la terza volta? In realtà si potrebbe scrivere un emulatore TAP basato su TUN che aggiunge le informazioni di Layer 2 in uscita e le elimina in ingresso. Ma questo emulatore TAP dovrebbe anche implementare ARP e un client DHCP. Non sono a conoscenza di nessuno che stia realizzando qualcosa del genere. Contattami se vuoi iniziare a scrivere del codice a riguardo. + Domande frequenti (FAQ) + Sto copiando le voci di log + Per copiare una singola voce del log, premi e mantieni sulla voce del log. Per copiare/inviare l\'intero log usa l\'opzione \"Manda log\". +Usa il tasto hardware Menù se non è visibile nella GUI. + Scorciatoia per l\'avvio + È possibile inserire un collegamento per avviare OpenVPN dal desktop. A seconda del vostro launcher dovrete aggiungere un collegamento o un widget. + La tua immagine non è supportata dal VPNService API, mi dispiace :( + Crittografia + Inserire il metodo di crittografia + Inserisci l\'algoritmo di cifratura cipher usato da OpenVPN. Lasciare vuoto per usare quello di default. + Inserisci l\'algoritmo di cifratura digest usato da OpenVPN. Lascia bianco per usare quello di default. + Autenticazione/crittografia + Esplora risorse + Blocco note + Errore durante l\'importazione del file + Impossibile importare il file dal filesystem + [[dati del blocco note]] + Rifiuto di attivare il dispositivo tun senza informazioni sull\'IP + Importa il profilo dal file .ovpn + Importa + Impossibile leggere il profilo da importare + Errore di lettura del file di configurazione + Aggiungi profilo + Impossibile trovare il file %1$s menzionato nel file di configurazione importato + Importa il file di configurazione dalla sorgente %1$s + La tua configurazione usava qualche opzione non mappata sull\'Interfaccia Utente. Queste opzioni sono state quindi aggiunte come personalizzate. La configurazione personalizzata è visualizzata qui sotto: + +Effettuata la lettura del file di configurazione + Non si vincola all\'indirizzo e alla porta locali (bind) + Niente local binding + Importa file di configurazione + Considerazioni sulla sicurezza + "Dato che si usa OpenVPN per motivi di sicurezza, si riportano alcune note su quanto la sicurezza sia sensibile. Tutti i dati memorizzati sulla scheda SD sono intrinsecamente insicuri. Qualunque programma può leggerli (ad esempio a questo programma non sono richiesti speciali diritti per accedere alla scheda SD). I dati di questo programma invece possono essere letti solo dal programma stesso. Utilizzando l\'opzione di importazione di cacert/cert/key nelle impostazioni, i dati vengono memorizzati nel profilo della VPN. I profili delle VPN sono accessibili solo da questo programma (non bisogna però dimenticarsi di eliminare le copie dei certificati sulla scheda SD dopo questa operazione). Tuttavia anche se accessibili solamente da questo programma, i dati vengono memorizzati senza alcuna crittografia. E\' possibile pertanto mediante rooting o altre procedure recuperare tali dati. Anche le password salvate vengono memorizzate in chiaro. Si raccomanda caldamente di importare i file pkcs12 nel keystore di Android." + Importa + Errore nel mostrare il certificato selezionato + Si è incappati in una eccezione tentando di visualizzare la finestra di selezione dei certificati di Android 4.0+. Questo non dovrebbe mai accadere dato che questa è una caratteristica standard di Android 4.0+. Forse il supporto al salvataggio dei certificati del tuo firmware di Android è corrotto. + IPv4 + IPv6 + In attesa del messaggio di stato… + profilo importato + profilo importato %d + Firmware bacati + <p>E\' noto che le immagini ufficiali di HTC presentano uno strano problema di routing causando per cui il traffico non fluisce nel tunnel (Vedere <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=18\">Issue 18</a> nella gestione dei bug.)</p><p>Le immagini SONY più vecchie per Xperia Arc S e Xperia Ray sono segnalate come completamente mancanti di VPNService. (Vedere anche <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=29\"> Problema 29</a> nella gestione bug.)</p><p> Su immagini personalizzate il modulo tun potrebbe essere mancante oppure i diritti di accesso a /dev/tun potrebbero essere errati. Alcune immagini CM9 hanno bisogno di avere abilitata \'opzione \"Aggiusta proprietà\" nelle \"Opzioni specifiche per il dispositivo\".</p><p>Molto importante: se il tuo dispositivo ha un\'immagine Android difettosa, segnalalo al tuo rivenditore. Più persone segnalano un problema al rivenditore, più è probabile che questi lo sistemi.</p> + File con la chiave di crittografia PKCS12 + Password della chiave privata + Password + icona del file + Autenticazione TLS + Configurazione generata + Impostazioni + Tenta di impostare system come proprietario di /dev/tun. Alcuni firmware CM9 necessitano di questa impostazione affinché le API del servizio VPN funzionino. E\' necessario essere root. + Correggi i diritti su /dev/tun + Mostra il file di configurazione di OpenVPN generato + Modifica \"%s\" + Configurazione in corso… + Selezionando questa opzione verrà forzata una riconnessione se lo stato della rete cambia (da WIFI a cellulare e viceversa) + Riconnetti in caso cambi la rete + Stato della rete: %s + Il certificato della CA è solitamente prelevato dal Keystore di Android. Indica un certificato differente se si generano errori di verifica del certificato. + Selezionare + Nessun certificato della CA è stato prelevato dal Keystore di Android. E\' probabile che l\'autenticazione fallisca. + Mostra la finestra dei log della connessione. Si può sempre accedere alla finestra dei log tramite la barra delle notifiche. + Visualizza la finestra dei log + In esecuzione su %1$s (%2$s) %3$s, Android API %4$d + Errore di firma con la chiave %1$s: %2$s del Keystore di Android. + L\'avvertimento durante la connessione VPN, in cui si informa che questo programma può intercettare tutto il traffico del sistema, serve a prevenire un uso fraudolento delle API del servizio VPN.\nL\'icona di notifica a forma di chiave è altresì imposta dal sistema Android per avvertire che si è connessi ad una VPN. Su alcuni apparecchi questa notifica è accompagnata da un suono.\nAndroid utilizza questi sistemi per la tua sicurezza e per assicurarsi che questi non vengano aggirati (in alcuni firmware questo sfortunamente è accompagnato da un suono di avvertimento). + Avviso di connessione e notifica sonora + Traduzione in inglese di Arne Schwabe<arne@rfc2549.org> + IP e DNS + Principali + Instradamento (routing) + Impostazioni avanzate di OpenVPN. Normalmente non necessarie. + Avanzate + Configurazione OpenVPN ICS + Nessun server DNS verrà utilizzato. La risoluzione dei nomi potrebbe non funzionare. Provare a impostare i server DNS personalizzati. Si prega di notare, che Android utilizzerà le impostazioni del proxy specificate per la connessione Wi-Fi, quando non viene impostato alcun server DNS. + Impossibile aggiungere il server DNS \"%1$s\", respinto dal sistema: %2$s + Non è stato possibile configurare l\'indirizzo IP \"%1$s\", che è stato rifiutato dal sistema: %2$s + <p>Ottieni una configurazione funzionante (testata sul tuo computer o fornita dal tuo provider o dalla tua ditta).</p><p>Se si tratta di un singolo file senza ulteriori file tipo pem/pkcs12, puoi spedire il file a te stesso via email ed aprire l\'allegato. Se hai più file, salvali sulla scheda SD.</p><p>Clicca sull\'allegato dell\'email oppure utilizza l\'icona della cartella nell\'elenco delle VPN per importare il file di configurazione.</p><p>Se compaiono degli errori relativi a file non trovati, copia i file mancanti sulla tua scheda SD.</p><p>Clicca sull\'icona di salvataggio per aggiungere la VPN importata nell\'elenco delle tue VPN.</p><p>Connettiti alla VPN cliccando sul nome della VPN.</p><p>Se compaiono degli errori o degli avvertimenti nei log, si consiglia di non ignorarli, ma di cercare delle soluzioni.</p> + Guida rapida + Prova a caricare il modulo tun.ko prima di connettersi. Si devono avere diritti di root sul dispositivo. + Carica il modulo tun + Importa i PKCS12 dalla configurazione presente nel Keystore di Android + Errore nell\'ottenere le impostazioni del proxy: %s + Si sta utilizzando il proxy %1$s %2$d + Utilizza il proxy di sistema + Utilizza la configurazione generale del sistema relativa ai proxy HTTP/HTTPS per connettersi. + Puoi <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">donare tramite PayPal</a> + OpenVPN is riconnetterà alla VPN se era in funzione durante un riavvio od un spegnimento dell\'apparecchio. Leggi con attenzione le FAQ con gli avvertimenti sulla connessione prima di scegliere questa opzione. + Riconnetti al riavvio + Ignora + Riavvia + Le modifiche sarannoi applicate dopo aver riavviato la connessione VPN. Riavviare ora la connessione? + Configurazione modificata + Impossibile determinare l\'ultimo profilo con cui ci si è connessi per poterlo modificare + Doppie notifiche + Normalmente, se la memoria di sistema (RAM) di Android è insufficiente, i programmi ed i servizi che non sono in quel momento necessari vengono rimossi dalla memoria attiva. Se ciò avvenisse, la connessione VPN in corso verrebbe terminata. Per far sì che la conessione OpenVPN resti in funzione, il servizio viene eseguito in priorità alta e per questo motivo appare un\'icona permanente nella barra delle notifiche. L\'icona di notifica a forma di chiave è invece imposta dal sistema come descritto nella precedente voce delle FAQ e non serve ad eseguire il programma con priorità alta. + Nessun profilo VPN definito. + Usa l\'icona <img src=\"ic_menu_add\"/> per aggiungere una nuova VPN + Usa l\'icona <img src=\"ic_menu_archive\"/> per importare il profilo (.ovpn o .conf) dalla tua scheda SD. + Si raccomanda di leggere anche le FAQ. C\'è anche una guida rapida. + Configurazione dei reindirizzamenti e dell\'interfaccia + Non passa allo stato di \"Nessuna connessione VPN\" quando OpenVPN sta eseguendo un tentativo di riconnessione. + tun persistente + Log di OpenVPN + Importa configurazione OpenVPN + Consumo della batteria + Nei miei test personali la ragione principale per l\'alto consumo di batteria con OpenVPN è rappresentata dai pacchetti keepalive. La maggior parte dei server OpneVPN posseggono una direttiva \'keepalive 10 60\' che fa sì che il client e il server scambino dei pacchetti keepalive ogni dieci secondi.<p> Anche se questi pacchetti sono piccoli e non usano molto traffico, essi mantengono impegnata la sezione radio del dispositivo e incrementano il consumo energetico. (Vedere anche <a href=\"http://developer.android.com/training/efficient-downloads/efficient-network-access.html#RadioStateMachine\">The Radio State Machine | Android Developers</a>) <p> Questa impostazione keepalive non può essere cambiata lato client. Solo l\'amministratore del server OpenVPN può farlo.<p> Purtroppo usando un keepalive maggiore di 60 secondi con UDP alcuni gateway NAT fanno cadere la connessione per via di un timeout su inattività. Usando TCP con un keepalive lungo il timeout funziona, ma il tunneling su TCP presenta basse prestazioni su connessioni con alta perdita di pacchetti. (Vedere <a href=\"http://sites.inka.de/bigred/devel/tcp-tcp.html\">Why TCP Over TCP Is A Bad Idea</a>) + Il Tethering di Android (via WiFi, USB o Bluetooth) e le API del servizio VPN (utilizzate da questo programma) non possono funzionare contemporaneamente. Per maggiori informazioni, vedi <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\">il problema #34</a> + VPN e Tethering + Tentativi di riconnessione + Impostazioni di riconnessione + Numero di secondi di attesa tra i tentativi di connessione. + Secondi tra le connessioni + OpenVPN si è arrestato in modo imprevisto. Ti consigliamo di attivare l\'opzione Invia Minidump nel menu principale. + Invia Minidump allo sviluppatore + Invia informazioni di debug riguardanti l\'ultimo crash allo sviluppatore + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + Connessione in corso + In attesa di risposta dal server + Autenticazione + Caricamento configurazione client + Assegnazione indirizzi IP + Configuro gli instradamenti + Connesso + Disconnetti + Riconnessione in corso + Uscita + Non in esecuzione + Risoluzione hostname in corso + Connessione in corso (TCP) + Autenticazione fallita + In attesa di una rete utilizzabile + ↓%2$s/s %1$s - ↑%4$s/s %3$s + Non connesso + Connessione alla VPN %s in corso + Connessione alla VPN %s in corso + Alcune versioni di Android 4.1 hanno problemi se il nome del certificato keystore contiene caratteri non alfanumerici (come spazi, caratteri di sottolineatura o trattini). Provare a reimportare il certificato senza caratteri speciali + Algoritmo di crittografia + Autenticazione pacchetti + Seleziona il metodo di autenticazione dei pacchetti + In esecuzione su %1$s (%2$s) %3$s, Android API %4$d, versione %5$s, %6$s + compilato da %s + versione di debug + versione ufficiale + Copia nel profilo + Dump del crash + Aggiungi + Invia file di configurazione + DN completo + La configurazione importata utilizza l\'opzione tls-remote che è obsoleta, ed utilizza un diverso formato DN. + RDN (nome comune) + Prefisso RDN + TLS-remote (obsoleto) + Puoi aiutare nella traduzione visitando http://crowdin.net/project/ics-openvpn/invite + %1$s tenta di controllare %2$s + Se procedi, concedi all\'applicazione l\'autorizzazione per intercettare tutto il traffico di rete. NON accettare se non consideri l\'applicazione attendibile, altrimenti corri il rischio che i tuoi dati vengano compromessi da programmi software dannosi + Considero questa applicazione attendibile. + Nessuna app ha il permesso di usare l\'API esterna + Apps abilitate;%s + Cancellare la lista delle apps esterne autorizzate?\nLista corrente di applicazioni autorizzate:\n\n%s + Sospende la VPN quando lo schermo è spento e meno di 64Kb di dati sono trasferiti in 60s. Quando l\'opzione \"Tun persistente\" è abilitata, la sospensione della VPN lascerà il tuo dispositivo con NESSUNA connettività di rete. Senza l\'opzione \"Tun persistente\" il dispositivo non avrà alcuna connessione/protezione VPN. + Sospende la connessione VPN dopo lo spegnimento dello schermo + Sospensione della connessione nello stato di schermo spento: meno di %1$s in %2$ss + Attenzione: \"Tun persistente\" non è abilitato per questa VPN. Quando lo schermo è spento verrà utilizzata la normale connessione internet. + Salva la Password + Pausa della VPN + Ricollega la VPN + Sospensione della VPN richiesta dall\'utente + VPN sospesa - schermo spento + Regolazioni specifiche per il dispositivo + Non è possibile visualizzare le informazioni del certificato + Comportamento dell\'applicazione + Comportamento della VPN + Abilita modifiche ai profili VPN + Raccoglitore chiavi hardware: + Un\'icona di applicazione sta tentando di usare OpenVPN per Android + "A partire da Android 4.3 la conferma della VPN viene salvaguardata da \"applicazioni in overlay\". Questo fa sì che il bottone di dialogo non reagisca allo sfioramento. Se avete un\'applicazione che usa gli overlay, ciò potrebbe causare questo comportamento. Se vi capita di trovare questo tipo di situazione, contattate l\'autore dell\'applicazione. Questo problema affligge tutte le applicazioni VPN da Android 4.3 in poi. Consultare anche <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=185\">Issue 185<a> per ulteriori dettagli" + Messaggio di conferma Vpn su Android 4.3 e versioni successive + In alternativa, potete inviarmi una donazione con il Play Store: + Grazie per la donazione di %s! + Registrazioni log cancellate. + Mostra password + Errore di accesso al Gestore Chiavi: %s + Breve + ISO + Indicazione oraria + Nulla + Upload + Download + Stato VPN + Visualizza opzioni + Eccezione non gestita: %1$s\n\n%2$s + %3$s: %1$s\n\n%2$s + Licenze complete + diff --git a/ics-openvpn-stripped/main/src/main/res/values-ja/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-ja/strings.xml new file mode 100755 index 00000000..162d56f0 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-ja/strings.xml @@ -0,0 +1,327 @@ + + + + + OpenVPN for Android + サーバアドレス + ポート番号 + 場所 + ディレクトリが読み取れません + 選択 + キャンセル + データなし + LZO 圧縮 + 証明書がありません。 + クライアント証明書 + クライアント証明書のキー + PKCS12ファイル + CA 証明書 + 証明書を選択する必要があります。 + ソースコードと問題管理はここにあります： http://code.google.com/p/ics-openvpn/ + プログラムは、次のコンポーネントを使用します。完全な詳細についてはソース上のライセンスを参照してください。 + バージョン情報 + プロファイル + 種別 + PKCS12のパスワード + 選択 + ファイルを選択する必要があります。 + TLS認証を使用します。 + TLS Direction + IPv6アドレスをCIDR形式で入力(例:2000:dd::23/64) + IPv4アドレスをCIDR形式で入力(例:1.2.3.4/24) + IPv4アドレス + IPv6アドレス + OpenVPNのカスタムオプションを入力します。利用には細心の注意が必要です。設定画面ではTUNモジュールの多くの設定がサポートされていません。もしほかに重要と思う設定があれば作者に連絡してください。 + ユーザー名 + パスワード + TLS認証鍵の設定は、静的キーとして使用されます。 + VPNの設定 + プロファイルの追加 + 新しいプロファイルを識別する名前を入力します + プロファイル名が重複しています。 + プロファイル名 + ユーザー証明書を選択する必要があります。 + エラーは見つかりませんでした。 + 設定に誤りがあります。 + IPv4 アドレスの解析エラー + カスタム経路の解析エラー + 必要に応じて入力するには空欄にしてください + OpenVPN のショートカット + VPNに接続 + ショートカットで指定されたプロファイルが見つかりません + ランダムなホスト プレフィックス + ランダムな6文字をホスト名の前に付加します。 + カスタム オプションを使用する + カスタムオプションを指定します。注意を要します。 + 経路がAndroidにより拒否されました。 + 切断 + VPNを切断します + ログをクリア + キャンセルの確認 + 接続中または試行中の接続をキャンセルしますか？ + VPN を削除 + リモートサーバー証明書の所有者識別子(Subject DN)を確認します。 + 証明書のホスト名を確認する + リモート証明書の照合に使用する識別名(DN)を指定します。(例: C=DE, L=Paderborn, OU=Avian IP Carriers, CN=openvpn.blinkt.de)\n\n完全な識別名(DN)または相対識別名(RDN)、あるいは相対識別名のプリフィクスを指定します。\n\nたとえば相対識別名のプリフィクスとして\"Server\"を指定すると、\"Server-1\"と\"Server-2\"にマッチします。\n\n空欄にした場合は相対識別名とサーバのホスト名をチェックします。\n\n詳細についてはOpenVPN 2.3.1以降のマニュアルの「--verify-x509-name」の項を参照してください。 + リモート証明書サブジェクト + TLS鍵認証を有効にする + TLS 認証ファイル + IPアドレス、経路情報、DNSなどの情報をサーバから取得します。 + サーバからは何も情報が取得できません。指定が必要な設定は以下の通りです。 + 情報取得の設定 + DNS + サーバ指定のDNSサーバ設定をオーバーライドします。 + DNSをユーザ側で指定します。 + 検索ドメイン + 使用する DNS サーバー + DNS サーバー + セカンダリDNSサーバーは、プライマリDNSサーバーに到達できない場合に使用します。 + セカンダリDNSサーバー + サーバ側指定の経路情報を無視する + サーバからプッシュされた経路情報を無視します。 + すべての通信をVPN経由にします + 既定の経路に使用 + カスタム経路を入力します。宛先のみをCIDR形式で指定します。例えば \"10.0.0.0/8 2002::/16\"と指定すれば10.0.0.0/8と2002::/16への通信はVPNに向けられます。 + カスタム経路情報 + 除外されたネットワーク + ログの詳細度 + 認証済みパケットをどのIPからでも受け付けます。 + フローティング サーバーを許可 + カスタム オプション + VPN 設定の編集 + VPN プロファイル %s を削除しますか？ + いくつかのカスタムICSイメージは、/dev/tunのパーミッションが異常か、TUNモジュールが含まれていません。CM9イメージの場合は全般設定で所有権設定を修正してください。 + TUNデバイスを開こうとして失敗しました。 + "エラー:" + クリア + tunインターフェースを開いています: + ローカル IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + DNSサーバ: %1$s, ドメイン: %2$s + 経路: %1$s %2$s + 除外された経路: %1$s %2$s + インターフェース情報として[%1$s]と[%2$s]を取得しました。2つめのアドレスはリモート側のピアアドレスです。32ビットマスクをローカルIPに使用します。 OpenVPNのモードは[%3$s]です。 + %1$sと%2$sではCIDR形式のIP経路情報として意味をなしません。32ビットマスクを使用します。 + 経路情報%1$s/%2$sを%3$s/%2$sに修正しました。 + Androidの証明書管理にアクセスできません。(ファームウェアの更新、アプリケーションまたはその設定のリストアによって発生する場合があります)。VPNの設定で証明書の選択を再度行ってください。 + %1$s %2$s + ログ ファイルを送信します。 + 送信 + ICS OpenVPN ログ ファイル + クリップ ボードにコピーされたログ エントリ + TAPモード + TAPモードは非root化環境では動作しません。よってこのアプリケーションではTAPをサポートできません。 + またですか？TAPモードはサポートされていませんし、サポートされるかどうかメールを送ることは何の役にも立ちません。 + ３回目です。本当のところ、TUN上で動くレイヤ2エミュレータを書くことはできました。(送信時の情報追加と受信時の情報削除で)。しかしこのエミュレータはARPやおそらくはDHCPをも実装しなければならないでしょう。誰もこのことに気がついていません。もしあなたがこの機能を作る気になったのであれば、どうぞ私に連絡してください。 + + よくある質問 + ログ エントリのコピー + 1行のログエントリをコピーするには、そのエントリをタッチし続けます。コピー／送信するには「ログエントリを送信」を使用します。GUIで表示されない場合はハードウェアのメニューボタンを使用してください。 + 起動ショートカット + OpenVPNを起動するためのショートカットをデスクトップに配置できます。ショートカットやウィジェットを配置できるかどうかはホームスクリーンプログラムに依存します。 + 申し訳ありませんが、お使いの環境ではVPNサービスがサポートされていません。 + 暗号化 + 暗号化方式を入力 + OpenVPNが暗号化に使用する暗号方式を入力してください。空欄にするとデフォルトを使用します。 + OpenVPNが使用する認証ダイジェストを入力します。空欄にするとデフォルトのダイジェストを使用します。 + 認証/暗号化 + ファイルを選択 + インライン ファイル + ファイルのインポート エラー + ファイルシステムからファイルをインポートできませんでした。 + [インライン ファイル データ] + IP情報なしでのTUNデバイス使用は拒否しています + OVPNファイルからプロファイルをインポート + インポート + インポートするプロファイルを読み取れませんでした。 + 構成ファイルの読み取りエラー + プロファイルの追加 + インポートされた構成ファイルに記載されたファイル %1$s が見つかりません。 + 構成ファイルを%1$sからインポートしています。 + ユーザインターフェースにマッピングされていないいくつかの設定項目があります。それらの設定はカスタムオプションとして追加されます。カスタムオプションを以下に表示します。 + 構成ファイルの読み取り終了。 + ローカル アドレスとポートにバインドを行いません。 + ローカルバインドしない + 構成ファイルのインポート + セキュリティに関する考慮事項 + OpenVPNがセキュリティに敏感であるように、セキュリティに関してのいくつかの注意事項は理にかなっています。 +SDカード上のデータは本質的に無防備です。すべてのアプリケーションが読み取り可能です。(たとえばこのプログラムはSDカードへの特別な読み取り許可を必要としていません) +このアプリケーションのデータは、自分自身のみが読み取り可能です。インポートされた証明書類はVPNプロファイルに保存されています。VPNプロファイルはこのアプリケーションからのみアクセス可能です。(あとでSDカード上のファイルを消すのを忘れないでください) +ただし、このアプリケーションからのみ読み取り可能ではあるものの、暗号化されてはいません。 +機体をroot化したり、あるいはその他の脆弱性によってファイルは読み取ることが可能かもしれません。パスワードは平文で保存されています。PKCS12ファイルをAndroidの証明書管理機能にインポートして使用することが強く推奨されます。 + インポート + 証明書の選択でエラーが表示されます + Android 4.0以降の証明書選択ダイアログ表示で例外を検知しました。 +この事象は標準的なAndroid 4.0以降では発生しません。お使いのAndroidの証明書管理機構が壊れている可能性があります。 + IPv4 + IPv6 + 状態メッセージを待っています。 + インポートされたプロファイル + インポートされたプロファイル %d + 壊れたイメージ + PKCS12ファイルの暗号化キー + 秘密鍵のパスワード + パスワード + ファイルのアイコン + TLS認証 + 生成された構成 + 設定 + システムに/dev/tunの所有者を設定します。いくつかのCM9のイメージでVPNService APIを動作させるために必要です。root権限が必要です。 + /dev/tun の所有権を修正 + 生成された OpenVPN の構成ファイルを表示します + \"%s\"の編集 + 構成中・・・ + この設定を有効にすると、ネットワークの状態変化時(WiFi／モバイル)に再接続を行います。 + ネットワーク変化時に再接続 + ネットワーク状態： %s + 認証局証明書（CA cert）は、通常、Android のキーストアから返されます。証明書の検証でエラーになる場合は、個別の証明書を指定します。 + 選択 + 認証局証明書（CA Cert）がAndroidのキーストアから取得できませんでした。認証はおそらく失敗します。 + 接続時にログウィンドウを表示します。ログウィンドウは常に状態通知からアクセスできます。 + ログウィンドウを表示 + 実行中：%1$s (%2$s)%3$s Android API %4$d + Androidキーストアに保存されたキー %1$s: %2$sの署名エラーです + VPN接続の警告は、このアプリケーションがVPNService APIを悪用してすべての通信を傍受できることを、システムがあなたに知らせるものです。\n +VPN接続通知(鍵の形)は、VPN接続が稼働中であることをAndroidが知らせています。いくつかのシステムではこの通知で音を鳴らします。\n +Androidはあなた自身の安全性のために、これらを迂回できないようにしています。(いくつかのシステムでは、遺憾ながら音も伴います) + 接続時の警告と通知音 + 日本語翻訳 高橋正希＠埼玉 <tools@artin.nu> + IPとDNS + 基本 + 経路設定 + 特殊なOpenVPNの設定。通常は必要ありません + 高度 + ICSのOpenVPN設定 + DNSサーバーが使用されていません。名前解決が動作しない可能性があります。カスタムDNSの設定を検討してください。また、DNSが指定されていない場合Androidはモバイル回線/WiFi接続に設定したプロキシを使用し続けることにも注意してください。 + DNSサーバ \"%1$s\" の追加に失敗しました。%2$sに拒否されました。 + IPアドレス \"%1$s\"を設定できませんでした。 システムに拒否されました: %2$s + <p>動作確認済の設定ファイルを入手します。(あなたのコンピュータでテスト済のものや、プロバイダや会社などの組織からダウンロードしたもの)</p> +<p>もしそれが単一のファイルでpemやpks12ファイルを伴わないなら、自分宛のメールに添付して送付し、それを開いてください。もし複数のファイルで構成されているならSDカードに格納してください。</p> +<p>メールの添付ファイルを開く、あるいはVPNリストのフォルダアイコンをクリックして設定ファイルをインポートします。</p> +<p>もしファイルが足りないというエラーが表示されたら、足りなかったファイルをSDカード上に格納してください。</p> +<p>インポートされたVPN設定をリストに追加するには、保存アイコンをクリックします。</p> +<p>VPNを接続するには、VPNの名称をクリックします。</p> +<p>もし警告やエラーがログエントリに表示されたら、それらを調べて解決してください。</p> + + クイックスタート + 接続の試行前にTUNデバイスモジュール(tun.ko)を読み込みます。デバイスのroot化が必要です。 + TUNモジュールをロード + PKCS12の設定をAndroidのキーストアにインポートします + プロキシ設定でエラー： %s + プロキシを使用します %1$s %2$d + システムのプロキシ設定を使用 + システム全体の構成の HTTP/HTTPS プロキシ接続を使用します。 + 以下のURLより寄付いただけます。 <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">PayPalで寄付</a> + OpenVPNはシステムの再起動やシャットダウン時に再接続するようになります。このオプションを使用する前にFAQをご一読ください。 + システム起動後に再接続 + 無視 + 再起動 + 設定の変更はVPNの再起動後に反映されます。VPNを(再)起動しますか？ + 設定が変更されました + 編集されたため、最後に接続したプロファイルを確認できませんでした + + 重複した通知 + もしAndroidがメモリ不足に陥った場合、その時点で必要とされないアプリケーションやサービスはアクティブなメモリから排除されます。 +この処理に伴い、VPN接続は終了されます。 +OpenVPNの接続を保証するためには、アプリケーションを高い優先度で稼働させます。 +高い優先度でアプリケーションを稼働させる場合、アプリケーションは通知を表示しなければなりません。 +鍵の形をした通知アイコンは、先述のFAQにあるとおりシステムにより表示させられたものです。 +高い優先度で稼働するための通知はアプリケーションの通知には含まれません。 + VPNのプロファイルが定義されていません + 新しいVPNを追加するには <img src=\"ic_menu_add\"/> のアイコンを使用します + SDカードからプロファイル(.ovpnや.conf)をインポートするには <img src=\"ic_menu_archive\"/> のアイコンを使用します。 + FAQを確認してください。クイックスタートガイドがあります。 + 経路情報／インターフェース設定 + OpenVPNが再接続試行中は、VPNなし状態を報告しません。 + 永続的なTUNデバイス + OpenVPN のログ + OpenVPN の構成のインポート + バッテリー消費量 + Androidのテザリング機能(WiFi, USB, Bluetooth経由)とVPNService API(このプログラムから使用する機能)は同時に利用できません。詳細については<a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\">issue #34</a>を参照 + VPN とテザリング + 接続の再試行回数 + 再接続の設定 + 再接続を試行する際の間隔(秒) + 接続間隔(秒) + OpenVPN は予期せず終了しました。メイン メニューでミニダンプの送信オプションを検討してください。 + ミニダンプを開発者に送信 + 最後にクラッシュした時のデバッグ情報を作者に送信します。 + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + 接続中 + サーバーの応答を待っています。 + 認証中 + クライアントの構成を取得中 + IPアドレスを割り当て中 + 経路を追加中 + 接続しました + 切断 + 再接続中 + 終了中 + 停止中 + ホスト名を解決中 + 接続中(TCP) + 認証に失敗しました + 使用可能なネットワークを待機中 + ↓%2$s/s %1$s - ↑%4$s/s %3$s + 未接続 + VPN %sに接続中 + VPN %sに接続中 + Android 4.1の一部のバージョンで、キーストアの証明書の名前にアルファベット以外の特殊な文字(スペース、アンダーバー、ダッシュ等)を含む場合に問題が発生します。証明書の名前から特殊な文字を外して再度インポートを試みてください。 + 暗号化方式 + パケット認証 + パケット認証方式を入力してください。 + %1$s (%2$s) %3$s、Android API %4$d、バージョン %5$s %6$s において実行中 + %s によりビルド + デバッグ ビルド + 正式ビルド + プロファイルにコピー + クラッシュ ダンプ + 追加 + 構成ファイルを送信 + 完全な識別名(DN) + あなたがインポートした設定は異なるDNフォーマットを使用した非推奨のtls-remoteオプションを使用しています。 + 相対識別名(RDN／共通名) + 相対識別名(RDN)プリフィクス + tls-remote (非推奨) + 翻訳作業を手伝っていただける方は次のURLへ http://crowdin.net/project/ics-openvpn/invite + %1$s は %2$s を制御しようとしています。 + 私はこのアプリケーションを信頼します + 外部APIの使用を許可されたアプリはありません + 許可アプリ: %s + 許可アプリの一覧をクリアしますか?\n現在の許可アプリ一覧:\n\n%s + スクリーンがオフかつ60秒で64kB以下のデータ転送量の場合、VPN通信を中断します。「永続的なTUN」設定が有効な場合、VPN接続が中断されると通信ができなくなります。「永続的なTUN」を無効にすると、VPNによる接続保護は行われなくなります。 + 画面オフ後にVPN接続を中断する + 警告: このVPN接続には永続的なTUNが設定されていません。スクリーンオフ後の通信は通常のインターネット接続を使用します。 + パスワードを保存 + VPN一時停止 + VPN再開 + ユーザによってVPN一時停止が要求されました + VPN一時停止中 - screenオフ + デバイス固有のhacks + 証明書の情報が表示できません。 + アプリケーションの挙動 + VPN の挙動 + VPNプロファイルの変更を許可する + ハードウェアのキーストア： + OpenVPN for Androidを使用しようと試みるアプリのアイコン + Android 4.3以降用VPN確認ダイアログ + ほかの手段として、Play Storeで私に寄付できます。 + ログがクリアされました。 + パスワードを表示する + キーチェーン アクセス エラー: %s + ISO + タイムスタンプ + なし + アップロード + ダウンロード + VPNの状態 + 未処理の例外: %1$s\n\n%2$s + %3$s: %1$s\n\n%2$s + もしあなたがデバイスをroot化しているのであれば、 <a href=\"http://xposed.info/\">Xposed framework</a>と<a href=\"http://repo.xposed.info/module/de.blinkt.vpndialogxposed\">VPN Dialog confirm module</a> を自己責任においてインストールできます + フルライセンス + ローカルインターフェイスに直接接続されているネットワークはVPNを経由しません。 +このオプションを外すとローカルネットワーク宛のすべての通信をVPNにリダイレクトします。 + いくつかのファイルが見つかりませんでした。プロファイルをインポートするファイルを選択してください： + インポートログ： + diff --git a/ics-openvpn-stripped/main/src/main/res/values-ko/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-ko/strings.xml new file mode 100755 index 00000000..61504764 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-ko/strings.xml @@ -0,0 +1,307 @@ + + + + + 안드로이드용 OpenVPN + 서버 주소: + 서버 포트: + 위치 + 폴더를 읽을 수 없습니다 + 선택 + 취소 + 데이터 없음 + LZO 압축 + 인증서 없음 + 클라이언트 인증서 + 클라이언트 인증서 키 + PKCS12 파일 + CA 인증서 + 인증서를 선택 해야 합니다 + 소스 코드와 문제 추적기는 http://code.google.com/p/ics-openvpn/에서 사용할 수 있습니다 + 프로그램은 다음 구성 요소를 사용합니다. 라이선스에 대 한 자세한 내용은 소스를 참조 하십시오 + 소개 + 프로파일 + 유형 + PKCS12 암호 + 선택… + 파일을 선택 해야 합니다 + TLS 인증 사용 + TLS 방향 + CIDR 형식의 IPv6 주소/넷마스크를 입력 (예: 2000:dd::23/64) + CIDR 형식의 IPv4 주소/넷마스크를 입력 (예: 1.2.3.4/24) + IPv4 주소 + IPv6 주소 + 사용자 정의 OpenVPN 옵션을 입력하세요. 매우 조심하세요. 또한 많은 tun과 연관된 OpenVPN 설정은 VPN 설정의 설계로 인하여 지원 되지 않습니다. 중요한 옵션이 누락됐다고 생각되면 저자에게 연락하십시오 + 계정 + 암호 + 고정설정에는 TLS인증 키가 고정키로 사용됩니다 + VPN 설정 + 프로파일 추가 + 새 프로 파일을 식별 하는 이름을 입력 하십시오 + 고유 프로필 이름을 입력 하십시오 + 프로 파일 이름 + 사용자 인증서를 선택 해야 합니다 + 오류 없음 + 설정 오류 + IPv4 주소 구문 분석 오류 + 사용자 지정 경로 구문 분석 오류 + (비워두면 요청시 쿼리됨) + OpenVPN 바로 가기 + VPN에 연결 하기 + 바로 가기에 지정 된 프로파일을 찾을 수 없습니다. + 임의의 호스트 접두사 + 6개 임의의 문자를 호스트 이름 앞에 추가 + 사용자 지정 옵션을 사용 하도록 설정 + 사용자 지정 옵션을 입력하세요. 주의해서 사용! + 안드로이드에 의해 거부된 라우트 + 연결 끊기 + VPN 연결 끊기 + 로그 지우기 + 취소 확인 + 연결된 VPN 끊기/연결시도 취소? + VPN 제거 + 서버가 TLS 서버 확장을 포함한 인증서를 사용하는지 여부 확인 (--remote-cert-tls server) + TLS 서버 인증서 바람 + 원격 서버 인증서 대상(Subject) DN을 확인 + 인증서 호스트명 확인 + 원격 인증서 DN을 확인 하는데 사용하는 검사를 지정 (예: C=DE, L=Paderborn, OU=Avian IP Carriers, CN=openvpn.blinkt.de)\n\n확인을 위해 완전한 DN이나 RDN (예 openvpn.blinkt.de) 또는 RDN 접두사를 지정.\n\nRDN 접두사 \"서버\"를 사용하면 \"서버-1\" 및 \"서버 2\"와 일치합니다\n\n텍스트 필드를 빈 상태로 두면 RDN은 서버의 호스트명과 비교됩니다\n\n더 자세한 내용은 OpenVPN 2.3.1+ 맨페이지에서 —verify-x509-name 아래를 참조 + 원격 인증서 제목 + TLS Key 인증 활성화 + TLS 인증 파일 + 서버로부터 IP 주소, 라우트와 타이밍 옵션을 요구합니다. + 서버로부터 정보를 요구하지 않습니다. 설정은 아래에 지정되야 합니다. + 설정 받기 + DNS + 서버에서 DNS 설정을 재정의합니다 + 지정한 DNS서버 사용하기 + searchDomain + 사용할 DNS 서버. + DNS 서버 + 보조 DNS 서버는 평소 DNS 서버에 접근불가시 사용됩니다. + 보조 DNS 서버 + 받은 라우트 무시하기 + 서버로부터 받은 라우트를 무시합니다. + VPN을 통해 모든 트래픽을 보냅니다. + 기본 라우트 사용하기 + 사용자 지정 라우트를 입력하십시오. 목적지는 CIDR 형식으로만 입력하십시오. \"10.0.0.0/8 2002::/16\"은 10.0.0.0/8 과 2002::/16 네트워크를 VPN으로 보냅니다. + 사용자 지정 라우트 + 로그의 자세한 정도 + 인증된 패킷은 IP와 상관없이 허용 + 플로팅 서버 허용 + 사용자 지정 옵션 + VPN 설정 편집 + VPN 프로 파일 \'%s\' 제거? + 일부 사용자 지정 ICS 이미지에서는 /dev/tun에 대한 권한이 잘못 되어 있거나 tun 모듈 자체가 누락 될 수 있습니다. CM9 이미지는 일반 설정에 있는 소유권 고치기 옵션을 사용해 보십시오. + Tun 인터페이스를 열지 못했습니다 + "오류:" + 지우기 + TUN 인터페이스 열기: + 로컬 IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + DNS 서버: %1$s, 도메인: %2$s + 인터페이스 정보 %1$s와 %2$s에 있어, 두 번째 주소를 원격 피어 주소로 가정 하겠습니다. 로컬 IP의 넷마스크로는 /32를 사용하겠습니다. OpenVPN에 의해 주어진 모드는 \"%3$s\" 입니다. + CIDR 넷마스크가 있는 IP 라우트 %1$s 와 %2$s 에 있어서 처리가 불가능합니다. /32를 넷마스크로 사용하겠습니다. + %1$s/%2$s 에서 %3$s/%2$s로 라우트 수정 + 안드로이드 키체인 인증서에 접근할 수 없습니다. 펌웨어 업그래이드 또는 백업된 앱/앱 설정을 복구하면서 발생할 수 있습니다. 인증서에 액세스할 수 있는 권한을 다시 생성하기 위해 VPN을 편집 하고 기본 설정 아래에서 인증서를 다시 선택 하십시오. + %1$s %2$s + 로그 파일 보내기 + 보내기 + ICS OpenVPN 로그 파일 + 클립보드로 로그 복사 + Tap 모드 + Tap 모드는 루트가 아닌 VPN API에서는 불가능합니다. 따라서 본앱은 tap지원을 제공할 수 없습니다 + 또? 농담인가요? 아니요 정말로 tap 모드는 지원이 불가능합니다. 계속해서 메일을 보내면서 요구하신다고 도움될 일이 아닙니다. + 3번째로? 누군가가 송신때 레이어2 정보를 추가하고 수신때 레이어2정보를 때내는 tun을 이용한 tap 에뮬레이터를 제작할 수 있습니다. 하지만 이것만이 아닌 ARP 그리고 어쩌면 DHCP 클라이언트 까지도 구현해야합니다. 본인은 이 같은 작업을 하는 분을 알고있지 않습니다. 코딩을 시작하려고 하시는 분이 계시면 제게 연락주십시오. + 자주 묻는 질문 + 로그 항목을 복사 + 단일 로그 항목을 복사 하려면 로그 항목을 누르고 계세요. 전체 로그를 복사/전송 하려면 로그 보내기 옵션을 사용하십시오. GUI에 표시 되지 않는 경우 하드웨어 메뉴 버튼를 사용하세요. + 시작으로 바로 가기 + 바탕 화면에 OpenVPN 시작 바로 가기를 배치할 수 있습니다. 당신의 homescreen 프로그램에 따라 바로 가기 또는 위젯 추가를 해야 합니다. + 당신의 이미지는 VPNService API를 지원 하지 않습니다, 죄송 합니다:( + 암호화 + 입력 암호화 방법 + OpenVPN이 사용할 암호화 암호 알고리즘을 입력 합니다. 기본 암호를 사용하려면 빈 공간으로 두십시오. + OpenVPN이 사용할 인증 다이제스트를 입력 합니다. 기본 다이제스트를 사용하려면 빈 공간으로 두십시오. + 인증/암호화 + 파일 탐색기 + 인라인 파일 + 파일 가져오기 오류 + 파일 시스템에서 파일을 가져올 수 없습니다. + [[인라인 파일 데이터]] + IP 정보가 없는 tun 장치 열기를 거부합니다 + Ovpn 파일에서 프로파일 가져오기 + 가져오기 + 가져올 프로 파일을 읽을 수 없습니다. + 설정 파일 읽기 오류 + 프로파일 추가 + 가져온된 설정 파일에 언급 된 파일 %1$s를 찾을 수 없습니다. + 원본 %1$s에서 설정 파일 가져오기 + 구성은 UI 구성으로 매핑되지 않는 몇 가지 구성 옵션을 가지고 있습니다. 이 옵션은 사용자 정의 구성 옵션으로 추가되었습니다. 사용자 정의 구성은 아래에 표시됩니다 : + 설정 파일 읽기 완료. + 로컬 주소와 포트로 바인드 안하기 + 로컬 바인딩 안함 + 구성 파일 가져오기 + 보안 고려 사항 + "OpenVPN은 보안에 민감하기 때문에 보안에 관련된 부분을 알고가는것이 현명합니다. SD카드의 있는 데이터는 기본적으로 보안이 취약합니다. 모든 앱이 읽을 수 있기 때문입니다 (예로 이 프로그램 또한 SD카드의 읽기 권한이 필요없습니다). 본앱의 데이터는 본앱만이 읽을 수 있습니다. cacert/cert/key를 파일 탐색기의 가져오기 옵션을 사용하면 데이터는 VPN 프로파일 내에 저장됩니다. VPN 프로파일은 본앱만이 접근할 수 있습니다. (잊지말고 SD카드에 있는 것을 삭제하세요). 접근은 본앱만이 가능하더라도 데이터는 암호화가 되어있지 않습니다. 루팅을 비롯한 다른 방법을 악용하여 데이터를 빼낼 수 있습니다. 암호 또한 일반 텍스트로 저장되어 있습니다. pkcs12 파일은 안드로이드 keystore에 보관할것을 강력하게 추천합니다." + 가져오기 + 인증서 선택 표시 오류 + 안드로이드 4.0+의 인증서 선택창을 보여주려는 과정에서 예외가 발생됐습니다. 안드로이드 4.0+의 표준 기능임으로 이 같은 일은 일어나면 안됩니다. 어쩌면 인증서 저장소에 대한 귀하의 안드로이드 ROM 지원이 깨졌습니다. + IPv4 + IPv6 + 상태 메시지를 기다리는 중… + 가져온 프로파일 + 가져온 프로파일 %d + 깨진 이미지 + <p>공식 HTC 이미지에서는 이상한 라우팅 문제로 트래픽이 터널로 통과 하지 않는 경우가 있는것으로 알려져 있습니다 (참고 <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=18\">Issue 18</a> 버그 추적기.)</p><p>Xperia arc S 와 Xperia Ray의 공식 SONY 이미지에서는 VPNService 자체가 완전히 없어진 것으로 보고 되었습니다. (참조 <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=29\">Issue 29</a> 버그추적기.)</p><p>일부 사용자를 위해 만들어진 이미지에서는 tun 모듈자체가 없거나 /dev/tun의 권한이 틀려있기도 합니다. 일부 CM9 이미지는 \"Device specific hacks\" 아래에 있는 \"Fix ownership\" 옵션을 사용해야 합니다.</p><p>가장 중요한 부분: 만약 깨진 이미지를 사용하는 경우라면 해당 공급업체에 보고해야 합니다. 업체에 문제를 보고하는 사람들이 많아야 수정될 가능성도 높아집니다..</p> + PKCS12 파일 암호화 키 + 개인 키 암호 + 암호 + 파일 아이콘 + TLS 인증 + 생성 된 설정 + 설정 + /dev/tun의 소유권을 시스템으로 설정 하려고 합니다. 일부 CM9 이미지에서 VPNService API를 사용하기 위해서는 앞의 작업이 요구됩니다. root권한을 가져야합니다. + /dev/tun 소유권 문제 해결 + 생성된 OpenVPN의 설정 파일 보기 + 수정 \"%s\" + 설정 만드는중… + 이 기능을 사용하면 네트워크 상태 변환시 강제로 재접속을 합니다 (예. WIFI 로/에서 모바일) + 네트워크 변화시 재접속 + 네트워크 상태: %s + CA 인증서는 일반적으로 안드로이드 Keystore에 있는것을 사용합니다. 인증서 오류 발생시 벌도의 인증서를 지정하세요. + 선택 + 안드로이드 keystore에서 CA 인증서를 찾지 못했습니다. Auhtentication은 실패할 것 입니다. + 연결시 로그 윈도우를 보여드립니다. 로그 윈도우는 항상 notification status에서 접근이 가능합니다. + 로그 윈도우 보기 + %1$s (%2$s) %3$s, 안드로이드 API %4$d 에서 실행 + 안드로이드 keystore 키 %1$s: %2$s과 싸이닝 오류 + 시스템에서는 VPN연결 경고를 통해 당신에게 본앱이 모든 트래픽을 가로챌수있다는 점을 알리게 되어 있는데 이는 VPNService API가 남용하는것을 막기 위함입니다.\nVPN 연결 알림 (키 아이콘) 또한 안드로이드 시스템에서 부과하는 부분이며 이는 VPN연결을 알리는 신호입니다. 어떤 버전에서는 소리를 알림으로 사용하는 경우도 있습니다.\n안드로이드는 이같은 방법을 당신의 안전을 위해 도입하였으며 사용은 필수적입니다. (어떤 버전에서는 유감스럽게도 소리 알림 또한 포함됩니다.) + 연결 경고 및 알림 소리 + 한국어 번역 (주)기가드 안규태<ktdann@gmail.com> + IP 와 DNS + 기본 + 라우팅 + 모호한 OpenVPN 설정. 일반적으로 필요하지 않습니다. + 고급 + ICS Openvpn 설정 + DNS 서버가 미사용중입니다. 이름 변환이 작동 않을 수 있습니다. 사용자 지정 DNS 서버를 설정 하십시오. 또한 안드로이드는 DNS서버가 없는 경우 모바일/Wi-Fi 연결에 저정된 프록시 설정을 계속해서 사용한다는 점을 유의하시기 바랍니다. + DNS서버 \"%1$s\" 는, 시스템에 의해 거부되 추가할 수 없습니다: %2$s + %2$s: 시스템에 의해 거부되어 IP 주소 \"%1$s\"를 설정하지 못하였습니다 + <p>문제없는 설정을 확보하세요 (당신의 컴퓨터에서 테스트 된것 또는 공급자/조직에서 다운받은)</p><p>이것이 단일 파일이며 추가 pem/pks12 파일이 없는 경우면 본인에게 이메일로 보내어 첨부파일을 열면 됩니다. 여러 파일인 경우 당신의 sd card에 넣으세요.</p><p>이메일 첨부파일을 클릭하세요/vpn목록에 있는 폴더 아이콘을 사용하여 설정 파일을 가져옵니다.</p><p>파일 누락 오류 발생시 누락된 파일을 sd card에 복사하세요.</p><p>저장 기호를 클릭하여 VPN 목록에 가져온 VPN을 추가 하세요.</p><p>VPN 이름을 클릭하여 VPN을 연결하세요.</p><p>오류 또는 경고가 로그에 있는 경우 오류/경고를 이해하여 이들을 해결하십시오.</p> + 빠른 시작 + 연결을 시도 하기 전에 tun.ko 커널 모듈을 로드하세요. 루팅된 장치야만 합니다. + tun 모듈 로드하기 + 설정에 있는 PKCS12를 안드로이드 keystore로 가져오기 + 프록시 설정 가져오기 오류: %s + 프록시 %1$s %2$d 을 사용 + 시스템 프록시를 사용 + 연결시 전 시스템 설정에 있는 HTTP/HTTPS 프록시를 사용합니다. + 당신은 <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">PayPal을 사용하여 기부할 수 있습니다.</a> + OpenVPN은 시스템 재부팅/종료에 활성화 되었으면 VPN을 다시 연결합니다. 이 옵션을 사용 하기 전에 연결 경고 FAQ를 읽어 보시기 바랍니다. + 재부팅시 다시 연결 + 무시 + 다시 시작 + VPN을 다시 시작한 후 설정 변경 내용이 적용 됩니다. VPN을 지금 (재)시작? + 설정 변경 + 편집을 위해 마지막으로 연결 된 프로파일을 확인할 수 없습니다. + 중복 알림 + 안드로이드는 시스템의 메모리 (RAM) 가 부족한 경우, 현재 필요하지 않는 앱들과 서비스들을 활성화 메모리에서 삭제합니다. 이 과정에서 진행중인 VPN 연결이 끊어 집니다. 이렇게 되지 않기 위해서 OpenVPN 서비스는 우선순위가 높게 되어 실행됩니다. 높은 우선 순위로 실행되기 위해서는 응용프로그램에서 이를 알림으로 표시해야 합니다. 키 알림 아이콘은 이전 FAQ에서 설명된 대로 시스템에서 강요하기 때문입니다. 이것은 우선 순위가 높이 실행된다는 알림에 대한 알림이 아닙니다. + VPN 프로파일이 정의 않됐습니다. + 이 <img src=\"ic_menu_add\"/> 아이콘을 사용하여 VPN을 추가 하세요 + 이 <img src=\"ic_menu_archive\"/> 아이콘을 사용하여 귀하의 sdcard에서 기존 (.ovpn 또는 .conf) 프로파일을 가져오세요. + 꼭 FAQ를 확인 하세요. 빠른 시작 가이드가 있습니다. + 라우팅/인터페이스 설정 + OpenVPN을 다시 연결 하는 경우 VPN 연결 없음으로 표기하지 마십시오. + tun 유지 + OpenVPN 로그 + OpenVPN 설정 가져오기 + 배터리 소모 + 제 개인적인 테스트에서 Openvpn의 높은 배터리 소비에 대한 주요 이유는 keepalive 패킷 때문이었습니다. 대부분의 OpenVPN 서버 설정에는 \'keepalive 10 60\' 와 같은 문구가 있는데 이는 클라이언트에서 서버로 서버에서 클라이언트로 keepalive 패킷을 10 초 마다 보냅니다. <p> 이러한 패킷은 작고 많은 트래픽을 사용 하지 않습니다만 이들은 모바일 라디오 네트워크를 계속 유지하게 만들게되고 따라서 에너지 소비를 증가 합니다. (참조 <a href=\"http://developer.android.com/training/efficient-downloads/efficient-network-access.html#RadioStateMachine\">The Radio State Machine | Android Developers</a>) <p> 이 keepalive 설정을 클라이언트에서 변경할 수 없습니다. OpenVPN의 시스템 관리자만 설정을 변경할 수 있습니다. <p> 불행히도 udp를 사용할때 keepalive값을 60초 이상으로 하면 일부의 NAT 게이트웨이에서는 비활성 타임아웃 때문에 연결을 끊어버리게 됩니다. TCP와 긴 keepalive 만료기간을 함께 사용할 수는 있지만 패킷 손실이 높은 연결구간에서는 TCP over TCP의 성능이 매우 저조합니다. (참조 <a href=\"http://sites.inka.de/bigred/devel/tcp-tcp.html\">왜 TCP를 통한 TCP는 안좋은 방법인지</a>) + 안드로이드 테더링 기능 (WiFi, USB 또는 블루투스를 통한)과 VPNService API (이 프로그램에서 사용됨)는 함께 작동 하지 않습니다. 자세한 내용은 <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\">issue #34</a> 를 참조 하십시오 + VPN과 테더링 + 다시 연결 + 다시 연결 설정 + 연결 시도 사이의 기다리는 초단위 주기 입니다. + 연결과 연결 사이의 초단위 기간 + OpenVPN이 예기치 않게 종료됐습니다. 메인 메뉴에 있는 미니 덤프 보내기 옵션의 사용을 고려 하시기 바랍니다 + 미니 덤프를 개발자에게 보내기 + 개발자에게 마지막 비정상종료에 대한 디버깅 정보를 보냅니다 + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + 연결중 + 서버 응답 대기중 + 인증중 + 클라이언트 구성 가져오는중 + IP 주소 할당중 + 노선 추가중 + 연결됨 + 연결 끊기 + 재연결중 + 종료중 + 실행안됨 + 호스트명 찾는중 + 연결중 (TCP) + 인증 실패 + 사용 가능한 네트워크 대기중 + ↓%2$s/s %1$s - ↑%4$s/s %3$s + 연결 되지 않음 + VPN %s 연결중 + VPN %s 연결중 + 일부 버전의 안드로이드 4.1에서는 키 인증서의 이름에 비 영숫자 문자(공백, 밑줄 또는 대시)가 포함 된 경우 문제가 있습니다. 특수 문자 없는 인증서를 다시 가져와 시도해보세요 + 암호화 암호 + 패킷 인증 + 패킷 인증 방법을 입력한다 + %1$s (%2$s) %3$s, 안드로이드 API %4$d, 버전 %5$s, %6$s에서 실행 + 개발자 %s + 디버그 빌드 + 공식 빌드 + 프로파일에 복사 + 크래시 덤프 + 추가 + 설정 파일 보내기 + 완전한 DN + 가져온 구성에는 다른 DN 형식을 사용하는 오래된 tls-remote옵션이 있는데 이는 더이상 지원되지 않습니다. + RDN (common 이름) + RDN 접두사 + tls-remote (지원 되지 않음) + http://crowdin.net/project/ics-openvpn/invite를 방문 하여 번역을 도울 수 있습니다 + %1$s 이(가) %2$s 을(를) 제어하려고 시도 + 다음 진행으로, 당신은 OpenVPN for Android 응용프로그램에게 완벽한 제어권과 모든 네트워크 트래픽을 가로챌 수 있는 권한을 허락합니다. 앱을 신뢰하지 않는다면 허락하지 마십시오. 그렇지 않으면, 당신은 당신의 데이터를 악성 소프트웨어에게 빼앗길 수 있습니다.\" + 나는 이 프로그램을 신뢰합니다. + 어떤 응용 프로그램도 외부 API를 사용할 수 없습니다 + 허용된 앱: %s + 허용된 외부 앱의 목록을 삭제하겠습니까?\n현재 허용된 외부 앱:\n\n%s + \"화면이 꺼져있을때 60초동안 64kB 미만의 데이터가 전송되면 VPN 일시정지. \"Persistent Tun\" 옵션이 활성화되어 있으면 VPN 일시 정지시 당신의 장비는 네트워크가 끊어 집니다. \"Persistent Tun\" 옵션이 없는 경우 장비는 VPN 연결/보호를 잃습니다. + 화면 꺼짐 후 VPN 연결 일시 정지 + 화면이 꺼진 상태에서 일시 중지: %2$ss에서 %1$s 미만 + 경고: 이 VPN은 persistent tun이 비활성화 되어있습니다. 화면이 꺼졌을 때 트래픽은 터널을 사용하지 않고 인터넷을 바로 사용합니다. + 암호 저장 + VPN 일시중지 + VPN 일시 정지 사용자의 요청 + VPN 일시정지됨 - 화면 끄기 + 장치 관련 Hacks + 인증서 정보를 표시 할 수 없습니다 + 응용 프로그램 동작 + VPN 동작 + VPN 프로필에 대한 변경을 허용 + 하드웨어 키 스토어: + 응용 프로그램의 아이콘이 OpenVPN for Android를 사용 하려고함 + "안드로이드 4.3부터는 VPN 확인이 \"overlaying apps\"로 부터 보호 받게 됩니다. 따라서 입력창이 터치 입력에 반응하지 않을 수 있습니다. 사용하는 앱중에서 overlay를 사용하는 경우 이러한 문제가 발생될수있습니다. 문제의 앱을 제작한 프로그램어를 연락하십시오. 이 문제는 안드로이드 4.3과 이상의 버전에서 모든 VPN 응용 프로그램에 영향을 줍니다. <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=185\">Issue 185<a> 참조" + 안드로이드 4.3과 이후 버전에서의 VPN 확인 창 + 또는 당신은 플레이 스토어와 나에게 기부금을 보낼 수 있습니다: + %s 님! 기부 감사합니다 + 로그가 삭제되었습니다. + 비밀 번호 표시 + 키체인 접근 오류: %s + 짧은 + ISO + 타임 스탬프 + 없음 + 업로드 + 다운로드 + Vpn 상태 + 옵션 보기 + 처리 되지 않은 예외: %1$s\n\n%2$s + %3$s: %1$s\n\n%2$s + 전체 라이센스 + diff --git a/ics-openvpn-stripped/main/src/main/res/values-nl/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-nl/strings.xml new file mode 100755 index 00000000..a7ae78fd --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-nl/strings.xml @@ -0,0 +1,125 @@ + + + + + OpenVPN voor Android + Server Adres: + Server Poort: + Locatie + Map is onleesbaar + Selecteer + Annuleer + Geen Gegevens + LZO Compressie + Geen Certificaat + Client Certificaat + Client Certificaat Sleutel + PKCS12 Bestand + CA Certificaat + Je moet een certificaat selecteren + De broncode en bugs zijn te vinden op http://code.google.com/p/ics-openvpn/ + Het programma gebruikt de volgende componenten. Zie de broncode voor volledige details over de licenties. + Over + Profielen + Type + PKCS12 Wachtwoord + Selecteer… + Je moet een bestand selecteren + Gebruik TLS autentificatie + TLS Richting + Voer een IPv6 Adres/Netmask in met het CIDR Formaat (v.b. 2000:dd::23/64) + Voer een IPv4 Adres/Netmask in met het CIDR Formaat (v.b. 1.2.3.4/24) + IPv4 Adres + IPv4 Adres + Geavanceerde OpenVPN opties. Veel van de tun gerelateerde OpenVPN instellingen worden niet ondersteund. Als u denkt dat een belangrijke optie ontbreekt, neem dan contact op met de auteur. + Gebruikersnaam + wachtwoord + Voor de statische configuratie worden de TLS Auth keys als statische sleutels gebruikt + VPN configureren + Profiel toevoegen + Voer een naam in voor het nieuwe Profiel + Profielnaam is al in gebruik + Profiel name + Geen gebruikerscertificaat geselecteerd + Geen fout. + Fout in de configuratie + Fout bij inlezen van IPv4-adres + Fout bij inlezen van aangepaste routes + (vrij laten voor query op aanvraag) + Open VPN shortcut + Met VPN verbinden + Het profiel zoals aangegeven in de snelkoppeling kon niet gevonden worden. + Willekeurig Host Voorvoegsel + Voegt 6 willekeurige tekens toe voor de hostname + Eigen configuratie opties + Geef je eigen configuratieopties aan. Wees voorzichtig! + Route geweigert door Android + Verbinding verbreken + VPN verbinding verbreken + logboek wissen + Annuleer bevestiging + Sluit de verbonden VPN af/annuleer de verbindingspoging? + VPN wissen + Controleert of de server een certificaat met TLS Server extensions gebruikt (--remote-cert-tls server) + Verwacht TLS server-certificaat + Controleert de externe server certificaathouder + Controleer Certificaat Hostname + Externe certificaathouder + Activeert TLS Key verificatie + TLS Auth Bestand + Vraag IP adres, routes en timing opties van de server. + De server vraagt geen informatie op. Instellingen moeten onderaan worden gespecificeerd. + Pull Instellingen + DNS + DNS Instellingen van Server Overschrijven + Gebruik eigen DNS Servers + Zoekd domein + Primaire DNS server + DNS Server + Secundaire DNS server. Deze wordt gebruikt voor het geval dat de primaire DNS server niet bereikbaar is + Backup DNS server + Negeer ontvangen routes + Negeer routes ontvangen van de server. + Leid al het Verkeer over de VPN + Gebruik standaard Route + Eigen routes + Geverifieerde pakketen zijn vanuit elk IP toegestaan + Zwevende server toestaan + Aangepaste Opties + VPN Instellingen Bewerken + De VPN-profiel \'%s\' verwijderen? + "Fout:" + Leeg maken + Lokaal IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + %1$s %2$s + Logboek verzenden + Verzenden + Tap mode + De VPN API van Android werkt zonder rooten van de telefoon en ondersteunt alleen de tun modus. Daarom is de tap modus niet mogelijk met deze app. + Veelgestelde vragen + Codering + Codering methode + Import + Profiel toevoegen + Kon het bestand %1$s, zoals aangegeven in de geïmporteerde configuratie niet vinden + Geïmporteerde configuratie bestand uit %1$s + Lezen van configuratie bestand afgesloten. + Geen locale binding + configuratie bestand importeren + Beveiligingsoverwegingen + Importeren + Fout bij het weergeven van de certificaat selectie + IPv4 + IPv6 + Wachten op status bericht… + Geïmporteerd profiel + Geïmporteerd profiel %d + Niet Werkende Afbeeldingen + PKCS12 Bestand Encryptie Sleutel + Privé Sleutel Wachtwoord + Wachtwoord + bestands pictogram + TLS Verificatie + Gegenereerde Configuratie + IP en DNS + diff --git a/ics-openvpn-stripped/main/src/main/res/values-no/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-no/strings.xml new file mode 100755 index 00000000..23af8c31 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-no/strings.xml @@ -0,0 +1,128 @@ + + + + + OpenVPN for Android + Server adresse: + Server port: + Plassering + velg + Avbryt + Ingen Data + LZO-komprimering + Ingen sertifikat + Klient sertifikat + Klientsertifikat nøkkel + PKCS12 fil + CA-sertifikat + Om + Type + PKCS12 passord + Velg… + Bruke TLS-godkjenning + TLS-retning + Angi IPv6-adresse/nettmaske i CIDR format (f.eks 2000:dd::23/64) + Angi IPv6-adresse/nettmaske i CIDR format (f.eks 1.2.3.4/24) + IPv4-adresse + IPv6-adresse + Brukernavn + Passord + Konfigurer VPN + Legge til profil + Angi et navn som identifiserer den nye profilen + Profilnavn + Ingen feil funnet + Feil i konfigurasjonen + OpenVPN snarvei + Koble til VPN + Tilfeldig vert prefiks + Aktiver egendefinerte valg + Koble fra + Tøm logg + Avbryt bekreftelse + Fjern VPN + TLS-Auth-fil + DNS + Bruk din egen DNS-server + DNS-Server som skal brukes. + DNS-server + Bruk standard rute + Egendefinert rute + Detaljnivå for Logging + Egendefinerte valg + Rediger VPN-innstillinger + "Feil:" + Fjern + %1$s %2$s + Send loggfilen + Send + ICS OpenVPN loggfil + Tap modus + FAQ + Kopier loggoppføringer + Snarvei til start + Kryptering + Angi krypteringsmetode + Autentisering/kryptering + Filutforsker + Feil ved import av fil + Kunne ikke importere filen fra filsystemet + Importer profil fra ovpn-fil + Importer + Kan ikke lese profil for importering + Feil under lesing av config-filen + legg til profil + Finner ikke filen %1$s nevnt i importert konfigurasjons fil + Importerer konfigurasjonsfilen fra kilde %1$s + Ferdig med å lese konfigurasjons-filen. + Ingen lokale binding + Importer konfigurasjonsfil + Sikkerhetsvurderinger + Importer + Feil ved visning av sertifikatvalg + IPv4 + IPv6 + Venter på tilstands melding… + importert profil + importert profilen %d + Ødelagte bilder + PKCS12 Filkrypteringsnøkkel + Privat nøkkel passord + Passord + fil ikon + TLS-godkjenning + Generert konfigurasjon + Fiks eierskap av /dev/tun + Rediger \"%s\" + Lager konfigurasjon… + Koble til på nytt ved nettverks endring + Nettverksstatus: %s + Velg + Vis logg-vindu + Kjører på %1$s (%2$s) %3$s, Android API %4$d + Norsk oversettelse av Jonny + IP og DNS + Grunnleggende + Ruting + Avansert + ICS Openvpn konfigurasjon + Hurtigstart + Prøv å laste tun.ko kjernemodul før tilkobling. Krever at enheten er rootet. + Last tun modul + Feil ved henting av proxy-innstillinger: %s + Bruker proxy %1$s %2$d + Bruk systemet proxy + Bruk global systemkonfigurasjon for HTTP/HTTPS proxy for å koble til. + Du kan <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">donere med PayPal</a> + Koble til på nytt ved restart + Ignorer + Start på nytt + Konfigurasjon endret + Kopier varsler + Ingen VPN-profiler er definert. + Ruting/grensesnitt-konfigurasjon + Ikke gå tilbake til ingen VPN-tilkoblingen mens OpenVPN kobler til på nytt. + OpenVPN Logg + Importer OpenVPN konfigurasjon + Batteriforbruk + diff --git a/ics-openvpn-stripped/main/src/main/res/values-pl/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-pl/strings.xml new file mode 100755 index 00000000..5c96d94c --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-pl/strings.xml @@ -0,0 +1,260 @@ + + + + + OpenVPN dla Androida + Adres serwera: + Port serwera: + Lokalizacja + Nie można odczytać katalogu + Wybierz + Anuluj + Brak danych + Kompresja LZO + Brak certyfikatu + Certyfikat klienta + Klucz certyfikatu klienta + Plik PKCS12 + Certyfikat urzędu certyfikacji + Musisz wybrać certyfikat + Kod źródłowy i formularz zgłoszeniowy błędów dostępny pod http://code.google.com/p/ics-openvpn/ + Program ten wykorzystuje następujące składniki; Szczegółowe informacje o licencjach w kodzie źródłowym + O + Profile + Typ + Hasło PKCS12 + Wybierz… + Wybierz plik + Użyj uwierzytelniania TLS + Kierunek TLS + Wprowadź adres IPv6 w formacie CIDR (np. 2000:dd::23 / 64) + Wprowadź adres IPv4 w formacie CIDR (np. 1.2.3.4/24) + Adres IPv4 + Adres IPv6 + Wprowadź ustawienia niestandardowe OpenVPN. Używać z rozwagą. Należy również pamiętać, że wiele ustawień związanych z tun OpenVPN nie jest obsługiwana przez projekt VPNSettings. Jeśli uważasz, że brakuje ważnych opcji skontaktuj się z autorem + Nazwa użytkownika + Hasło + W konfiguracji statycznej klucze uwierzytelniania TLS zostaną wykorzystane jako statyczne klucze + Konfiguracja VPN + Dodaj profil + Wprowadź nazwę określającą nowy profil + Wybierz unikalną nazwę profilu + Nazwa profilu + Musisz wybrać certyfikat użytkownika + Brak błędów + Błąd w konfiguracji + Błąd parsowania adresu IPv4 + Błąd parsowania niestandardowych tras + (Pozostaw puste, aby wywołać na żądanie) + Skrót OpenVPN + Połącz się z siecią VPN + Nie odnaleziono profilu określonego w skrócie + Losowy prefiks hosta + Dodaje 6 losowych znaków przed nazwą hosta + Włącz opcje niestandardowe + Określ niestandardowe opcje. Ostrożnie! + Trasa odrzucona przez Androida + Rozłącz + Rozłącz VPN + Wyczyść log + Anuluj potwierdzenie + Odłącz podłączone VPN / zrezygnować z próby połączenia? + Usuń VPN + Oczekiwanie na certyfikat TLS z serwera + Weryfikuj nazwę domenową zawartą w certyfikacie + Temat zdalnego certyfikatu + Włącza uwierzytelnianie kluczem TLS + Plik TLS + Pobierz ustawienia + DNS + Nadpisz DNS z serwera + Użyj własnych serwerów DNS + Używany serwer DNS. + Serwer DNS + Pomocniczy serwer DNS używany, jeśli normalny serwer DNS jest nieosiągalny. + Zapasowy serwer DNS + Ignoruj trasy + Ignoruj trasy serwera. + Przekieruj cały ruch przez tunel VPN + Użyj domyślnej trasy + Opcjonalne trasy + Poziom logowania + Zezwalaj uwierzytelnionym pakietom z każdego IP + Opcje użytkownika + Edytuj ustawienia VPN + Usunąć profil VPN \'%s\'? + Na niektórych customowych kompilacjach ICS może występować problem z uprawnieniami do /dev/tun albo występować problem z brakującymi częściami tun. Dla obrazów CM9 spróbuj poprawić uprawnienia za pomocą ustawień. + Nie można otworzyć interfejsu tun + "Błąd:" + Czyść + Otwieram interfejs tun: + Lokalne IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + Serwer DNS: %1$s, Domena: %2$s + %1$s %2$s + Wyślij loga + Wyślij + Plik logów ICS OpenVPN + Skopiowano log do schowka + Tryb TAP + Tryb TAP nie jest możliwy z nierootwanym API VPN. Dlatego ta aplikacja nie zapewnia wsparcia TAP + Znowu. Żartujesz sobie? Tryb tap jest naprawdę nie wspierany, a wysyłanie więcej maili o to czy będzie wsparcie wcale nie pomoże. + FAQ + Kopiowanie wpisów dziennika + Aby skopiować pojedynczy wpis dziennika, naciśnij i przytrzymaj interesującą Cię pozycję. Celem skopiowania całego dziennika, należy użyć opcji Wyślij Log - jeżeli nie jest widoczna, użyj klawisza menu na obudowie urządzenia. + Skrót do startu + Możesz umieścić skrót uruchamiający OpenVPN na swoim pulpicie. W zależności od używanej wersji oprogramowania, musisz dodać widget lub skrót na ekran główny. + Twój obraz nie wspiera API VPN, przepraszamy ;( + Szyfrowanie + Wprowadź metodę szyfrowania + Wybierz algorytm szyfrowania wykorzystywany przez OpenVPN. Pozostaw puste, aby skorzystać z ustawień domyślnych. + Wprowadź dane logowania użyte do OpenVPN. Pozostaw puste, aby skorzystać z ustawień domyślnych. + Uwierzytelnianie/Szyfrowanie + Manager plików + Błąd importu pliku + Nie można zaimportować pliku z systemu + [[Inline file data]] + Wczytaj profil z pliku ovpn + Wczytaj + Nie można odczytać Profilu do importu + Błąd podczas czytania pliku konfiguracyjnego + Dodaj profil + Nie można znaleźć pliku %1$s zawartego w zaimportowanym pliku + Importowanie pliku konfiguracyjnego ze źródła %1$s + Skończono czytać plik konfiguracyjny. + Nie przypisuj do lokalnego adresu i portu + Importuj plik konfiguracji + Importuj + IPv4 + IPv6 + Oczekiwanie na wiadomość powitalną… + Uszkodzone obrazy + Klucz pliku PKCS12 + Hasło klucza prywatnego + Hasło + plik ikony + Uwierzytelnianie TLS + Wygenerowana konfiguracja + Ustawienia + Popraw uprawnienia do /dev/tun + Pokazuje wygenerowany plik konfiguracji OpenVPN + Edycja \"%s\" + Tworzenie konfiguracji… + Włączenie tej opcji spowoduje ponowne połączenie jeśli stan sieci się zmienił (np. z WiFi na GSM) + Połącz ponownie przy zmianie sieci + Status sieci: %s + Wybierz + Pokaż okno loga + Ostrzeżenie połączeń oraz dźwięki powiadomień + Angielskie tłumaczenie Arne Schwabe<arne@rfc2549.org> + IP i DNS + Podstawowe + Routing + Zaawansowane + Konfiguracja ICS Openvpn + Nie można dodać serwera DNS \"%1$s\", odrzucone przez system: %2$s + Szybki start + Próba załadowania modułu tun.ko kernel przez próbą połączenia. Potrzeba rootowanych urządzeń. + Załaduj moduł tun + Importuj PKCS12 z konfiguracji do slepu kluczy Androida + Błąd ustawień proxy: %s + Użycie proxy %1$s%2$d + Użyj proxy systemowego + Użyj konfiguracji systemowej dla HTTP/HTTPS proxy w celu połączenia. + Możesz <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">wspomóc przez PayPal</a> + OpenVPN połączy VPN jeśli był aktywny przy restarcie/zamknięciu systemu. Proszę przeczytać FAQ ostrzeżenia połączenia przez użyciem tej opcji. + Połącz przy reboocie + Ignoruj + Restartuj + Zmiany konfiguracji będą zatwierdzone po restarcie VPN. Uruchomić ponowie teraz? + Zmieniono konfigurację + Nie można ustalić ostatnio połączonego profilu do edycji + Podwójne powiadomienia + Nie zdefiniowano żadnego profilu. + Sprawdź także nasze FAQ. Znajdziesz tam krótki poradnik dla początkujących. + Konfiguracja trasy/interfejsu + Persistent tun + Log OpenVPN + Importuj konfigurację OpenVPN + Zużycie baterii + VPN i Tethering + Próby połączenia + Ustawienia ponownego połączenia + Liczba sekund oczekiwania między próbami połączenia. + Sekundy pomiędzy połączeniami + OpenVPN niespodziewanie uległ awarii. Proszę rozważ użycie opcji wyślij Minidump w głównym menu + Wyślij minidump do autora + Wysyłam informacje debuggera o ostatniej awarii aplikacji do twórcy + OpenVPN - %s + %1$s-%2$s + %1$s-%3$s,%2$s + Łączę + Czekam na odpowiedź serwera + Uwierzytelnianie + Pobieranie konfiguracji klienta + Przypisywanie adresów IP + Dodaję trasy + Połączony + Odłączony + Łączę ponownie + Zamykanie + Nie działa + Rozpoznwanie nazw hostów + Łączenie (TCP) + Błąd autentykacji + Czekam na sieć + ↓%2$s/s %1$s - ↑%4$s/s %3$s + Niepołączony + Łączę z VPN %s + Łączę z VPN %s + Niektóre wersje Androida 4.1 mają problemy, jeśli nazwa certyfikatu zawiera niealfanumeryczne znaki (spacje, podkreślenia, myślniki). Spróbuj zaimportować certyfikat bez znaków specjalnych + Pakiety uwierzytelniania + Wpisz metodę uwierzytelniania pakietów + Działa na %1$s (%2$s) %3$s, Android API %4$d, wersja %5$s, %6$s + zbudowany przez %s + Kompilacja z debugiem + Oficjalna kompilacja + Skopiuj do profilu + Zrzut + Dodaj + Prześlij plik konfiguracyjny + Kompletny DN + Zaimportowana konfiguracja używa przestarzałej opcji tls-remote, która używa innego formatu DN. + RDN (bieżąca nazwa) + Prefiks RDN + tls-remote (PRZESTARZAŁE) + Możesz pomóc w tłumaczeniu odwiedzająć http://crowdin.net/project/ics-openvpn/invite + %1$s próby kontroli %2$s + Ufam tej aplikacji. + Żadna aplikacja nie ma pozwolenia do używania zewnętrznego API + Dozwolone aplikacje: %s + Wyczyścić listę dozwolonych aplikacji?\nObecna lista dozwolonych aplikacji:\n\n%s + \"Wstrzymaj VPN kiedy wyświetlacz jest wyłączony i mniej niż 64kB danych przetransmitowano w 60s. Kiedy opcja \"Persistent Tun\" jest włączona wstrzymanie VPN zostawi twoje urządzenie bez połączenia. Bez opcji \"Persistent Tun\" urządzenie nie będzie miało połączenia/ochrony VPN. + Wstrzymaj połączenie VPN po wyłączeniu wyświetlacza + Wstrzymanie połączenia na wyłączonym ekranie: w mniej niż %1$s na %2$ss + Ostrzeżenie. Persistent tun nie włączone dla tego VPN. Połączenie będzie generować ruch normalnego połączenia przy wyłączonym ekranie. + Zapisz hasło + Wstrzymaj VPN + Wznów VPN + Wstrzymanie VPN na żądania użytkownika + VPN zatrzymany - ekran wyłązony + Informacje dotyczące haków w urządzeniu + Nie można wyświetlić informacji o certyfikacie + Zachowanie aplikacji + Zachowanie VPN + Zezwól na zmiany profili VPN + Sprzętowy magazyn kluczy: + Ikona aplikacji próbującej użyć OpenVPN + Potwierdzenie dla Android w wersji 4.3 i wyższych + Alternatywnie, dotację możesz przesłać za pomocą Google Play: + Dziękujemy za wsparcie %s! + Dziennik wyczyszczony. + Pokaż hasło + Błąd dostępu do klucza: %s + Krótki + ISO + Znaczniki czasu + Brak + Wysyłanie + Pobieranie + Status VPN + diff --git a/ics-openvpn-stripped/main/src/main/res/values-ro/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-ro/strings.xml new file mode 100755 index 00000000..7e00ba96 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-ro/strings.xml @@ -0,0 +1,276 @@ + + + + + OpenVPN pentru Android + Adresa server: + Port server: + Locaţie + Directorul nu poate fi citit + Selectare + Anulare + Nu există date + Compresie LZO + Fără certificat + Certificat client + Cheie certificat client + Fişier PKCS12 + Certificat CA + Trebuie să selectați un certificat + Cod sursă şi tracker probleme disponibile la http://code.google.com/p/ics-openvpn/ + Acest program utilizează următoarele componente; a se vedea codul sursă pentru mai multe detalii despre licente + Despre + Profile + Tip + Parola PKCS12 + Selectaţi… + Trebuie să selectaţi un fişier + Folosiţi autentificare TLS + Direcţie TLS + Introduceţi adresa IPv6/Netmask în Format CIDR (ex. 2000:dd::23 / 64) + Introduceţi adresa IPv4/Netmask în format CIDR (de exemplu, 1.2.3.4/24) + Adresă IPv4 + Adresă IPv6 + Introduceţi opţiuni particularizate OpenVPN. Folosiţi cu atenţie. De asemenea, reţineţi că multe dintre opţiunile legate de OpenVPN tun nu sunt suportate de VPNSettings. Dacă lipseşte o opţiune importantă contactaţi autorul + Utilizator + Parola + Pentru configurarea statică Cheile TLS Auth vor fi utilizate ca şi chei statice + Configurare VPN + Adaugă profil + Introduceţi un nume ce identifică profilul nou + Vă rugăm să introduceţi un nume de profil unic + Nume profil + Trebuie să selectați un certificat de utilizator + Nu s-a găsit nici o eroare + Eroare în configurare + Eroare parsare adresă IPv4 + Eroare parsare rute particularizate + (lăsaţi necompletat pentru a interoagre la cerere) + Scurtătură OpenVPN + Conectare la VPN + Profilul specificat în comanda rapidă nu a fost găsit + Prefix host aleator + Adaugă 6 caractere aleatoare în faţa hostname + Activare opţiuni particularizate + Specificaţi opţiunile particularizate. Folosiţi cu grijă! + Rută respinsă de Android + Deconectaţi + Deconectați VPN + Golire jurnal + Anulare confirmare + Deconectaţi VPN-ul conectat/anulaţi încercarea de conectare? + Elimina VPN + Verifică dacă serverul utilizează un certificat cu extensii TLS Server (--remote-cert-tls server) + Aşteptă certificat de server TLS + Verifică Remote Server Certificate Subject DN + Verficare hostname certificat + Specifică verificarea ce va fi utilizată pentru certificatul DN (e.g. C=DE, L=Paderborn, OU=Avian IP Carriers, CN=openvpn.blinkt.de)\n\nSpecifică DN complet sau RDN (openvpn.blinkt.de in exemplu) sau un prefix RDN pentru verificare.\n\nCând folosiți prefix RDN \"Server\" face match si cu \"Server-1\" și \"Server-2\"\n\nDacă lăsați câmpul gol se va verifica RDN contra hostaname-ul serverului.\n\nPentru mai multe detalii verificați manualul OpenVPN 2.3.1+ la —verify-x509-name + Subiect certificat remote + Activează autentificarea cu cheie TLS + Fişier TLS Auth + Cere adrese IP, rute şi opţiuni timing de la server. + Nu se cere nici o informaţie de la server. Setările trebuie specificate mai jos. + Setări pull + DNS + Suprascrie setările DNS trimise de Server + Utilizează propriile servere DNS + searchDomain + Server DNS ce va fi folosit. + Server DNS + Server DNS secundar folosit dacă serverul DNS normal nu poate fi folosit. + Server DNS backup + Ignoră rutele primite + Ignoră rutele oferite de server. + Redirecţionează tot traficul peste VPN + Foloseşte ruta default + Introduceţi rute particularizate. Introduceţi destinaţia în format CIDR. \"10.0.0.0/8 2002:: / 16\" va redirecta reţelele 10.0.0.0/8 şi 2002:: / 16 peste VPN. + Rute particularizate + Nivel detaliu jurnal + Permite pachete autentificate de la orice IP + Permite floating server + Opţiuni particularizate + Editaţi setările VPN + Şterge profilul VPN \'%s\'? + În cazul anumitor imagini particularizate de ICS permisiile pentru /dev/tun pot fi greşite sau modulul tun lipseşte cu desăvârşire. Pentru imaginile CM9 ăncercaţi opţiunea de a repara permisiunile în cadrul setărilor generale + Eroare deschidere interfaţa tun + "Eroare:" + Goleşte + Se deschide interfața tun: + Local IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + Server DNS: %1$s, Domeniu: %2$s + S-au primit informaţiile despre interfaţă %1$s şi %2$s, presupun că a doua adresă este adresa peer a serverlui remote. Folosesc netmask /32 pentru IP local. Modul dat de OpenVPN este \"%3$s\". + Nu se poate interpreta %1$s şi %2$s ca rute IP cu netmask CIDR, folosesc /32 ca netmask. + Am corectat ruta %1$s/%2$s ca %3$s/%2$s + Imposibil de accesat Keychain cu certificate al Android. Acest lucur poate fi cauzat de un upgrade de firmware sau de restaurarea unei copii de siguranţă a setărilor app/app. Editaţi din nou VPN-ul si reselectaţi certificatul la \"setări de bază\" pentru a recreea permisiile de a accesa certificatul. + %1$s %2$s + Trimite fişier jurnal + Trimite + Fişier jurnal OpenVPN ICS + Linia din log s-a copiat in clip board + Mod Tap + Modul Tap nu este posibil folosind API-ul VPN non root. Astfel această aplicaţie nu poate oferi suport tap + Din nou? Glumesti? Nu, modul tap chiar nu este suportat şi trimiţând mai multe email-uri în care îl cereţi nu va ajuta. + A treia oară? De fapt, cineva ar putea scrie un emulator tap bazat pe tun ce ar adăuga informaţii din layer2 la trimitere şi are elimina informaţiile layer2 la primire. Dar acest emulator ar trebui sa implementeze ARP şi probabil un client DHCP. Nu sunt la curent cu cineva care lucrează la asta. Daca vreţi sa programaţi aceste funcţii mă puteţi contacta. + FAQ + Copiere linii jurnal + Pentru a copia o singură linie din jurnal apăsaţi şi menţineţi apăsat pe acea linie. Pentru a copia/trimite întreg jurnalul folosiţi opţiunea Trimite Jurnal. Folosiţi butonul de meniu hardware dacă nu este vizibil în GUI. + Shortcut pornire + Puteţi plasa o scurtătură pe desktop pentru a lansa OpenVPN. În funcţie de programul homescreen trebuie să adăugaţi fie o scurtătură fie un widget. + Imaginea dvs. nu suportă API-ul VPNService, îmi pare rău :( + Criptare + Alegeţi metoda de criptare + Introduceţi autentificarea digest ce este folosită de OpenVPN. Lăsaţi gol pentru digest predefinit. + Autentificare/criptare + File Explorer + Fişier inline + Eroare importare fişier + Nu s-a putut importa fişierul din filesystem + [[date fişier inline]] + Se refuză deschiderea device-ului tun fără informaţii IP + Importa profilul din fişier ovpn + Import + Imposibil de citit profilul de importat + Eroare la citirea fişierului de configurare + Adaugă profil + Imposibil de găsit fișierul %1$s menţionat în fişierul de configurare importat + Import fişierul de configurare din sursa %1$s + Configurația avut câteva opțiuni de configurare care nu sunt mapate la configurații UI. Aceste opțiuni au fost adăugate ca opțiuni de configurare personalizate. Configurația personalizată este afișată mai jos: + S-a terminat citirea fişierului de configurare. + Nu face bind la adresa şi portul local + Fără binding local + Import fişier de configurare + Considerente de securitate + "Deoarece OpenVPN are implicaţii de securitate este bine să facem câteva menţiuni. Toate datele de pe cardul sd sunt inerent nesecurizate. Orice aplicaţie le poate citi (de exemplu acest program nu are nevoie de drepturi speciale pentru sd). Datele acestei aplicaţii pot fi citite doar de aplicaţia însăşi. Dacă folosiţi funcţia import pentru cacert/cert/key în dialogul de import fişiere datele sunt stocate în profilul VPN. Profilele VPN sunt accesibile doar de această aplicaţie. (Nu uitaţi să ştergeţi copiile de pe cardul sd după aceea). Chiar dacă sunt accesibile doar de această aplicaţie datele sunt necriptate. Folosind root sau alte exploit-uri datele ar putea fi extrase. Parolele salvate sunt stocate de asemenea în clar. Pentru fişiere pkcs12 este recomandat să le importaţi în keystore-ul android." + Import + Eroare la afişarea selecţiei de certificat + Excepţie la afişarea dialogului Android 4.0+ de selecţie a certificatului. Acest lucru nu ar trebui să se întâmple deoarece este o funcţie standard Android 4.0+. Poate ROM-ul dvs. Android are suportul de stocare a certificatelor defect + IPv4 + IPv6 + Se aşteaptă mesajul de stare… + profil importat + profil importat %d + Imagini defecte + <p>Este cunoscut faptul ca imaginile HTC oficiale au o problemă ciudată de rutare ce nu permite traficului să treacă prin tunel (citiţi şi <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=18\">Problema 18</a>în bug tracker.)</p><p>S-a raportat că VPNService lipseşte complet din imaginile oficiale SONY mai vechi pentru Xperia arc S şi Xperia Ray. (citiţi şi <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=29\">Problema 29</a> în bug tracker.)</p><p>În imaginile particularizate modulul tun poate lipsi sau drepturile pentru /dev/tun pot fi greşite. Unele imagini CM9 au nevoie de opţiunea de reparare a drepturilor din setările generale.</p><p>Important: dacă aveţi o imagine defectă raportaţi-o fabricantului. Cu cât mai mulţi utilizatori raportează problema fabricantului cu atât este mai posibil ca el să o remedieze.</p> + Cheie criptare fişier PKCS12 + Parola cheie privată + Parola + icon fişier + autentificare TLS + Config generat + Setări + Încearcă să seteze owner-ul /dev/tun ca sistem. Unele imagini CM9 au nevoie de asta pentru a permite API-ului VPNService să funcţioneze. Are nevoie de root. + Repară drepturi /dev/tun + Afişează fişierul de configurare OpenVPN generat + Editare \"%s\" + Se generează configurarea… + Activând această opţiune forţaţi o reconectare dacă se schimbă starea de reţea (e.g. WiFi la/de la mobil) + Reconectare la schimbare reţea + Statutus reţea: %s + Certificatul CA este în mod normal returnat de Android Keystore. Specificaţi un certificat separat dacă observaţi erori de verificare a certificatului. + Selectare + Nici un certificat CA nu a fost returnat la citirea din keystore-ul Android. Autentificarea probabil va eşua. + Afişează fereastra jurnal la conectare. Fereastra jurnal poate fi accesată oricând din statusul notificare. + Arată fereastra Jurnal + Rulează pe %1$s (%2$s) %3$s, Android API %4$d + Eroare semnare cu Android keystore key %1$s: %2$s + Avertizarea la conexiunea VPN ce vă spune că această aplicaţie poate intercepta întreg traficul este impusă de sistem pentru a preveni abuzul funcţiei API VPNService.\nNotificarea de conexiune VPN(simbolul cheie)este de asemenea impusă de sistemul Android pentru a semnala o conexiune VPN în derulare. În cadrul unor imagini această notificare face şi un sunet.\nAndroid a introdus aceste notificări pentru siguranţa dvs. şi este asigurat că nu pot fi evitate. (Din păcate în anumite imagini acestea includ şi un sunet de notificare) + Alertă conexiune şi sunet notificare + Traducere în limba română de Silviu Vulcan<silviuvulcan.ro> + IP şi DNS + Basic + Rutare + Setări obscure pentru OpenVPN. În mod normal nu sunt necesare. + Avansate + Configurare Openvpn ICS + Nici un server DNS utilizat. Rezolvarea de nume poate să nu funcționeze. Luați în considerare stabilirea unor servere DNS personalizate. Vă rugăm, de asemenea, rețineți că Android va continua să utilizeze setările proxy specificate pentru conexiunea mobilă/Wi-Fi atunci când nu sunt stabilite servere DNS. + Nu s-a putut adăuga serverul DNS \"%1$s\", respins de sistem: %2$s + <p>Obţineţi o configurare funcţională (testată pe calculatorul dvs. sau descărcată de la provider/companie)</p><p>Dacă este un singur fişier fără alte fişiere pem/pks12 puteţi să vă trimiteţi fişierul prin email şi să deschideţi ataşamentul. Daca aveţi fişiere multiple le puteţi pune pe cardul sd.</p><p>Click pe ataşamentul email/Folosiţi icoana director din lista de vpn-ri pentru a importa fişierul de configurare.</p><p>Dacă sunt erori despre fişiere lipsă le puteţi pune pe cardul sd.</p><p>Click pe simbolul de salvare pentru a adăuga VPN-ul importat în lista dvs. de VPN-uri</p><p>Conectaţi VPN-ul dând click pe numele VPN-ului</p><p>Dacă sunt erori/avertismente în jurnal încercaţi să le înţelegeţi şi să le reparaţi</p> + Pornire rapidă + Încearcă încărcarea modului kernel tun.ko înainte de conectare. Are nevoie de un device root-at. + Încarcă modulul tun + Import PKCS12 configurare în Android Keystore + Eroare la obţinerea setărilor proxy: %s + Folosesc proxy %1$s %2$d + Foloseşte proxy sistem + Foloseşte configurarea sistem pentru proxy HTTP/HTTPS folosit la conectare. + Puteţi <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">dona prin PayPal</a> + OpenVPN va reconecta un VPN dacă a fost activ la reboot/shutdown. Citiţi avertizarea la Conexiune din FAQ înainte de a folosi această funcţie. + Reconectarea la reboot + Ignora + Restart + Schimbările de configurare vor fi aplicate după restartarea VPN-ului. (Re)startaţi VPN-ul acum? + Configuraţie schimbată + Nu se poate determina ultimul profil conectat pentru editare + Duplichează notificări + Dacă Android are puţină memorie (RAM) disponibilă va închide aplicaţii şi servicii ce nu sunt necesare pe moment. Acest lucru va închide o conexiune VPN activă. Pentru a asigura că acest fapt nu se întâmplă şi conexiunea/OpenVPN supravieţuieşte serviciul rulează cu prioritate ridicată. Pentru a rula cu prioritate ridicată aplicaţia trebuie să afişeze o notificare. Icoana cheie de notificare este impusă de sistem după cum s-a descris în raspunsul FAQ anterior. Nu se socoteşte ca notificare a aplicaţiei în scopul de a rula cu prioritate ridicată. + nici un profil VPN definit. + Folosiţi icoana <img src=\"ic_menu_add\"/> pentru a adăuga un nou VPN + Folosiţi icoana <img src=\"ic_menu_archive\"/> pentru a importa un profil existent (.ovpn sau .conf) de pe cardul sd. + Verificaţi şi FAQ. Acolo este ghid rapid de utilizare. + Configurare Rutare/Interfaţă + Nu reveni la nici o conexiune VPN câtă vreme OpenVPN se reconectează. + Tun persistent + jurnal OpenVPN + Import configurare OpenVPN + Consum baterie + În cadrul testelor mele personale principalul motiv pentru consumul ridicat de baterie al OpenVPN sunt pachetele keepalive. Majoritatea serverelor OpenVPN au în configurare o directivă cum ar fi \'keepalive 10 60\' ce face ca şi clientul să schimbe cu serverul pachete keepalive la fiecare 10 secunde.<p> Chiar dacă aceste pachete sunt mici şi nu folosesc trafic, ele menţin radioul mobil activ şi cresc consumul de energie. (Citiţi şi <a href=\"http://developer.android.com/training/efficient-downloads/efficient-network-access.html#RadioStateMachine\">The Radio State Machine | Android Developers</a>) <p>Această setare keepalive nu poate fi schimbată de client. Doar administratorul serverului OpenVPN o poate schimba.<p> Din păcate o valoare mai mare de 60 de secunde a keepalive cu UDP poate face ca unele gateway-uri NAT să termine conexiunea după un timp scurt. Folosind TCP cu valori lungi de keepalive funcţionează dar rularea unui tunel TCP peste o conexiune TCP funcţionează foarte slab în cazul conexiunilor cu pierderi mari de pachete. (Citiţi <a href=\"http://sites.inka.de/bigred/devel/tcp-tcp.html\">Why TCP Over TCP Is A Bad Ide</a>) + Funcţia Android Tether (folosind WiFi, USB sau Bluetooth) şi API-ul VPNService (folosit de acest program) nu funcţionează împreună. Pentru mai multe detalii vizitaţi <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\">issue #34</a> + VPN şi Tethering + Reîncercări conectare + Setările de reconectare + Numărul de secunde între încercările de conectare. + Secunde între conexiuni + OpenVPN sa oprit în mod neaşteptat. Vă rugăm să consideraţi opţiunea de trimitere a unui Minidump din meniul principal + Trimite Minidump la dezvoltator + Trimite informații de depanare despre ultimul crash la dezvoltator + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + Se conectează + Se aşteaptă răspunsul serverului + Autentificare + Se obţine configurarea clientului + Se asignează adresele IP + Adăugare rute + Conectat + Deconectaţi + Se reconectează + Se iasă + Nu rulează + Rezolvare nume host + Se conectează (TCP) + Autentificare a eşuat + Se aşteaptă o reţea utilizabilă + ↓%2$s/s %1$s - ↑%4$s/s %3$s + Nu este conectat + Conectare la VPN %s + Conectare la VPN %s + Unele versiuni de Android 4.1 au probleme dacă numele certificatului keystore conţine caractere non-alfanumerice (cum ar fi spaţii, linii de subliniere sau cratime). Încercaţi să reimportaţi certificatul fără caractere speciale + Cifru criptare + Autentificare pachete + Introduceţi metoda de autentificare de pachete + Rulează pe %1$s (%2$s) %3$s, Android API %4$d, versiunea %5$s, %6$s + compilat de %s + versiune debug + versiune oficială + Copiaţi în profil + Crashdump + Adauga + Trimite fişierul de configurare + DN Complet + Configuraţia importată foloseşte opţiunea ÎNVECHITĂ tls-remote ce utilizează un format DN diferit. + RDN (nume comun) + Prefix RDN + tls-remote (ÎNVECHIT) + Puteţi ajuta la traducere vizitând http://crowdin.net/project/ics-openvpn/invite + %1$s încercări de a controla %2$s + Am încredere în această aplicaţie. + Nici o aplicaţie nu are permisiunea de a folosi API-ul extern + Aplicaţii permise: %s + Şterge lista aplicaţilor permise?\nLista curentă a aplicaţilor ce au permisiune:\n\n%s + \"Suspendă VPN atunci când ecranul este oprit şi au fost transferaţi mai puţin de 64 kB în 60s. Când \"Tun persistent\" este activat suspendarea conexiunii VPN va lăsa aparatul dvs. FĂRĂ conexiune la reţea. Fără opţiunea \"Tun persistent\" aparatul nu va beneficia de conexiune/protecţie VPN. + Suspendă conexiunea VPN după închiderea ecranului + Se suspendă conexiunea în starea ecran oprit: mai puţin de %1$s în %2$s + Atenție: TUN persistent nu este activat pentru acest VPN. Traficul va utiliza conexiunea Internet normala atunci când ecranul este oprit. + Salvare parola + diff --git a/ics-openvpn-stripped/main/src/main/res/values-ru/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-ru/strings.xml new file mode 100755 index 00000000..9cc95a5a --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-ru/strings.xml @@ -0,0 +1,295 @@ + + + + + OpenVPN для Android + Адрес сервера: + Порт сервера: + Расположение + Не могу прочитать директорию + Выбрать + Отмена + Нет данных + Сжатие LZO + Нет сертификата + Сертификат клиента + Ключ сертификата клиента + PKCS12 файл + CA сертификат + Вам необходимо выбрать сертификат + Исходники и информация о версиях находятся по адресу http://code.google.com/p/ics-openvpn/ + Данная программа использует следующие компоненты; смотрите исходный код для получения подробной информации о лицензии + О программе + Профили + Тип + Пароль для PKCS12 + Выбрать… + Вы должны выбрать файл + Использовать аутентификацию TLS + TLS Direction + Введите адрес/маску подсети IPv6 в формате CIDR (например 2000:dd::23/64) + Введите адрес/маску подсети IPv4 в формате CIDR (например 1.2.3.4/24) + Адрес IPv4 + Адрес IPv6 + Введите дополнительные параметры OpenVPN. Используйте эту возможность с большой осторожностью. Если вы считаете, что отсутствует важный параметр, свяжитесь с автором + Имя пользователя + Пароль + Для конфигурации с статичными сертификатами будут использоваться ключи TLS + Настройка VPN-туннеля + Добавить конфигурацию + Введите имя новой конфигурации + Пожалуйста, введите уникальное имя профиля + Имя конфигурации + Необходимо выбрать сертификат пользователя + Ошибок не найдено + Ошибка в конфигурации + Невозможно прочесть IPv4 адрес + Невозможно примениить пользовательские маршруты + (оставьте пустым для запроса по требованию) + Ярлык OpenVPN + Подключиться к VPN + Не найден профиль, указанный в ярлыке + Случайный префикс узла + Добавляет 6 случайных символов перед именем хоста + Включить пользовательские параметры + Пользовательские параметры. Используйте с осторожностью! + Маршрут отвергнут Android + Отключение + Отключить VPN + очистить журнал + Подтверждение отмены + Отключение активных VPN/Отмена попыток подключения? + Удалить VPN + Проверяет, использует ли сервер сертификаты TLS (--remote-cert-tls server) + Ожидать сертификата TLS от сервера + Проверка DN объекта удаленного сертификата + Проверка имени хоста сертификата + Переключатель способа проверки DN сертификата (e.g. C=DE, L=Paderborn, OU=Avian IP Carriers, CN=openvpn.blinkt.de)\n\nВозможные значения: полный DN, RDN (для примера openvpn.blinkt.de) или только преффикс RDN для проверки.\n\nПри использовании преффикса RDN, например \"Server\", значения будут \"Server-1\", \"Server-2\" и т.д.\n\nПри пустом текстовом поле проверка будет проводиться по имени хоста.\n\nДля подробностей смотрите руководство для OpenVPN 2.3.1+, раздел —verify-x509-name + Объект удаленного сертификата + Включить аутентификацию по TLS ключу + Файл аутентификации TLS + Запрос IP-адреса, маршрутов и параметров от сервера. + Игнорировать все параметры сервера. Параметры должны быть указаны ниже. + Запрашивать параметры + DNS + Переопределить параметры DNS от сервера + Использовать ваши DNS + Домен поиска + DNS-сервер для использования. + DNS-сервер + Вторичный DNS-сервер используется, если не получен ответ от первого сервера DNS. + Резервный сервер DNS + Игнорировать посылаемые маршруты + Игнорировать маршруты, посылаемые сервером. + Перенаправляет весь трафик через VPN + Использовать маршрут по-умолчанию + Введите пользовательские маршруты. Только введите адрес назначения в формате CIDR. \"10.0.0.0/8 2002::/16\" будет использовано для 10.0.0.0/8 и 2002::/16 сетей через VPN. + Пользовательские маршруты + Уровень детализации лога + Разрешить пакеты аутентификации с любого IP-адреса + Разрешать \"плавающие\" сервера + Пользовательские параметры + Редактирование параметров VPN + Удаление профиля VPN %s? + На некторых костомных сборках права на /dev/tun могут быть неверными или tun-модуль может быть не включен. Для прошивки CM9 можете попробовать исправить владельца прямо из настроек программы + Открытие интерфейса tun окончилось неудачей + "Ошибка: " + Очистить + Открытие tun-интерфейса: + Адрес IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + DNS-сервер: %1$s, Домен: %2$s + Получена информация интерфейса %1$s и %2$s, второй адрес является удалённым адресом канала. Используется сетевая маска /32 для локального IP адреса. Режим, установленный OpenVPN: \"%3$s\". + Невозможно использовать выражения %1$s и %2$s как маршрут по стандарту CIDR. используется /32 как маска подсети. + Маршрут исправлен с %1$s/%2$s на %3$s/%2$s + Не удается получить доступ к хранилищу ключей и сертификатов Android. Это может быть вызвано обновлением прошивки или восстановления старой копии приложения или его настроек. Пожалуйста, отредактируйте профиль VPN и заново укажите ключи и сертификаты в разделе Основные параметры. + %1$s %2$s + Отправить файл журнала + Отправить + ICS OpenVPN файла лога + Скопировать лог в буфер обмена + Режим TAP + Режим TAP невозможен на устройствах без root-а. Поэтому это приложение не поддерживает TAP + Снова? Вы издеваетесь? Не поддерживается режим TAP и просьбы к автору об этом не помогут ему реализоваться. + Третий раз? На самом деле можно было бы писать эмулятор tap, основанные на tun, который бы добавлял информацию 2 уровня при отправке и извлекал бы ее при получении. Но этот эмулятор потребует также ARP и, возможно, клиента DHCP. Я не знаю никого, кто мог бы этим заняться. Свяжитесь со мной, если вы хотите заняться этим. + Вопросы и ответы + Копирование записей лога + Для копирования одного элемента журнала необходимо нажать и удерживать. Для копирования/передачи всего файла журнала используйте опцию \"Отправить файл журнала\". Используйте hardware кнопку меню, если вы не в графическом интерфейсе. + Ярлык для запуска + Вы можете создать ярлык для запуска OpenVPN на рабочем столе. В зависимости от вашего окружения необходимо добавить ярлык или виджет. + Ваша прошивка не поддерживает VPNService API, извините :( + Шифрование + Укажите метод шифрования + Укажите алгоритм шифрования, используемый OpenVPN. Оставьте пустым, чтобы использовать шифрование по-умолчанию. + Введите the authentication digest для OpenVPN. Оставьте пустым для использования значения по-умолчанию. + Авторизация/шифрование + Обзор файлов + Встроенный файл + Ошибка при импорте файла + Не удалось импортировать файл из файловой системы + [[Встроенный файл данных]] + Отказ в открытии устройства tun без информации об IP-адресе + Импорта конфигурации из файла .ovpn + Импорт + Не удалось прочитать конфигурацию для импорта + Ошибка чтения файла конфигурации + добавить конфигурацию + Не удалось найти файл %1$s, указанный в файле конфигурации + Импорт файла конфигурации из исходного %1$s + Ваша конфигурация имел несколько параметров, которые не входят в параметры стандартной конфигурации. Эти параметры были вынесены в пользовательскую конфигурацию. Пользовательская конфигурация отображается ниже: + Файла конфигурации успешно прочитан. + Не привязываться к локальному адресу и порту + Не использовать привязки + Импорт файла конфигурации + Соображения безопасности + "Так как OpenVPN чувствителен к безопасности, то будут разумными несколько замечаний относительно защиты. Все данные на sd карте по сути не защищены. Каждое приложение может прочесть их (например эта программа не требует специальных привилегий на sd карту). Данные этого приложения могут быть прочитаны только им самим. При использовании опции импорта для cacert/cert/key в диалоговом окне файл, данные сохраняются в VPN профиле. VPN профили доступны только этому приложению. (Потом не забудьте удалить копии на sd карте). Несмотря на то, что данные доступны только этому приложению, они все еще незашифрованы. Путем получения прав администратора (рута) на телефоне или другими эксплойтами возможно извлечь данные. Также сохраненные пароли хранятся в обычном текстовом виде. Настоятельно рекомендуется pkcs12 файлы импортировать в android keystore." + Импорт + Ошибка вывода выбранного сертификата + Произошла ошибка при попытке вызова системного диалога выбора сертификатов Android 4.0+ Этого не должно было случиться на стандартной прошивке. Может быть в вашей прошивке испорчено хранилище сертификатов + IPv4 + IPv6 + Ожидание сообщения о состоянии… + импортируемый профиль + импортируемый профиль %d + Сломанные прошивки + <p>Извествно, что официальные прошивки HTC имеют странные проблемы с маршрутизацией, приводящей к тому, что трафик не идёт через туннель (см. <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=18\">Issue 18</a> в баг-трекере).</p><p>Также сообщалось, что в старых официальных прошивках SONY от Xperia Arc S и Xperia Ray полностью отсутствует сервис VPNService (см. <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=29\">Issue 29</a> в баг-трекере).</p><p>В некоторых встроенных прошивках модуль tun может отсутствовать или иметь неправильные права на файл устройства /dev/tun. Некоторые CM9 прошивки могут требовать исправлений опции прав в главных настройках.</p><p>И самое главное: Если у вас прошивка с указанными проблемами, сообщите об этом производителю устройства. Чем больше пользователей сообщит о проблеме, тем больше шансов, что этот производитель исправит прошивку.</p> + Файл PKCS12-ключа + Пароль закрытого ключа + Пароль + файл значка + TLS-аутентификация + Сгенерированая конфигурация + Настройки + Попытаться изменить владельца для /dev/tun. Некоторые прошивки CM9 требуют этого для корректной работы API OpenVPN. Требуется root. + Исправить права для /dev/tun + Показать сгенерированный файл конфигурации OpenVPN + Правка \"%s\" + Создание конфигурации… + Включение этого параметра заставит переподключиться, если состояние сети изменения (WIFI с мобильного) + Переподключение при изменении сети + Статус сети: %s + Сертификат CA обычно возвращается из хранилища Android Keystore. Укажите отдельный сертификат, если у вас возникли ошибки при проверке сертификата. + Выбрать + Не удалось получить CA из хранилища ключей Android. Аутентификация не удалась. + Показывает окно журнала при подключении. Окно журнала всегда может быть доступно из панели уведомлений. + Показать окно журнала + Работает на %1$s (%2$s) %3$s, Android API %4$d + Ошибка подписи с использованием ключа из хранилища Android %1$s: %2$s + Предупреждение VPN соединения сообщает вам, что это приложение может перехватывать весь сетевой трафик, и сообщается системой предупреждений VPNService API.\nИзвещение о VPN соединении (символ \"Ключа\") также формируется системой Android для сигнализации исходящего VPN соединения. В некоторых прошивках это оповещение сопровождается сигналом.\nAndroid использует эти оповещения для вашей собственной безопасности и из нельзя обойти. (К сожалению, на некоторых прошивках также издается оповещение звуком) + Сообщение о подключении и звук уведомления + Русский перевод от RusFox <horonitel@gmail.com> + IP-адрес и DNS + Основные + Маршрутизация + Скрытые параметры OpenVPN. Обычно не требуются. + Расширенные + ICS Openvpn конфигурация + Серверы DNS не используются. Разрешение имен может не работать. Рассмотрите возможность установки пользовательских DNS-серверов. Также обратите внимание, что Android будет продолжать использовать параметры, указанные для вашего мобильного/Wi-Fi соединения, если не указаны DNS-серверы. + Не удалось добавить DNS-сервер \"%1$s\", отклонен системой: %2$s + Не удалось настроить IP-адрес \"%1$s\", сообщение системы: %2$s + <p>Используйте готовую конфигурацию (протестированную на вашем компьютере или полученную от вашего провайдера)</p><p>Если это простой файл без pem/pks12 вы можете отправить его по email на свое устройство. Если же это несколько файлов, вы можете использовать их со своей карты памяти.</p><p>Просто кликните на .conf файл или выберите его с помощью меню в программе для импорта конфигурации</p><p>Если программа выдаст ошибку о нехватке некоторых файлов, просто поместите эти файлы на карту памяти</p><p>Нажмите кнопку сохранения для добавления импортируемой конфигурации в программу</p><p>Запустите ваш VPN-тоннель нажав на его название в списке</p><p>Если при запуске возникли ошибки попробуйте разобраться и устранить их.</p> + Быстрый старт + Попробуйте загрузить модуль ядра tun.ko прежде чем пытаться подключиться. Требуется root-доступ на устройстве. + Загрузить tun-модуль + Импорт PKCS12 из хранилища ключей Android + Ошибка при получении параметров прокси-сервера: %s + Используется прокси-сервер %1$s %2$d + Использовать прокси-сервер системы + Использовать системную конфигурацию прокси HTTP/HTTPS для соединения. + Вы можете <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">пожертвовать с PayPal</a> + OpenVPN будет переподключаться, если он был активен в момент выключения/перезагрузки. Пожалуйста, прочтите FAQ перед тем, как использовать эту настройку. + Переподключение после перезагрузки + Игнорировать + Перезапуск + Изменения конфигурации применяются после перезапуска VPN. (Пере)запустить VPN сейчас? + Конфигурация изменена + Не удалось определить последний используемый профиль для редактирования + Дублирующиеся уведомления + Если в Android возникает нехватка оперативной памяти (RAM), ненужные службы и приложения останавливаются. Из-за этого прерывается установленное VPN-соединение. Чтобы избежать этого, приложение нужно запускать с повышенным приоритетом. Для запуска с высоким приоритетом приложение должно вывести предупреждение. Основная иконка приложения будет закреплена наверху панели уведомлений самой системой, как описано в предыдущем вопросе. Она не является собственно уведомлением, это ограничение распространяется на все приложения, запущенные с высоким приоритетом. + Профили VPN не указаны. + Используйте <img src=\"ic_menu_add\"/> иконку для добавления нового VPN + Используйте <img src=\"ic_menu_archive\"/> кнопку для импорта существующих профилей (.ovpn or .conf) с вашей карты памяти. + Не забудьте заглянуть в FAQ. Также имеется краткое руководство. + Конфигурация маршрутизации/интерфейса + Не открывать диалог, когда происходит переподключение VPN. + Постоянный tun + OpenVPN Журнал + Импорт конфигурации OpenVPN + Потребление батареи + В моих тестах, главным источником высокого потребления электроэнергии батареи были keepalive пакеты. Большинство OpenVPN-серверов содержат директиву вроде \'keepalive 10 60\', которая отправляет keepalive-пакет с клиента на сервер и с сервера на клиент каждые 10 секунд. <p> Хоть эти пакеты и маленькие и не расходуют много трафика, они заставляют радиомодуль потреблять много энергии. (см. <a href=\"http://developer.android.com/training/efficient-downloads/efficient-network-access.html#RadioStateMachine\">The Radio State Machine | Android Developers</a>) <p> Настройки keepalive не могут быть изменены на клиенте, это может сделать только системный администратор OpenVPN.lt;pgt; К сожалению, использование keepalive более, чем 60 секунд с UDP, может вносить проблемы с некоторыми типами NAT, которые удаляют информацию о соединении через короткое время (в моем случае, это было 60 секунд). Использование TCP с большим keepalive-таймаутом будет работать, но производительность туннелирования TCP через TCP в сетях с высокой вероятностью потери пакета крайне низкая (см. <a href=\"http://sites.inka.de/bigred/devel/tcp-tcp.html\">Why TCP Over TCP Is A Bad Idea</a>). + Тетеринг функция Android (через WiFi, USB или Bluetooth) и VPNService API (используемое этой программой) не работают вместе. Подробней в <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\">проблеме №34</a> + VPN и Tethering + Попытки подключения + Параметры переподключения + Количество секунд между попытками подключения. + Секунд между соединениями + OpenVPN завершилась неожиданно. Пожалуйста, посмотрите опцию \"Отправить Minidump\" в главном меню + Отправить Minidump разработчику + Отправка отладочной информации разработчику о последнем аварийном завершении + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + Подключение + Ожидание ответа сервера + Проверка подлинности + Получение конфигурации клиента + Назначение IP-адресов + Добавление маршрутов + Подключено + Отключиться + Повторное подключение + Выход + Не запущено + Разрешение имен узлов + Подключение (TCP) + Ошибка аутентификации + Ожидание работы сети + ↓%2$s/s %1$s - ↑%4$s/s %3$s + Разъединено + Подключение к VPN %s + Подключение к VPN %s + В некоторых версиях Android 4.1 есть проблемы, если имя сертификата содержит не буквенно-цифровые символы (например, пробелы, подчеркивания или тире). Попробуйте переустановить сертификат без использования специальных символов. + Алгоритм шифрования + Проверка подлинности пакетов + Укажите метод проверки подлинности пакетов + Запущен на %1$s (%2$s) %3$s, Android API %4$d, версии %5$s, %6$s + создан %s + сборка для отладки + официальная сборка + Скопировать в профиль + Отчет о падении + Добавить + Отправить конфигурационный файл + Полное DN + Импортированнаяе конфигурация использует устаревшую опцию tls-remote которая имеет другой формат DN. + RDN (полное имя) + Префикс RDN + tls-remote (УСТАРЕВШЕЕ) + Вы можете улучшить перевод, посетив http://crowdin.net/project/ics-openvpn/invite + %1$s пытается управлять %2$s + Продолжая, вы даете приложению права на управление \"OpenVPN для Android\" и перехват всего сетевого трафика. Не продолжайте, если не доверяете полностью этому приложению. В противном случае вы рискуете утечкой и использованием ваших данных злоумышленниками. + Я доверяю этому приложению. + Нет приложений, авторизованных для внешнего API + Авторизованные приложения: %s + Очистить список авторизованных внешних приложений?\nСписок разрешенных приложений:\n\n%s + VPN-соединение приостанавливается, если экран выключен или объем данных меньше 64kb за 60сек. Если включена опция \"Удержание соединения\", VPN-соединение будет постоянно активным. Без этого параметра оно будет приостанавливаться при этих условиях.. + Приостановить VPN-соединение при выключенном экране + Приостановка соединения при выключенном экране: меньше, чем %1$s за %2$sс + Внимание: постоянный tun не включен для этого VPN. Трафик будет проходить через обычный доступ в Интернет, когда экран выключен. + Сохранить пароль + Приостановить VPN + Продолжить VPN + VPN приостановлен по запросу пользователя + VPN приостановлен - выкл. экран + Не удается отобразить сведения о сертификате + Поведение приложения + Поведение VPN + Разрешить изменение VPN-профилей + Аппаратное хранилище ключей: + Окно подтверждения VPN для Android 4.3 и позже + Спасибо за пожертвование %s! + Журнал очищен. + Показать пароль + Выгружено + Загружено + Статус VPN + diff --git a/ics-openvpn-stripped/main/src/main/res/values-sv/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-sv/strings.xml new file mode 100755 index 00000000..12a94cc9 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-sv/strings.xml @@ -0,0 +1,274 @@ + + + + + OpenVPN för Android + Serveradress: + Serverport: + Plats + Katalogen kan inte läsas + Välj + Avbryt + Inga Data + LZO komprimering + Inget certifikat + Klientcertifikat + Klientcertifikatsnyckel + PKCS12 fil + CA-certifikat + Du måste välja ett certifikat + Källkod och incidenthantering finns på http://code.google.com/p/ics-openvpn/ + Programmet använder följande komponenter, se källkoden för fullständig information om licenser + Om + Profiler + Typ + PKCS12 lösenord + Välj… + Du måste välja en fil + Använd TLS-autentisering + TLS riktning + Ange IPv6-adress/Netmask i CIDR Format (t.ex. 2000:dd::23 / 64) + Ange IPv4-adressen/Netmask i CIDR Format (t.ex. 1.2.3.4/24) + IPv4-adress + IPv6-adress + Ange anpassade OpenVPN alternativ. Använd med försiktighet! Tänk också på att många av de tun relaterade OpenVPN inställningarna inte kan stödjas genom utformningen av VPNSettings. Om du anser att ett viktigt alternativ saknas kontakta författaren + Användarnamn + Lösenord + Vid statisk konfiguration används TLS Auth nycklarna som statiska nycklar + Konfigurera VPN-anslutningen + Lägga till en profil + Ange ett namn som identifierar den nya profilen + Vänligen ange ett unikt Profilnamn + Profilnamn + Du måste välja ett användarcertifikat + Inga fel hittades + Fel i konfigurationen + Det går inte att tolka IPv4-adressen + Det går inte att tolka de anpassade rutterna + (lämna tom för förfrågan vid behov) + OpenVPN genväg + Ansluta till VPN + Profilen som anges i genvägen hittades inte + Slumpmässigt värd-prefix + Lägger till 6 slumpmässiga tecken framför hostname + Aktivera anpassade alternativ + Ange anpassade inställningar. Använd med försiktighet! + Rutten avvisades av Android + Koppla från + Koppla från VPN + rensa loggen + Avbryt bekräftelse + Koppla från det anslutna VPN/Avbryt anslutningen? + Ta bort VPN + Kontrollerar om servern använder ett certifikat med TLS server tillägg (--remote-cert-tls server) + Förvänta TLS servercertifikat + Verifierar Remote Server Certificate Subject DN + Certifikat Hostname kontroll + Ange den kontroll som används för att verifiera Fjärrcertifikat DN (e.g. C=DE, L=Paderborn, OU=Avian IP Carriers, CN=openvpn.blinkt.de)\n\nSpecificera en komplett DN eller RDN (openvpn.blinkt.de i exemplet) eller ett RDN prefix för verifiering.\n\nOm RDN prefix används matchar \"Server\" både \"Server-1\" och \"Server-2\" \n\nLämnas textfältet tomt matchas RDN mot server hostname.\n\nFor mer information se OpenVPN 2.3.1+ manpage under —verify-x509-name + Fjärrcertifikats ämne + Aktiverar TLS Key Authetication + TLS Auth fil + Begär IP-adresser, rutter och tidsalternativ från servern. + Ingen information begärs från servern. Inställningar behöver specificeras nedan. + Hämta inställningar + DNS + Använd DNS-inställningarna från servern + Använda dina egen DNS-servrar + searchDomain + DNS-Server som ska användas. + DNS-server + Sekundära DNS-servern används om den normala DNS-servern inte kan nås. + Sekundär DNS-Server + Ignorera tilldelade rutter + Ignorera rutter tilldelade av servern. + Omdirigerar all trafik över VPN-anslutningen + Använd standardrutt + Ange anpassade rutter. Skriv destination i CIDR-format. \"10.0.0.0/8 2002:: / 16\" dirigerar nätverk 10.0.0.0/8 och 2002:: / 16 över VPN. + Anpassade rutter + Utförlighetsnivå för log + Tillåter autentiserade paket från alla IP-adresser + Tillåt flytande server + Anpassade alternativ + Redigera VPN-inställningar + Ta bort VPN-profilen \'%s\'? + På vissa anpassade ICS ROM kan behörigheten på /dev/tun vara fel eller så kan tun modulen saknas helt. För CM9 ROM prova alternativet fixa ägande under allmänna inställningar + Det gick inte att öppna tun gränssnittet + "Fel:" + Klart + Öppnar tun gränssnittet: + Lokal IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + DNS-Server: %1$s, Domän: %2$s + Fick gränssnitts informationen %1$s och %2$s, förutsätter att andra adressen är peer adressen på fjärrservern. Använder nätmask /32 för lokal IP. Satus på OpenVPN är \"%3$s\". + Förstår inte %1$s och %2$s som IP rutt med CIDR netmask, där /32 används som nätmask. + Korrigerad rutt %1$s/%2$s till %3$s/%2$s + Åtkomst nekas till certifikat i Android nyckelring. Detta kan orsakas av en firmware-uppgradering eller en återställning från säkerhetskopia av app/app inställningar. Vänligen redigera VPN och välj på nytt certifikatet under grundinställningar för att återskapa åtkomstbehörigheten till certifikatet. + %1$s %2$s + Skicka loggfilen + Skicka + ICS OpenVPN loggfil + Kopierade loggpost till klippboken + Tap-läge + Tap-läge är inte möjligt med icke root VPN-API. Därför kan inte denna applikation stödja tap-läge + Igen? Skämtar du? Nej, tap-läge stöds verkligen inte och det hjälper inte att skicka fler mail och fråga om det kommer att stödjas i framtiden. + En tredje gång? Man skulle kunda skriva en tap-emulator baserat på tun som skulle lägga till layer2 information vid skicka och ta bort layer2 information vid ta emot. Men denna tap emulator skulle också behöva implementera ARP och eventuellt också en DHCP-klient. Jag är inte medveten om att någon gjort något arbete i denna riktning. Kontakta mig om du vill börja koda på detta. + FAQ + Kopierar loggposter + För att kopiera en enda logg post tryck och håll på loggposten. Om du vill kopiera/skicka hela loggen använd alternativet Skicka loggen. Använd hårdvarumenyknappen om menyn inte syns i GUI. + Genväg för att starta + Du kan placera en genväg för att starta OpenVPN på skrivbordet. Beroende på ditt hemskärmsprogram måste du lägga till antingen en genväg eller en widget. + Din ROM stöder inte VPNService API, ledsen :( + Kryptering + Ange krypteringsmetod + Ange den autentiserings digest som används för OpenVPN. Lämna tom för att använda standard digest. + Autentisering/kryptering + Filutforskare + Inline-fil + Fel vid import av fil + Kunde inte importera filen från filsystemet + [[Inline-fil data]] + Vägrar att öppna tun enhet utan IP-information + Importera profil från ovpn fil + Import + Kunde inte läsa profil att importera + Fel vid läsning av konfigurationsfil + lägg till profil + Kunde inte hitta filen %1$s som omnämns i den importerade konfigurationsfilen + Importerar konfigurationsfilen från %1$s + Din konfiguration hade några konfigurationsalternativ som inte är kopplade till UI konfigurationer. Dessa alternativ lades till som anpassade konfigurationsalternativ. Den anpassade konfigurationen visas nedan: + Färdig med att läsa konfigurationsfilen. + Bind inte till lokal adress och port + Ingen lokal bindning + Importera konfigurationsfil + Säkerhetsaspekter + "Eftersom OpenVPN är säkerhets känslig kan några om säkerhet vara vettiga. Alla data på sd-kortet är potentiellt osäkra. Varje app kan läsa datan (till exempel kräver detta program inga särskilda sd-korts rättigheter). Datat som tillhör denna applikation kan endast läsas av applikationen själv. Genom att använda alternativet import för cacerts/cert/nyckel i fildialogrutan lagras datat i VPN-profilen. VPN-profiler kan bara läsas av denna applikation. (Glöm inte att ta bort kopiorna på sd-kortet efteråt). Även om datat endast är tillgängligt för denna applikation så är data fortfarande okrypterat. Genom att roota telefon eller med andra hack kan det vara möjligt att få åtkomst till datat. Sparade lösenord lagras också i klartext. För pkcs12 filer rekommenderas det starkt att du importerar dem till Android nyckering." + Import + Fel vid visning av certifikatval + Fick ett undantag när Android 4.0+ dialogrutan för val av certifikat försökte visas. Detta bör aldrig ske eftersom detta en standardfunktion hos Android 4.0+. Kanske är stödet för lagring av certifikat i din Android ROM trasigt + IPv4 + IPv6 + Väntar på tillstånds meddelande… + importerad profil + importerad profil %d + Trasiga ROM + lt;pgt;Officiella HTC ROM är kända för att ha ett konstigt rutt problem som orsakar att trafik inte går genom tunneln (Se även <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=18\">Ärende 18</a> i äredehanteringen.)</p><p>Äldre officiella SONY ROM för Xperia Arc S och Xperia Ray har rapporterats sakna VPNService helt. (Se även <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=29\">Ärende 29</a> i ärendehanteringen.)</p><p>I anpassade/modifierade ROM kan tun modulen saknas eller rättigheterna på /dev/tun kan vara fel. Vissa CM9 ROM behöver alternativet \"Fixa ägande\" under \"Modellanpassade hack\" ikryssat.</p><p>Viktigt: Om du har en trasig ROM, rapportera det till din leverantör. Ju fler människor som rapportera problemet till leverantören desto mer sannolikt är det att det kommer en rättning.</p> + Krypteringsnyckel för PKCS12-filen + Lösenord för privat nyckel + Lösenord + filikon + TLS-autentisering + Genererad konfiguration + Inställningar + Försöker att sätta ägaren av /dev/tun till system. Vissa CM9 ROM behöver detta för att VPNService API ska fungera. Detta kräver root. + Fixa ägande av /dev/tun + Visar den genererade OpenVPN-konfigurationsfilen + Redigerar \"%s\" + Bygger konfiguration… + Aktivering av detta alternativ kommer att tvinga en återanslutning om nätverksanslutningen ändras (t.ex. WiFi <-> mobildata) + Återanslut vid förändring av nätverksanslutning + Nätverksstatus: %s + CA certifikat hämtas vanligtvis från Android Keystore. Ange ett separat certifikat om du får verifieringsfel på certifikatet. + Välj + Inget CA certifikat returnerades från Android Keystore. Autenticering kommer troligen att misslyckas. + Visar loggfönstret vid anslutning. Loggfönstret kan alltid nås från statusgardinen. + Visa loggfönstret + Kör på %1$s (%2$s) %3$s, Android API %4$d + Fel vid signering med Android keystore nyckeln %1$s: %2$s + Varningen vid VPN-anslutning som berättar att denna app kan avlyssna all trafik utfärdas av systemet för att förhindra missbruk av VPNService API.\nNotifieringen om VPN-anslutning (nyckelsymbolen) tillhandahålles också av Android-systemet för att signalera en pågående VPN-anslutning. På vissa ROM spelar denna notifiering ett ljud.\nAndroid har infört dessa dialogrutor och notifieringar för din egen säkerhet och kan inte undvikas. (På vissa ROM innehåller dessa tyvärr ljud) + Anslutnings varning och ljud + Svensk översättning av Zapp och Mr_Arrow + IP och DNS + Grundläggande + Rutter + Obskyra OpenVPN inställningar. Behövs normalt inte. + Avancerad + ICS OpenVPN konfiguration + Inga DNS-servrar används. Namnuppslag kommer kanske inte fungera. Överväg att namnge egna DNS-servrar. Observera även att Android kommer att fortsätta att använda dina proxyinställningar som anges för din mobildata/Wi-Fi-anslutning när inga DNS-servrar är konfigurerade. + Kunde inte lägga till DNS-servern \"%1$s\", förkastades av systemet: %2$s + <p>Hämta en fungerande konfiguration (testad på din dator eller nerladdad från din leverantör/organisation)</p><p>Om det är en enda fil utan extra pem/pks12 filer kan du maila den till dig själv och öppna den bifogade filen. Om du har flera filer lägg dem på ditt sd-kort.</p><p>Klicka på den i mailet bifogade filen/Användning mappikonen i VPN-listan för att importera konfigurationsfilen</p><p>Om det ger fel ang. saknade filer lägg dessa på ditt sd-kort.</p><p>Klicka på spara symbolen för att lägga till den importerade konfigurationen i VPN-listan</p><p>Anslut din VPN genom att klicka på konfigurationsnamnet</p><p>Om det finns fel eller varningar i loggen försöka förstå dessa varningar/fel och försök att åtgärda dem</p> + Snabbstart + Prova att ladda kärnmodulen tun.ko innan du försöker ansluta. Kräver root. + Ladda tun modul + Importera PKCS12 från konfigurationen till Android Keystore + Fel vid hämtning av proxyinställningar: %s + Använder proxy %1$s %2$d + Använd system proxy + Använda systemkonfigurationen för HTTP/HTTPS proxy för att ansluta. + Du kan <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">donera via PayPal</a> + OpenVPN återansluter VPN om den var aktiv vid avstängning/omstart. Läs FAQ om anslutningsvarning innan du använder detta alternativ. + Återanslut vid omstart + Ignorera + Starta om + Konfigurationsändringar tillämpas efter omstart av VPN. Starta(om) VPN nu? + Konfigurationen ändrades + Kunde inte avgöra vilken den sista anslutna profilen var för redigering + Dubblerade meddelanden + Om Android tillfälligt har brist på systemminne (RAM), tas program och tjänster som inte behövs just nu bort från aktiva minnet. Detta avslutar en pågående VPN-anslutning. För att se till att pågående anslutning/OpenVPN överlever körs denna tjänst med högre prioritet. För att köra med högre prioritet måste applikationen visa en notifikation. Nyckelikonen visas av systemet, som beskrivs i FAQ tidigare, och räknas inte som ett meddelande som ger rättighet att köra med högre prioritet. + Inga VPN-profiler har definierats. + Använd <img src=\"ic_menu_add\"/> ikonen för att lägga till en ny VPN + Använd <img src=\"ic_menu_archive\"/> ikonen för att importera en befintlig (.ovpn eller .conf) profil från ditt sd-kort. + Tänk på att titta i FAQ\'n. Där finns en snabbstartguide. + Konfiguration för rutter/gränssnitt + Fall inte tillbaka till ingen VPN-anslutning när OpenVPN återansluter. + Ihållande tun + OpenVPN Log + Importera OpenVPN konfiguration + Batteriförbrukning + Funktionen Internetdelning i Android (över WiFi, USB eller Bluetooth) och VPNService API (används av denna applikation) fungerar inte tillsammans. För mer information se <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\">ärende #34</a> + VPN och Internetdelning + Anslutningsförsök + Inställningar för återanslutning + Antal sekunder att vänta mellan anslutningsförsök. + Sekunder mellan anslutningar + OpenVPN kraschade oväntat. Försök att använda skicka Minidump alternativet i huvudmenyn + Skicka Minidump till utvecklare + Skickar felsökningsinformation om senaste krasch till utvecklare + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + Ansluter + Väntar på svar från servern + Autentiserar + Hämtar klientkonfiguration + Tilldelar IP-adresser + Lägger till rutter + Ansluten + Koppla ifrån + Återansluter + Avslutar + Kör inte + Slår upp värdnamn + Ansluter (TCP) + Autentisering misslyckades + Väntar på användbart nätverk + ↓%2$s/s %1$s - ↑%4$s/s %3$s + Inte ansluten + Ansluter till VPN %s + Ansluter till VPN %s + Vissa versioner av Android 4.1 har problem om namnet på keystore certifikatet innehåller icke alfanumeriska tecken (som mellanslag, understreck eller bindestreck). Försök att omimportera certifikatet utan specialtecken + Krypteringschiffer + Paketautentisering + Ange autentiseringsmetod för paket + Kör på %1$s (%2$s) %3$s, Android API %4$d, version %5$s, %6$s + byggd av %s + felsöknings bygge + officiellt bygge + Kopiera till profil + Crashdump + Lägg till + Skicka konfigurationsfilen + Komplett DN + Din importerade konfiguration innehåller gamla, ej längre i bruk, tls-remote optioner som använder ett annat DN-format. + RDN (vanligt namn) + RDN prefix + TLS-remote (ej längre i bruk) + Du kan hjälpa till med översättningen genom att besöka http://crowdin.net/project/ics-openvpn/invite + %1$s försöker styra %2$s + Jag litar på denna applikation. + Ingen app får använda externa API + Tillåtna apps: %s + Rensa lista över tillåtna externa apps? \nNuvarande lista över tillåtna apps:\n\n%s + Pausa VPN-anslutningen efter att skärmen stängts av + Pausa anslutning när skärmen är avstängd: mindre än %1$s i %2$ss + Varning: Permanent tun är inte aktiverat för denna VPN. Trafiken kommer att använda den normala Internet-anslutning när skärmen är avstängd. + Spara lösenord + diff --git a/ics-openvpn-stripped/main/src/main/res/values-tr/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-tr/strings.xml new file mode 100755 index 00000000..85f1740f --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-tr/strings.xml @@ -0,0 +1,310 @@ + + + + + Android için OpenVPN + Sunucu adresi: + Sunucu Portu: + Konum + Dizin Okunamıyor + Seçin + İptal + Veri Yok + LZO sıkıştırma + Sertifika yok + İstemci sertifikası + İstemci sertifika anahtarı + PCKCS12 Dosyası + CA Sertifikası + Bir sertifika seçmelisiniz + Kaynak kodu ve sorun izcisine http://code.google.com/p/ics-openvpn/ buradan ulaşablirsiniz + Bu program, aşağıdaki bileşenleri kullanır; tam bilgi için lisanslardaki kaynak koduna bakınız + Hakkında + + Profiller + Tür + PKCS12 Şifresi + Seçiniz… + Bir dosya seçmelisiniz + TLS Kimlik Doğrulamasını Kullan + TLS yönü + CIDR formatında IPv6 Adresi/Ağ maskesi girin (örneğin 2000:dd::23/64) + IPv4 adresi/ağ maskesi CIDR biçimi (örneğin 1.2.3.4/24) girin + IPv4 Adresi + IPv6 adresi + Özel OpenVPN seçenekleri girin.Dikkatli kullanın.Ayrıca tun kullanan VPN ler tasarlanan bu program tarafından desteklenmiyor.Eğer özel bir seçenek eksikliği olduğunu düşünüyorsanız geliştirici ile iletişime geçin + Kullanıcı Adı + Şifre + Statik yapılandırma için TLS Auth Keys statik anahtar olarak kullanılacak + VPN\'i Yapılandırın + Profil Ekle + Yeni profili tanımlayan bir isim girin + Benzersiz bir profil adı girin + Profil Adı + Kullanıcı sertifikası seçmelisiniz + Hiçbir hata bulunamadı + Yapılandırma hatası + IPv4 adresi ayrıştırma hatası + Özel yolları ayrıştırma hatası + (Talep üzerine sorgulamak için boş bırakın) + OpenVPN Kısayolu + VPN\'e Bağlan + Kısayolu belirtilen profil bulunamadı + Rastgele host ön eki + Host ismine 6 rasgele karakter ekler + Özel seçenekleri etkinleştir + Özel seçenekleri belirleyin.Dikkatli kullanın! + Yol Android tarafından reddedildi + Bağlantıyı kes + VPN bağlantısını kes + Kayıtları temizle + Onayı İptal et + Bağlı VPN bağlantısını keseyim / bağlantı girişimini iptal edeyim mi? + VPN kaldırın + (- Uzak-CERT-tls sunucu) sunucu TLS Sunucu uzantıları ile bir sertifika kullanır olmadığını kontrol eder + TLS sunucu sertifikasını bekleyin + Uzak sunucu sertifika konusunu DN kontrol eder + Sertifika sunucu adı kontrol + Uzaktan sertifika DN doğrulamak için kullanılan onay belirtin (örneğin C = DE, L = Paderborn, OU = Kuş IP Taşıyıcılar, CN = openvpn.blinkt.de) \ n \ tam DN veya RDN (openvpn.blinkt.de nBuörnek) ya da doğrulama için bir RDN önek. \ n \ nWhen RDN önek \"Sunucu\" ile \"Sunucu-1\" ve \"Sunucu-2\" ile eşleşir \ n \ boş metin alanına ana bilgisayar adı, sunucu karşı RDN kontrol edecektir nLeaving. \ n \ nBu daha fazla bilgi OpenVPN 2.3.1 + man sayfasına altında-kontrol-x509-adını görmek + Uzak sertifika konusu + TLS Anahtar Kimlik Doğrulaması sağlar + TLS Kimlik Doğrulama Dosyası + İstekler IP adresleri, sunucudan yolları ve zamanlama seçenekleri. + Herhangi bir bilgi sunucudan istenir. Ayarlar aşağıda belirtildiği gibidir. + Ayarlarını çekin + DNS + Sunucusu tarafından DNS ayarları geçersiz + Kendi DNS Sunucularını kullanın + Arama Etki Alanı + DNS Sunucusu kullanılacak. + DNS Serveri + Ikinci DNS Serveri Kullan Normal DNS Serveri Erişilmezse. + DNS Sunucusunu Yedekle + Itilmiş rotalar göz ardı + Yoksay sunucu tarafından itti yönlendirilir. + Tüm trafiği VPN üzerinden kullan + Varsayılan Yolu kullan + Özel yolları girin. CIDR biçimde tek hedef girin. \"10.0.0.0 / 8 2002 :: / 16\" ağlar VPN üzerinden 10.0.0.0 / 8 ve 2002 :: / 16 doğrudan. + Özel Yollar + Ayrıntı düzeyi Log + Herhangi bir IP kimlik doğrulaması paketlerini sağlar + Herhangi bir IP kimlik doğrulaması paketlerini sağlar + Özel Seçenekler + VPN Ayarlarını düzenle + VPN profilleri kaldırılsın mı \'%s\'? + Bazı özel ICS görüntülerde / dev / tun üzerinde izni yanlış olabilir, ya da tun modülünü tamamen eksik olabilir. CM9 görüntüleri genel ayarlar altında düzeltme mülkiyet seçeneğini deneyin + Tun arayüzü açılamadı + "Hata:" + Temizle + Açılış tun arabirimi: + Yerel IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + DNS sunucusu: %1$s, etki alanı: %2$s + Arabirim bilgileri %1$s ve %2$s var, tabii ikinci eş adresi uzaktan adresidir. /32 Kullanarak için yerel IP ağ maskesi. OpenVPN tarafından verilen \"%3$s\" modudur. + %1$s ve %2$s olarak IP yolu ile CIDR ağ maskesi, ağ maskesi /32 kullanarak yapamazsınız. + Rota %1$s/%2$s %3$s/%2$s için düzeltilmiş + Android Anahtarlık sertifika erişemiyor. Bu bir yazılım yükseltmesi veya app/app ayarları bir yedeğini geri yükleme tarafından kaynaklanabilir. Lütfen VPN düzenlemek ve sertifikanın sertifika erişim izni yeniden oluşturmak için temel ayarları altında yeniden seçin. + %1$s %2$s + Günlük dosyasını gönder + Gönder + ICS OpenVPN günlük dosyası + Panoya kopyalanan günlük girdisi + Moda dokunun + Dokunun modu olmayan kök VPN API ile mümkün değildir. Bu nedenle bu uygulama dokunun destek sağlayamaz + Yine? Dalga mı geçiyorsun? Hayır, dokunun modu gerçekten desteklenmez ve bu desteklenecektir soran daha fazla posta gönderme değil yardımcı olacaktır. + Üçüncü kez? Aslında, bir yazabilirsiniz bir Katman2 bilgi göndermek eklemek ve şerit Katman2 bilgi tun dayalı bir dokunun emülatör alırsınız. Ama bu dokunun emülatör da ARP ve muhtemelen bir DHCP istemci uygulamak gerekir. Herkes bu yönde herhangi bir işi farkında değilim. Bu konuda kodlama başlatmak istiyorsanız bana ulaşın. + Sık Sorulan Sorular + Günlük girdisi kopyalama + Bir tek günlük girişi basın kopyalamak ve günlük girdisi üzerinde tutun. Tüm günlük kopyala ve gönderme göndermek günlük seçeneğini kullanın. Görünür değil Eğer GUI donanım menü düğmesini kullanın. + Kısayolları başlatmak için + Masaüstünüzde OpenVPN başlatmak için bir kısayol yerleştirebilirsiniz. Homescreen programınıza bağlı olarak bir kısayol ya da bir widget eklemeniz gerekecek. + Görüntü VPNService API desteklemiyor, özür :( + Şifreleme + Şifreleme yöntemi girin + OpenVPN tarafından kullanılan şifreleme algoritmasını girin. Varsayılan şifrelemeyi kullanmak için boş bırakın. + OpenVPN için kullanılan kimlik doğrulamasını özet girin. Varsayılan özeti kullanmak için boş bırakın. + Kimlik doğrulama/şifreleme + Dosya Gezgini + Satır içi dosya + Dosya alınırken hata oluştu + Dosya sistemindeki dosya içe aktarılamadı + [[Satır içi dosya veri]] + IP bilgisi olmadan tun cihazı açmayı reddediyor + Ovpn dosyası alma profili + Alma + Profil alma için okunamadı + Yapılandırma dosyası okuma hatası + Profil ekle + Alınan yapılandırma dosyasında belirtilen dosya %1$s bulunamadı + Kaynak %1$s yapılandırma dosyası alma + Senin yapılandırma kullanıcı arabirimi yapılandırmaları için eşleştirilmemiş birkaç yapılandırma seçenekleri vardı. Bu seçenekler özel yapılandırma seçenekleri eklenmiştir. Özel yapılandırma aşağıda görüntülenir: + Yapılandırma dosyası okuması bitmiş. + Yerel adresi ve bağlantı noktası için bağlama yapmak + Hiçbir yerel bağlama + Yapılandırma dosyası al + Güvenlik konuları + OpenVPN güvenlik duyarlı olduğu gibi güvenlik hakkında birkaç not mantıklı bulunmaktadır. Sdcard üzerindeki tüm verileri doğal olarak güvensiz. Her app (örneğin bu program herhangi özel bir sd kartı hak gerektirir) okuyabilirsiniz. Bu uygulama verileri yalnızca uygulama tarafından okunabilir. Cacert/cert/anahtarında dosya iletişim kutusu için içe aktarma seçeneğini kullanarak verileri VPN profilinizde saklanır. VPN profilleri yalnızca bu uygulama tarafından erişilebilir. (Daha sonra sd kartta kopyaları sil unutmayın). Bile erişilebilir rağmen bu uygulama tarafından yalnızca verileri hala şifreli değildir. Telefon veya diğer olağanüstü köklenme tarafından veri almak mümkün olabilir. Kurtarmak parola düz metin olarak depolanır. Pkcs12 dosyaları için onları android deposunun almak önerilir. + Alma + Hata gösteren sertifika seçimi + Android 4.0 + göstermeye çalışıyor bir istisna var sertifika seçimi iletişim. Bu hiç bu kadar standart bir özellik olarak Android 4.0 + gerçekleşmesi gerekir. Belki sertifika depolama ortamı için Android ROM destek bozuldu + IPv4 + IPv6 + Durum iletisi bekleniyor… + içe aktarılan profil + İçe aktarılan profil %d + Kırık görüntüleri + <p> Resmi HTC görüntüleri tünelden değil trafiğe neden garip bir yönlendirme sorunu var için bilinen (Ayrıca bkz: < bir href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=18\" > sorunu 18 </a> hata izci içinde.)</p> <p> büyük resmi SONY Xperia Arc S ve görüntüleri Xperia Ray VPNService tamamen görüntüden eksik bildirilmiştir. (Ayrıca bkz: < bir href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=29\" > sayı 29 </a> hata izci içinde.)</p> <p> ya da eksik/dev haklarını tun modülü olabilir görüntüleri üzerinde özel yapı/tun-ebilmek var olmak yanlış. Bazı CM9 görüntü \"etkin aygıt belirli kesmek\" altında \"mülkiyet saptamak\" seçeneği gerek. </p> <p> en önemlisi: cihazınızda kopuk Android resmi varsa, senin satıcısına bildirin. Daha fazla kişi kim daha onlar bunu </p> düzeltmek için olabilir satıcıya, sorun bildir + PKCS12 Dosya şifreleme anahtarı + Özel Anahtar Şifresi + Şifre + Dosya simgesi + TLS kimlik doğrulama + Oluşturulan yapılandırma + Ayarlar + Sisteme /dev/tun sahibi çalışır. Bazı CM9 görüntüleri bu işe VPNService API yapmak gerekir. Kök gerektirir. + / Dev / tun sahipliğini düzeltmek + Oluşturulan OpenVPN yapılandırma dosyası göster + \"%s\" düzenleme + Yapılandırma binası… + Ağ durumu (örneğin WiFi üzerinden cep telefonlarına/cep) değiştirdiyseniz bu seçeneği açmak yeniden bağlantı zorlar + Ağ değişikliği üzerinde yeniden bağlan + Ağ Durumu: %s + Sertifika yetkilisi sertifikası genellikle Android deposunun döndürülür. Sertifika doğrulama hataları alırsanız ayrı bir sertifika belirtin. + Seçin + Hayır CA sertifikasını okurken Android deposunu döndürdü. Kimlik doğrulama muhtemelen başarısız olur. + Bağlama kütüğü penceresi üzerinde gösterir. Kütüğü penceresi her zaman bildirim durumu erişilebilir. + Günlüğü penceresini göster + %1$s (%2$s) %3$s, Android API %4$d d\'çalışması + Android deposunun anahtarı %1$s %2$s ile imzalama hatası + Bu app tüm trafiği geçirebilir belirten VPN bağlantısı uyarı dayatılan VPNService API.\nThe VPN bağlantısının istismarını önlemek için sistem tarafından bildirim (anahtar simgesi) da devam eden bir VPN bağlantısı sinyal için Android sistem tarafından uygulanmaktadır. Bu bildirim çalış bazı görüntülerde ses. \nAndroid kendi güvenliğiniz için bu sistem diyaloglar tanıttı ve circumenvented olamaz emin oldum. (Bazı görüntülerde bu unfortunely notifciation ses içerir) + Bağlantı uyarı ve bildirim sesi + İngilizce Çeviri: Arne + IP ve DNS + Temel + Yönlendiriliyor + OpenVPN ayarları belirsiz. Normalde gerekmez. + Gelişmiş + ICS Opnvpn Yapılandırma + Kullanılan DNS sunucusu yok. Ad çözümlemesi çalışmıyor olabilir. Özel DNS sunucularını ayarlamayı düşünün. Ayrıca Android cep/Wi-Fi bağlantınız için DNS sunucusu ayarlandığında belirtilen proxy ayarlarını kullanmaya devam unutmayın. + DNS sunucusu sistem tarafından reddedilen %1$s, eklenemedi: %2$s + IP adresi \"%1$s\"yapılandırılamadı ,sistem tarafından reddedildi: %2$s + (bilgisayarınızdaki veya sağlayıcı/organizasyon yüklenebilir test) bir çalışma config <p> olsun </p> <p> Hayır hiçbir ilave pem/pks12 ile tek bir dosya dosyaları ise dosyayı kendiniz e-posta ve eki açın. Birden çok dosya varsa koymak onları üstünde senin sd kartı </p> <p> e-posta eki/kullanım üzerinde klasör simgesini tıklatın, sd eksik dosyaları koyun dosyaları eksik hakkında hatalar varsa config dosyasının </p> <p> almak için vpn listedeki kayıt tıklayın kartı </p> <p> sembol alınan VPN </p> VPN listenize eklemek için <p > VPN varsa hata veya uyarılar günlüğüne uyarı/hata anlamak ve onları </p> gidermek çalışın VPN </p> <p> adını tıklatarak bağlanmak  + Hızlı Başlangıç + Bağlanmadan önce tun.ko yüklemeyi deneyin.Root edilmiş cihazlar gerekli. + Tun modülünü yükle + PKCS12 yapılandırma Android deposunun içine alma + Proxy ayarları alınırken hata oluştu: %s + Proxy %1$s %2$d kullanarak + Sistem proxy kullan + Sistem geniş yapılandırma HTTP/HTTPS proxy için bağlanmak için kullanın. + Şunları yapabilirsiniz <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">PayPal ile bağış </a> + Sistem yeniden başlatma/kapatma üzerinde etkin OpenVPN bir VPN yeniden bağlanır. Bu seçeneği kullanmadan önce bağlantı uyarı SSS okuyun. + Yeniden başlatmada tekrar bağlan + Yoksay + Yeniden Başlat + Yapılandırma değişiklikleri, VPN yeniden başlattıktan sonra geçerli olur. (Yeniden) VPN şimdi başlıyorsun? + Yapılandırma değişti + Düzenleme için son bağlı profil belirlenemedi + Yinelenen bildirimler + Android sistem belleği (RAM) basınç altında ise, apps ve hizmet hangi anda gerekli değildir aktif bellekten kaldırılır. Bu devam eden bir VPN bağlantısını sonlandırır. Bağlantı/OpenVPN ile daha yüksek öncelikli hizmet çalışır hayatta emin olmak için. Daha yüksek öncelik ile çalıştırmak için uygulama bir bildirim görüntülemeniz gerekir. Anahtar bildirim simgesini, önceki SSS girdisi içinde açıklandığı gibi sistem tarafından uygulanmaktadır. Daha yüksek öncelik ile çalışan amaç için app bildirim olarak sayılmaz. + Tanımlanan VPN profili yok. + Kullanım < img src = \"ic_menu_add\" / > yeni bir VPN eklemek için simge + Kullanım < img src = \"ic_menu_archive\" / > simgesi sdcard (.ovpn veya .conf) bir profili almak için. + Ayrıca SSS kontrol etmeyi unutmayın. Hızlı Başlangıç Kılavuzu vardır. + Yönlendirme/arabirimi yapılandırması + OpenVPN yeniden bağlamadan zaman VPN bağlantısı değil geri dönüş yap + Kalıcı tun + OpenVPN kayıtları + OpenVPN yapılandırması aktar + Pil tüketimi + Benim kişisel testlerinde yüksek pil tüketimi OpenVPN ana sebebi canlı tutma paketleri var. Bir yapılandırma yönergesi gibi çoğu OpenVPN sunucusu var \' keepalive 10 60 istemci ve sunucu 10 saniyede canlı tutma paketleri alışverişi neden \'. <p> Bunlar süre paketleri küçük ve çok trafik kullanmayın, mobil radyo ağ meşgul ve enerji tüketimini artırır. (Ayrıca bkz: < bir href=\"http://developer.android.com/training/efficient-downloads/efficient-network-access.html#RadioStateMachine\" > Radyo durum makinesi | Android geliştiriciler </a>) <p> Bu canlı tutma ayarı istemcide değiştirilemez. Yalnızca sistem yöneticisinin OpenVPN in ayarı değiştirebilirsiniz. <p> Ne yazık ki 60 saniyeden daha büyük bir canlı tutma ile UDP kullanarak bazı NAT ağ geçitleri işlem zaman aşımı nedeniyle bağlantıyı kesmek neden olabilir. TCP kullanarak uzun canlı tutma zaman aşımı ile çalışır, ancak TCP TCP üzerinden tünel son derece kötü bağlantılarında yüksek paket kaybı ile gerçekleştirir. (Bkz: < bir href=\"http://sites.inka.de/bigred/devel/tcp-tcp.html\" > neden TCP üzerinden TCP A kötü düşünce </a>) + Android hayvan zinciri özelliğin (üzerindeki, WiFi, USB veya Bluetooth) ve VPNService (Bu program tarafından kullanılan) API birlikte çalışmayabilir. Daha fazla ayrıntı için bkz: < bir href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\" > #34 </a> yayın + VPN ve Paylaşım + Yeniden bağlantı denemesi + Yeniden Bağlanma ayarları + Bağlantı girişimleri arasında beklenecek saniye sayısı. + Bağlantılar arasındaki Saniye + OpenVPN beklenmedik biçimde düştü. Lütfen ana menüde gönder mini döküm seçeneği kullanmayı düşünün + Geliştiriciye mini döküm gönder + Hata ayıklama bilgisini son hatayı geliştiriciye gönder + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + Bağlanıyor + Sunucudan yanıt bekleniyor + Kimlik Doğrulanıyor + İstemci yapılandırma alınıyor + IP Adresleri Atanıyor + Yollar ekleniyor + Bağlanıldı + Bağlantıyı kes + Yeniden bağlanıyor + Çıkılıyor + Çalışmıyor + Ana bilgisayar adları çözümleniyor + (TCP) Bağlanıyor + Kimlik doğrulaması başarısız + Kullanılabilir ağ için bekleniyor + ↓%2$s/s %1$s - ↑%4$s/s %3$s + Bağlı değil + %s VPN bağlanıyor + %s VPN bağlanıyor + Sertifika deposunun adını (gibi alanlarda, alt çizgi veya tire) sigara alfasayısal karakterler içeriyorsa, bazı yorum-in Android 4.1 sorunları var. Özel karakter içermeyen sertifika yeniden ithalat çalışın + Şifre şifresi + Paket kimlik doğrulama + Paket kimlik doğrulama yöntemini girin + Çalışan %1$s (%2$s) %3$s, Android API %4$d, sürüm %5$s, %6$s + %s tarafından inşa + hata ayıklama yapı + resmi yapı + Profili kopyalayın + Crashdump + Ekle + Yapılandırma dosyasını gönderin + Tam DN + Alınan yapılandırmanızı farklı bir DN biçimini kullanan eski kullanım dışı tls-uzaktan seçeneği kullanılır. + RDN (ortak ad) + RDN öneki + TLS-uzaktan (kullanım dışı) + Http://crowdin.net/project/ics-openvpn/invite ziyaret ederek çeviri yardımcı olabilir + %2$s denetlemek %1$s çalışır + Devam, tamamen OpenVPN Android için kontrol etmek ve tüm ağ trafiğini kesişmek üzere uygulama izin veriyorsunuz. Yapmak değil uygulama güvenmediğiniz sürece kabul. Aksi takdirde, verilerinizi kötü amaçlı yazılım tarafından tehlikeye sahip riski çalıştırılır.\" + Bu uygulamaya güveniyorum. + Harici API\'yi kullanma izniniz yok + Uygulamalar izni: %s + Açıkça izin verilen dış uygulamalar listesini? \nCurrent listesi izin verilen apps:\n\n%s + \"Ekran kapalı iken VPN ve 60\'lar daha az 64 kB transfer verilerde duraklatın. VPN duraklatma \"Kalıcı Tun\" seçeneği etkinleştirildiğinde aygıtınız ağ bağlantısı sayesinde bırakacaktır. \"Kalıcı Tun\" seçeneği olmadan aygıt yok VPN bağlantısı/koruma olacak. + Ekran kapandıktan sonra VPN bağlantısını duraklat + Duraklatma bağlantı durumu devre dışı ekran: %1$s %2$ss içinde daha az + Uyarı: kalıcı tun bu VPN için etkin değil. Ekran kapalı iken trafik normal Internet bağlantınızı kullanacak. + Parolayı Kaydet + VPN duraklatın + VPN yi çalıştırmaya devam edin + Kullanıcı isteğiyle VPN duraklatıldı + Ekran kapalıyken VPN duraklat + Aygıt özellikleri kesmek + Sertifika bilgilerini görüntüleyemiyor + Uygulama davranış + VPN davranış + VPN Profillerinin değiştirilmesine izin ver + + Donanım deposu: + Uygulama simgesi Android için OpenVPN kullanmaya çalışıyor + "Android 4.3 ile VPN onay başlayan\"overlaying apps\"karşı korunuyor. Bu giriş dokunmaya tepki değil iletişim kutusunda olur. Bindirmeleri kullanan bir uygulama varsa, bu davranışa neden olabilir. Kusurlu bir app temas yazar app bulursanız. Bu sorun tüm VPN uygulamaları Android 4.3 ve daha sonra etkiler. Ayrıca bkz: < bir href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=185\" > sayı 185 <a> ek ayrıntılar için " + VPN Onayla iletişim Android 4.3 ve üstü + Alternatif olarak Play Store den bağış yapabilirsiniz. + Bağış için teşekkürler%s! + Kayıtlar temizlendi. + Şifreyi göster + Anahtarlık erişim hatası: %s + Kısa + ISO + Zaman damgaları + Hiçbiri + Yükleme + İndirme + Vpn Durumu + Görünüm seçenekleri + Kural dışı durum: %1$s\n\n%2$s + %3$s: %1$s\n\n%2$s + Lisanslar + diff --git a/ics-openvpn-stripped/main/src/main/res/values-uk/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-uk/strings.xml new file mode 100755 index 00000000..3418ece1 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-uk/strings.xml @@ -0,0 +1,276 @@ + + + + + OpenVPN для Android + Адреса сервера: + Порт сервера: + Розташування + Не вдалося прочитати каталог + Вибрати + Скасувати + Немає даних + Стиснення LZO + Немає сертифіката + Сертифікат клієнта + Ключ сертифіката клієнта + Файл PKCS12 + Сертифікат CA + Потрібно вибрати сертифікат + Початковий код і відстеження проблем доступні по http://code.google.com/p/ics-openvpn/ + Ця програма використовує такі компоненти; перегляньте вихідний код для повної інформації про ліцензії + Про + Профілі + Тип + Пароль PKCS12 + Виберіть… + Слід вибрати файл + Використовувати TLS аутентифікацію + TLS напрямок + Введіть адресу IPv6/маску в CIDR форматі (напр., 2000:dd::23/64) + Введіть адресу IPv4/маску в CIDR форматі (напр., 1.2.3.4/24) + IPv4-адреса + IPv6-адреса + Введіть додаткові параметри OpenVPN. Використовуйте цю можливість з великою обережністю. Якщо ви вважаєте, що відсутній важливий параметр, то зв\'яжіться з автором + Ім\'я користувача + Пароль + Для статичної конфігурації ключі авторизації TLS будуть використовуватися як статичні ключі + Налаштувати VPN + Додати профіль + Введіть ім\'я нового профілю + Введіть унікальне ім\'я профілю + Ім\'я профілю + Потрібно вибрати сертифікат користувача + Помилок не знайдено + Помилка конфігурації + Помилка при розборі адреси IPv4 + Помилка аналізу налаштованих маршрутів + (залиште порожнім для запиту на вимогу) + Ярлик OpenVPN + Підключення до VPN + Профіль, вказаний у ярлику, не знайдено + Випадковий префікс вузла + Додає 6 випадкових символів перед іменем вузла + Увімкнути налаштовувані параметри + Укажіть налаштовувані параметри. Використовуйте з обережністю! + Маршрут відхилено Андроїдом + Від\'єднати + Відключити VPN + очистити журнал + Підтвердження скасування + Відключення активних VPN/скасувати спробу підключення? + Видалити VPN + Перевіряє, чи є сервер використовує сертифікат з сервера TLS розширень (--remote-cert-tls server) + Очікувати TLS сертифікат сервера + Перевірка DN об\'єкта віддаленого сертифіката + Перевірка імені вузла сертифікату + Перемикач способу перевірки DN сертифікату (eg C = DE, L = Paderborn, OU = Avian IP Carriers, CN = openvpn.blinkt.de) \n \nМожливо значення: повний DN, RDN (для прикладу openvpn.blinkt.de) або тільки преффікс RDN для перевірки. \n \nПрі використанні преффікса RDN, наприклад \"Server\", значення будуть \"Server-1\", \"Server-2\" і т.д. \n \nПрі порожньому текстовому полі перевірка проводитиметься по імені хоста. \n \nДля подробиць дивіться керівництво для OpenVPN 2.3.1 +, розділ-verify-x509-name + Об\'єкт віддаленого сертифіката + Увімкнути автентифікацію по TLS ключу + Файл авторизації TLS + Запити IP адрес, маршрутів та параметрів часу від сервера. + Не запитувати інформацію від сервера. Параметри необхідно вказати нижче. + Запитувати параметри + DNS + Переписати параметри DNS від сервера + Використовувати ваші власні DNS сервери + Домен пошуку + DNS сервер для використання. + DNS-сервер + Вторинний DNS-сервер використовується, якщо нормальний DNS-сервер недоступний. + Резервний DNS-сервер + Ігнорувати надіслані маршрути + Ігнорувати маршрути, надіслані сервером. + Перенаправляти увесь трафік через VPN + Використовувати типовий маршрут + Введіть користувацькі маршрути. Тільки введіть адресу призначення в форматі CIDR. \"10.0.0.0/8 2002::/16\" буде використано для 10.0.0.0/8 і 2002::/16 мереж через VPN. + Власні маршрути + Рівень деталізації журналу + Дозволити пакети аутентифікації з будь-якої IP-адреси + Дозволити \"плаваючий\" сервер + Власні параметри + Змінити налаштування VPN + Видалити VPN профіль \'%s\'? + На деяких користувацьких прошивках ICS права на /dev/tun можуть бути невірними або модуль tun може бути взагалі відсутнім. Для прошивок CM9 спробуйте виправити власника у загальних налаштуваннях + Не вдалося відкрити інтерфейс tun + "Помилка: " + Очистити + Відкриття tun інтерфейсу: + Адреса IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + DNS-сервер: %1$s, Домен: %2$s + Отримано інформацію інтерфейсу %1$s і %2$s, друга адреса є віддаленою адресою каналу. Використовується мережева маска /32 для локальної IP-адреси. Режим, встановлений OpenVPN: \"%3$s\". + Неможливо використовувати вирази %1$s і %2$s як маршрут за стандартом CIDR. використовується /32 як маска підмережі. + Виправлено маршрут з %1$s/%2$s на %3$s/%2$s + Не можна отримати доступ до сховища ключів та сертифікатів Андроїд. Це можливо спричинено оновлення прошивки або відновленням резервної копії програми чи її налаштувань. Будь ласка, відредагуйте профіль VPN та заново виберіть сертифікат у основних параметрах для створення доступу до сертифікату. + %1$s %2$s + Надіслати файл журналу + Надіслати + ICS OpenVPN файл журналу + Скопійовано запис журналу до буферу обміну + TAP режим + TAP режим не можливий в VPN API без рут. З цієї причини цей додаток не може надати підтримку TAP + Знову? Жартуєш? Ні, TAP режим дійсно не підтримується і надсилання все більше листів з питаннями чи це буде підтримуватись не допоможе. + Втретє? Насправді можна було б написати TAP емулятор на основі TUN який додавав інформацію 2 рівня при відправці і віднімав її при отриманні. Проте для цього TAP емулятора потрібно реалізувати ARP і можливо DHCP клієнта. Я не знаю будь-кого хто міг би цим зайнятися. Зв’яжіться зі мною, якщо ви хочете це зробити. + ЧаПи + Копіювання записів журналу + Для копіювання одного запису журналу натисніть і утримуйте цей запис. Щоб скопіювати/надіслати увесь журнал використовуйте параметр Надіслати журнал. Використовуйте апаратну кнопку меню, якщо ви не бачите у графічному інтерфейсі. + Ярлик для запуску + Ви можете розмістити ярлик для запуску OpenVPN на робочому столі. Залежно від програми домашнього екрану ви можете додати ярлик або віджет. + Ваша прошивка не підтримує VPNService API, вибачте :( + Шифрування + Введіть метод шифрування + Введіть the authentication digest для OpenVPN. Залиште порожнім для використання стандартних значень. + Автентифікація/Шифрування + Провідник файлів + Вбудований файл + Помилка імпорту файлу + Не вдалося імпортувати файл із файлової системи + [[Вбудований файл даних]] + Відмова у відкритті пристрою tun без інформації про IP-адресу + Імпорт профілю з ovpn файлу + Імпорт + Не вдалося прочитати профіль для імпорту + Помилка читання файлу конфігурації + додати профіль + Не можливо знайти файл %1$s, згаданий у імпортованому файлі конфігурації + Імпорт файлу конфігурації з джерела %1$s + Ваша конфігурація мала кілька варіантів конфігурації, які не відображені в інтерфейсі конфігурації. Ці варіанти були додані в якості користувача параметрів конфігурації. Призначена для користувача конфігурація відображається нижче: + Файл конфігурації успішно прочитаний. + Не прив\'язувати до локальної адреси і порту + Нема локальної прив\'язки + Імпорт файлу конфігурації + Вимоги до безпеки + "Так як OpenVPN чутливий до безпеки, то будуть розумними кілька зауважень щодо захисту. Всі дані на sd карті по суті не захищені. Кожний додаток може прочитати їх (наприклад ця програма не вимагає спеціальних привілеїв на sd карту). Дані цього додатка можуть бути прочитані тільки ним самим. При використанні опції імпорту для cacert/cert/key в діалоговому вікні файла, дані зберігаються в VPN профілі. VPN профілі доступні тільки цьому додатку. (Потім не забудьте видалити копії на sd карті). Незважаючи на те, що дані доступні тільки цьому додатку, вони все ще незашифровані. Шляхом отримання прав суперкористувача (root) на телефоні або іншими хитрощами можливо витягти дані. Також збережені паролі зберігаються в звичайному текстовому вигляді. Наполегливо рекомендується pkcs12 файли імпортувати в android сховище ключів. " + Імпорт + Помилка показу вибору сертифіката + Відбулася помилка при спробі виклику системного діалогу вибору сертифікатів Android 4.0 + Цього не повинно було статися на стандартній прошивці. Можливо у вашій прошивці зіпсовано сховище сертифікатів + IPv4 + IPv6 + Очікування повідомлення стану… + імпортований профіль + імпортований профіль: %d + Пошкоджені зображення + <p> Відомо, що офіційні прошивки HTC мають дивні проблеми з маршрутизацією, викликані тим, що трафік не йде через тунель (див. також <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=18\">Issue 18</a> в баг-трекері) </p> <p> Також повідомлялося, що в офіційних прошивках SONY для Xperia arc S і Xperia Ray повністю відсутній сервіс VPNService. Також інші прошивки від Sony можуть мати такі ж проблеми. (див. також <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=29\">Issue 29</a> в баг-трекері) </p> <p> У деяких вбудованих прошивках модуль tun може бути відсутнім або мати не правильні права файлу-пристрою /dev/tun. Деякі CM9 прошивки можуть вимагати виправлення власника в головних налаштуваннях. </p> <p> Важлива інформація: Якщо у вас прошивка із зазначеними проблемами, повідомте про це виробнику пристрою. Чим більше користувачів повідомить про проблему виробнику, тим більше шансів, що цей виробник зволить прибрати свої недоробки. </p> + PKCS12 Ключ шифрування файлу + Пароль закритого ключа + Пароль + Піктограма файлу + Аутентифікація TLS + Згенерована конфігурація + Параметри + Спробуйте змінити власника для /dev/tun. Деякі прошивки CM9 вимагають цього для коректної роботи API OpenVPN. Потрібний root. + Виправити власника /dev/tun + Показує згенерований файл конфігурації OpenVPN + Редагується \"%s\" + Побудова конфігурації… + Вмикання цього параметру примусить перепідключитися, якщо стан мережі змінився (напр. Wi-Fi/мобільний інтернет) + Перепідключатися при зміні мережі + Статус мережі: %s + Сертифікат СА звичайно повертається з сховища ключів Андроїд. Вкажіть окремий сертифікат, якщо ви отримали помилки при перевірці сертифікату. + Вибрати + Не вдалося отримати СА сертифікат при читанні із сховища ключів Андроїд. Автентифікація не вдалася. + Показати вікно журналу при з\'єднанні. Вікно журналу може бути завжди дрступним у панелі сповіщень. + Показати вікно журналу + Працює на %1$s (%2$s) %3$s, Android API %4$d + Помилка підпису з використанням ключа із сховища Андроїд %1$s: %2$s + Попередження VPN з\'єднання повідомляє вам, що цей додаток може перехоплювати весь мережевий трафік, і повідомляється системою попереджень VPNService API. \nСповіщення про VPN з\'єднання (символ \"Ключа\") також формується системою Android для сигналізації про вихідне VPN з\'єднання. У деяких прошивках це сповіщення супроводжується сигналом. \nAndroid використовує ці cповіщення для вашої власної безпеки і їх не можна обійти. (На жаль, на деяких прошивках також сповіщення супроводжується звуком) + Повідомлення про підключення та звук сповіщеня + Переклад українською від wvolov + IP-адреса та DNS + Основне + Маршрутизація + Приховані параметри OpenVPN. Зазвичай не потрібні. + Додатково + ICS Openvpn конфігурація + Жодний DNS сервер не використовується. Дозвіл імен може не працювати. Розгляньте питання про створення користувацьких серверів DNS. Зверніть увагу, що Android буде продовжувати використовувати налаштування проксі-сервера, вказаного для вашого мобільного / Wi-Fi з\'єднання, коли не задано DNS сервери. + Не можливо додати DNS-сервер \"%1$s\", відхилено системою: %2$s + <p> Використовуйте готову конфігурацію (протестовану на вашому комп\'ютері або отриману від вашого провайдера) </p> <p> Якщо це простий файл без pem/pks12 ви можете відправити його по email на свій пристрій. Якщо ж це декілька файлів, ви можете використовувати їх зі своєї карти пам\'яті. </p> <p> Просто натисніть на .сonf файл або виберіть його за допомогою меню в програмі для імпорту конфігурації </p> <p> Якщо програма видасть помилку про брак деяких файлів, просто помістіть ці файли на карту пам\'яті </p> <p> Натисніть Збереження для додавання імпортованої конфігурації в програму </p> <p> Запустіть ваш VPN-тунель, натиснувши на його назву в списку </p> <p> Якщо при запуску виникли помилки спробуйте розібратися і усунути їх. </p> + Швидкий старт + Спробуйте завантажити модуль ядра tun.ko перш ніж з\'єднатися. Необхідний пристрій з правами root. + Завантажити tun-модуль + Імпорт PKCS12 з конфігурації у сховищі ключів Андроїд + Помилка отримання параметрів проксі: %s + Використовується проксі %1$s %2$d + Використовувати системний проксі + Використовувати системну конфігурацію HTTP/HTTPS проксі для з\'єднання. + Ви можете <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">пожертвувати через PayPal</a> + OpenVPN буде перепідключатися, якщо він був активний в момент вимикання/перезавантаження. Будь ласка, прочитайте ЧаП перед тим, як використовувати цей параметр. + Перепідключати при перезавантаженні + Ігнорувати + Перезапустити + Після перезапуску VPN застосувати зміни конфігурації. (Пере)запустити VPN тепер? + Конфігурація змінена + Не вдалося визначити останній підключений профіль для редагування + Дублювати сповіщення + Якщо в Android виникає нестача оперативної пам\'яті (RAM), непотрібні служби і програми зупиняються. Через це переривається встановлене VPN-з\'єднання. Щоб уникнути цього, програму потрібно запускати з підвищеним пріоритетом. Для запуску з високим пріоритетом програма повинна вивести попередження. Піктограма ключа сповіщення виводиться системою, як описано в попередньому пункті ЧаП. Це не вважається як програмне сповіщення з метою запуску з вищим пріоритетом. + VPN профіль не визначено. + Використовуйте <img src=\"ic_menu_add\"/> піктограму для додання нової VPN + Використовуйте <img src=\"ic_menu_archive\"/> піктограму для імпорту існуючого (.ovpn or .conf) профілю з вашої карти пам\'яті. + Не забудьте заглянути у ЧаП. Там також є короткий посібник. + Конфігурація маршрутизації/інтерфейсу + Не повертатися до жодного VPN з\'єднання, коли OpenVPN перепідключається. + Стійкість tun + Журнал OpenVPN + Імпорт конфігурації OpenVPN + Споживання акумулятора + У моїх особистих тестах основна причина високого споживання батареї OpenVPN є підтримуючі пакети. Більшість OpenVPN сервера мають директиви конфігурації, як \"залишайся в живих 10 60\", які перекладаються як підтримуючий пакет від клієнта до сервера і від сервера до клієнта кожні десять секунд. <p> Хоча ці пакети є невеликими і не використовують багато трафіку, вони тримають мережі мобільного радіозв\'язку зайнятими і збільшвють споживання енергії. (Див. також <a href=\"http://developer.android.com/training/efficient-downloads/efficient-network-access.html#RadioStateMachine\">Радіо State Machine | Android Developers </a>) <p> Цей параметр надсилання пакетів не може бути змінений на клієнті. Тільки системний адміністратор OpenVPN може змінити настройки. <p> На жаль, використання цього параметру більше 60 секунд з UDP має проблеми з деякими шлюзами NAT, які закінчуються стан підключення після короткого тайм-ауту (60 с в моїх тестах). Використання TCP з довгими затримками працює, але має проблему TCP над TCP. (Див. <a href=\"http://sites.inka.de/bigred/devel/tcp-tcp.html\"> Чому TCP над TCP є поганим середовищем</a>) + Функція транзитного з\'єднання на Android (через WiFi, USB або Bluetooth) та VPNService API (використовуване цією програмою) не працюють разом. Детальніше в <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\"> Issue 34 </a> + VPN і тетерінг + Спроб підключення + Налаштування перепідключення + Кількість секунд очікування між спробами підключення. + Секунд між підключеннями + OpenVPN впав несподівано. Будь ласка, розгляньте використання параметру \"Надіслати Мінідамп\" в головному меню + Надіслати мінідамп розробнику + Відправляє налагоджувальну інформацію розробнику про останнє аварійне завершення + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + Підключення + Очікування відповіді сервера + Аутентифікація + Отримання конфігурації клієнта + Перепризначення IP-адрес + Додавання маршрутів + Підключено + Від\'єднати + Повторне підключення + Виходимо + Не працює + Розпізнавання імен вузлів + Підключення (TCP) + Помилка автентифікації + Очікування на використання мережі + ↓%2$s/s %1$s - ↑%4$s/s %3$s + Не підключено + Підключення до VPN %s + Підключення до VPN %s + У деяких версіях Android 4.1 є проблеми, якщо ім\'я сертифікату містить не буквено-цифрові символи (наприклад, пробіли, підкреслення або тире). Спробуйте перевстановити сертифікат без використання спеціальних символів. + Алгоритм шифрування + Пакети автентифікації + Введіть метод автентифікації пакетів + Запущено на %1$s (%2$s) %3$s, Android API %4$d, версії %5$s, %6$s + побудована по %s + відлагоджувальна збірка + Офіційна збірка + Скопіювати в профіль + Звіт про крах + Додати + Надіслати файл конфігурації + Повний DN + Імпортована конфігурація використовує застарілий параметр tls-remote, який має інший формат DN. + RDN (загальне ім\'я) + RDN префікс + tls-remote (ЗАСТАРІЛЕ) + Ви можете допомогти в перекладі, відвідавши http://crowdin.net/project/ics-openvpn/invite + %1$s спроб контролювати %2$s + Я довіряю цьому додатку. + Не дозволяється використовувати зовнішнє API + Дозволенi додатки: %s + Очистити список дозволених зовнішніх програм \nПоточний список дозволених програм:\n\n%s + "Пауза VPN, коли екран вимкнений і менш ніж 64 Кб переданих даних за 60с. Коли „Постійний тун“ увімкнений пауза VPN залишить ваш пристрій без відсутності мережевого підключення. Без параметра „Постійний тун“ пристрій не буде мати ніякого VPN підключення / захисту. + Пауза VPN з\'єднання після вимкнення екрану + Призупинення зв\'язку в екрані вимкненого стану: менше %1$s у %2$sс. + Попередження: Постійний тут не увімкнений для цього VPN. Трафік буде використовувати звичайне інтернет-з\'єднання, коли екран вимкнений. + Зберегти пароль + diff --git a/ics-openvpn-stripped/main/src/main/res/values-zh-rCN/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-zh-rCN/strings.xml new file mode 100755 index 00000000..a2fb95ce --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-zh-rCN/strings.xml @@ -0,0 +1,274 @@ + + + + OpenVPN for Android + 服务器地址： + 服务器端口： + 地点 + 无法读取目录 + 选择 + 取消 + 无数据 + LZO 压缩 + 无客户端证书 + 客户端证书 + 客户端证书密钥 + PKCS12 文件 + CA 证书 + 您必须选择一个证书 + 请前往 http://code.google.com/p/ics-openvpn/ 查看源码或提供问题反馈 + 本程序使用以下组件，请在 Licenses 查看源码获取更详细内容。 + 关于 + 配置文件 + 类型 + PKCS12 密码 + 请选择... + 您必须选择一个文件 + 使用 TLS 身份验证 + TLS 方向 + 输入 CIDR 格式 IPv6 地址/子网掩码（例如：2000:dd::23/64） + 输入 CIDR 格式 IPv4 地址/子网掩码（例如：1.2.3.4/24） + IPv4 地址 + IPv6 地址 + 请谨慎输入 OpenVPN 的自定义选项。此外请注意许多与 tun 模块有关的 OpenVPN 设置由于系统 VPN 功能的设计而不能得到支持。如果您缺少认为一个很重要的选项，请联系作者。 + 用户名 + 密码 + 静态配置中 TLS 身份验证密钥将被用作静态密钥 + 配置 VPN + 添加配置文件 + 输入新配置文件名： + 请输入一个唯一的配置文件名称 + 配置文件名称 + 您必须选择一个用户证书 + 未找到错误 + 配置有错误 + 无法解析 IPv4 地址 + 无法解析自定义路由 + (根据需求留空) + OpenVPN 快捷方式 + 连接至 VPN + 未找到快捷方式中指定的配置文件 + 随机主机前缀 + 在主机名前添加6个随机字符 + 启用自定义选项 + 指定自定义选项。小心！ + Android 拒绝了路由 + 断开 + 断开连接 + 清除日志 + 取消确认 + 断开已连接的 VPN / 取消连接尝试？ + 删除 VPN + 检查服务器是否使用 TLS 服务器证书 + 除了 TLS 服务器 + 检查远程服务器证书的 DN 属性 + 证书主机名检查 + 勾选此项将验证远程证书的 DN 属性（例：C=DE, L=Paderborn, OU=Avian IP Carriers, CN=openvpn.blinkt.de）\n\n输入完整的 DN 或者 RDN 以便进行验证。\n\nRDN前缀 \"Server\" 可以匹配 \"Server-1\" 以及 \"SERVER-2\"\n\n若留空则将仅验证 RDN 而不验证主机名。\n\n有关更多信息请查看 OpenVPN 2.3.1+ 参考手册的 --verify-x509-name 小节 + 远程证书主题 + 启用 TLS 密钥认证 + TLS 认证文件 + 从服务器请求 IP 地址、 路由规则和计时选项。 + 没有从服务器请求信息。设置需要在下方被指定。 + Pull 设置 + DNS + 覆盖服务器 DNS 设置 + 使用自定义 DNS 服务器 + 搜索域 + 要使用的 DNS 服务器 + DNS 服务器 + 如果无法达到主 DNS 服务器，要使用辅助 DNS 服务器。 + 备用 DNS 服务器 + 忽略推送路由 + 忽略服务器推送的路由 + 重定向所有流量到VPN + 使用默认路由 + 输入自定义路由。输入 CIDR 格式地址。 + 自定义路由 + 日志详细级别 + 允许来自任何 IP 的认证数据包 + 允许浮服务器 + 自定义选项 + 编辑 VPN 设置 + 移除 VPN 配置文件 \'%s\' 吗？ + 在某些自定义 ICS 版本上，/dev/tun 的权限可能会有错误，或者根本就没有该文件。CM9 用户请尝试通过本程序的设置功能修复权限 + 未能打开 tun 模块 + 错误 + 清除 + 正在打开 tun 设备： + 本地 IPv4： %1$s/%2$d IPv6： %3$s MTU： %4$d + DNS 服务器: %1$s, 域名: %2$s + 已获得接口信息 %1$s 以及 %2$s，将第二个地址作为远程地址。使用 /32 作为本地掩码。OpenVPN 给出的模式是 \"%3$s\"。 + 无法将 %1$s 和 %2$s 作为 CIDR 形式的路由，将使用 /32 的子网掩码。 + 纠正路由 %1$s/%2$s 为 %3$s/%2$s + 不能访问 Android 密钥链证书。这可能是由于固件升级或通过还原备份的应用程序/软件设置造成的。请编辑 VPN 配置文件并在基本设置中重新选择证书以重新创建证书访问权限。 + %1$s %2$s + 发送日志文件 + 发送 + ICS OpenVPN 日志文件 + 日志条目已复制剪贴板 + Tap 模式 + Tap 模式在未 root 的机器上不可用。因此本程序无法提供 tap 模块支持 + 还来? 您在开玩笑嘛? tap 连接模式是不支持的，不要再发邮件问这些问题了。 + 这已经是第三次有人问这个问题了。好吧，虽然确实可以在 TAP 设备上写一个 TAP 模拟器，给发送出去的数据包添加第二层网络头，并去掉收到的数据包中的第二层网络头，但是这个 TAP 模拟器可能还需要实现 ARP 甚至 DHCP 客户端功能。我目前不知道有谁在做这方面的工作。如果你想开展这方面的编码工作的话，请联系我。 + 常见问题 + 复制日志条目 + 若要复制单条日志请在相应条目上轻按即可。若要复制/发送全部日志请使用发送日志功能。如果该功能在界面中没有显示，请使用设备原生的菜单按钮。 + 启动快捷方式 + 您可以在主屏幕上放置一个 OpenVPN 的快捷方式。这取决于您的主屏幕管理程序，可能是快捷方式，也可能是一个小挂件。 + 很遗憾，您目前的系统不支持 VPN 服务接口 + 加密 + 输入加密方法 + 请输入 OpenVPN 使用的加密算法。留空为默认。 + 输入 OpenVPN 使用的认证摘要。留空则使用默认的摘要。 + 认证/加密 + 文件浏览器 + 内联文件 + 导入文件出错 + 无法导入文件系统文件 + [[内联文件数据]] + 无 IP 信息，拒绝打开 tun 设备 + 从 ovpn 文件中导入配置文件 + 导入 + 无法读取要导入的配置文件 + 读取配置文件发生出错 + 添加配置文件 + 无法找到导入配置文件参考的文件： %1$s + 从 %1$s 中导入配置文件 + 您的配置中有几个选项无法解析。这些选项是您自定义添加的。如下所示： + 读取配置文件完成 + 不关联到本地地址和端口 + 无本地绑定 + 导入配置文件 + 安全注意 + “OpenVPN 是非常注重安全的，所以在此提供一些安全方面的建议。所有保存在存储卡上的数据都是不安全的，任何应用都可以读取存储卡上的文件，即使这个应用没有‘写入存储卡’的权限也是如此。应用自身的数据只能被应用自己读取。在选择 CA 证书、证书文件或者密钥文件的时候请使用导入功能，这样这些数据就会保存在 OpenVPN 自身的数据文件中，保证不会被其他的应用恶意读取。当然导入证书之后记得要把证书从存储卡上删除掉。不过，虽然这些数据不能被其他应用读取，但是这些数据是明文保存的，如果你的系统是 rooted 的，那么这些数据将能够被任何拥有 root 权限的应用轻松地读取。保存在 OpenVPN 中的密码也是以明文保存的，如果设备被 rooted 了，这些密码也有可能被其他应用恶意读取。强烈建议使用 pkcs12 证书并将证书导入到 Android 自己的证书管理系统里。” + 导入 + 显示证书发生错误 + 尝试显示 Android 4.0 + 证书选择对话框时出现异常。Android 4.0 以上的系统不可能出现该问题，因为这是标准的系统功能。可能您当前 ROM 中的证书存储已经损坏。 + IPv4 + IPv6 + 等待状态消息 + 已导入配置文件 + 已导入配置文件 %d + 图像已损坏 + <p>HTC 的官方固件存在问题，它无法将网络流量转发到隧道接口上（参见（英文网页）： <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=18\">Issue 18</a> ）</p><p>SONY 的 Xperia arc S 机型和 Xperia Ray 机型的固件上没有包含完整的 Android VPN 服务，其他 Sony 手机的固件可能也存在此问题。（参见（英文网页）： <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=29\">Issue 29</a>）</p><p>在一些民间爱好者制作的固件上，可能缺少 /dev/tun 设备，或者 /dev/tun 的权限不正确。一些 CM9 固件需要设置 /dev/tun 的文件属主。.</p><p>重点是，如果你的固件存在问题，请向厂商或者固件制作者报告，如果报告问题的人足够多，就能引起厂商或者固件制作者的注意，他们就会去修复这些问题。</p> + PKCS12 文件加密密钥 + 私钥密码 + 密码 + 文件图标 + TLS 认证 + 已生成的配置 + 设置 + 尝试设定 /dev/tun 的属主为 system。一些 CM9 ROM 需要它以使 VPNService API 工作。本操作需要 root 权限。 + 修复 /dev/tun 的权限 + 显示已生成的 OpenVPN 配置文件 + 编辑 %s + 正在生成配置 + 启用该选项以在网络变化(例如从蜂窝数据到 WiFi)时强制重新连接 + 当转换网络时重新连接 + 网络状态： %s + Android 密钥库通常会自带 CA 证书。如果您获取的证书发生验证错误，请单独指定一个证书。 + 选择 + 在 Android 密钥库中未找到任何 CA 证书。可能验证失败。 + 连接时显示日志窗口。日志窗口可始终从通知栏访问。 + 显示日志窗口 + 运行 %1$s （ %2$s ） %3$s ，Android API %4$d + 与 Android 密钥库 %1$s 签名时出错： %2$s + VPN 连接警告会告诉你有程序正要拦截所有的网络流量，这是为了确保 VPN 服务的 API 不被恶意应用滥用。\nVPN 连接通知（通知栏上的钥匙图标）是 Android 系统内建的，如果当前有 VPN 连接，Android 系统就会自动显示这个通知图标。一些系统上还会在 VPN 连接建立的时候发出提示音。Android 这么做的原因是为了保护你不受恶意应用的欺骗。 + 连接警告和通知声音 + 中文翻译：Christopher Meng +<trans@cicku.me> + IP 和 DNS 设置 + 基本 + 路由设置 + 其他 OpenVPN 设置，一般不需要修改。 + 高级设置 + ICS Openvpn 配置 + 没有正在使用的 DNS 服务器。域名解析可能无法工作。请考虑设置自定义 DNS 服务器 + 无法添加 DNS 服务器 \"%1$s\"，%2$s 拒绝了您的操作。 + <p>获取你的 VPN 配置文件，可以是在电脑上正在使用的 OpenVPN 客户端配置文件，也可以向你的 VPN 服务商索取配置文件。</p><p>如果配置文件只有一个，可以把配置文件发到你自己的邮箱然后从手机上下载。如果配置文件有很多个，可以将它们复制到存储卡内。</p><p>从邮件中下载附件，或者在 VPN 列表中点击文件夹图标来导入配置文件。</p><p>如果提示找不到文件，那就将缺失的文件复制到存储卡内。</p><p>点击保存，将配置文件保存到你的 VPN 列表中。</p><p>在 VPN 列表中点击 VPN 的连接的名字，就可以连接到 VPN 了。</p><p>如果发生错误，可以看日志窗口中的日志，然后设法解决问题。</p> + 快速入门 + 尝试在连接之前加载 tun.ko 内核模块。需要 root 权限。 + 载入 tun 模块 + 将 PKCS12 导入 Android 密钥库 + 获取代理设置时出错：%s + 使用代理 %1$s %2$d + 使用系统代理 + 使用系统设置连接 HTTP/HTTPS 代理服务器。 + 您可以 <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\"> 通过 PayPal 捐助</a> + OpenVPN 将会在重启后自动重新连接 VPN。请在启用该选项前先阅读连接警告的常见问题解答。 + 重启时重新连接 + 忽略 + 重启 + 配置的变更将在重启 VPN 后生效，是否立即重启？ + 配置已更改 + 无法判断最后一次连接使用的是哪个配置文件，所以无法编辑配置文件 + 重复的通知 + 当 Android 系统的内存（RAM）即将耗尽的时候，不再需要的应用和服务将被关闭以腾出内存空间，这项机制也会影响到 VPN 进程。为了保证 OpenVPN 及其连接不被关闭，OpenVPN 服务会以较高的优先级运行，而为了以较高的优先级运行，OpenVPN 必须在状态栏显示一个图标。正如前面的问题中说过的，系统的“钥匙”图标是系统内建的，仅仅显示这个“钥匙”图标并不能让 OpenVPN 以更高的优先级运行。 + 没有定义 VPN 配置文件 + 点击 <img src=\"ic_menu_add\"/> 图标添加新的 VPN 配置 + 使用 <img src=\"ic_menu_archive\"/> 图标导入存储卡中已有的配置文件(.ovpn 或 .conf)。 + 请确保阅读常见问题解答。这是一个快速向导。 + 路由/接口配置 + 路由表不是使用传统的 ifconfig 或 route 命令来设置的，而是通过 Android 的 VPN 服务的接口来进行设置的，所以路由的设置方法和在其他系统上的有些不同。设置中只需要包含通过隧道设备的 IP 地址以及网络，节点 IP 地址以及网关地址都不需要，指定通往 VPN 服务器的路由信息也不需要。OpenVPN for Android 会忽略配置文件中的这些设置。Android 的 VPN 服务接口保证了通往 VPN 服务器的流量不会被转发到隧道设备上。VPN 支持将通往特定网络的流量转发到隧道上，但不支持不要将通往指定网络的流量转发到隧道接口上（例：route x.x.x.x y.y.y.y net_gateway）。在日志窗口中的“显示连接信息”菜单内可以查看到当前由 Android 的 VPN 服务提供的网络配置信息。 + 当 OpenVPN 重连时，也一直使用 VPN 连接。 + 保持 tun 通道 + OpenVPN 日志 + 导入 OpenVPN 配置文件 + 电池消耗 + 在我的测试中，发现最能消耗电量的是 OpenVPN 的 keepalive 包。大多数 OpenVPN 服务器都在配置文件中使用了“keepalive 10 60”这样的选项，这会导致 OpenVPN 服务器和客户端每隔 10 秒就相互向对方发送一个数据包。<p>虽然这些包很小，几乎不会消耗多少流量，但是频繁地发送这些包会导致手机的无线模块长时间处于活跃状态，并消耗大量的电能。（请参见（英文网页）： <a href=\"http://developer.android.com/training/efficient-downloads/efficient-network-access.html#RadioStateMachine\">）<p> keepalive 选项无法在客户端进行修改，只能在服务器上进行修改。<p>令人郁闷的是，如果发送 keepalive 的频率小于 60 秒，某些 NAT 网关可能会关闭 UDP 连接（我测试得到的结果是 60 秒）。使用 TCP 模式虽然可以将 keepalive 的频率设成很大，但是会造成 TCP over TCP 问题。（请参见（英文网页）：<a href=\"http://sites.inka.de/bigred/devel/tcp-tcp.html\">）（TCP over TCP 问题指的是由于 TCP 协议的机制，在 TCP 协议上再次封装一个 TCP 协议时，如果上层 TCP 链路的速度比下层 TCP 协议的链路速度快，就会造成大量 TCP 重传，从而导致网络拥塞，对用户来说就是网络变成龟速 ——译者注） + Android 网络分享和便携式热点功能(通过 WiFi, USB 或蓝牙)无法与本程序所使用的 VPN 服务接口一同工作。详情请见 <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\">issue #34</a> + VPN 和中继 + 连接重试次数 + 重新连接设置 + 每次尝试连接等待时间(秒)。 + 两次连接间隔时间(秒) + OpenVPN 意外崩溃。建议您使用主菜单中的发送转储文件功能向开发者发送转储文件 + 向开发者发送转储信息 + 向开发人员发送上次崩溃的调试信息 + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + 连接中 + 等待服务器响应 + 验证中 + 正在获取客户端配置 + 正在分配 IP 地址 + 添加路由 + 已连接 + 断开 + 正在重新连接 + 正在退出 + 未运行 + 正在解析主机名 + 连接中(TCP) + 验证失败 + 等待可用网络 + ↓%2$s/s %1$s - ↑%4$s/s %3$s + 未连接 + 正在连接 VPN %s + 正在连接 VPN %s + 某些版本的 Android 4.1 存在问题，如果密钥库证书的名称包含非字母和数字字符(如空格、 下划线或短划线)。请尝试重新导入不包含特殊字符的证书 + 加密算法(cipher) + 数据包验证 + 数据包验证方式 + 当前运行环境 %1$s (%2$s) %3$s，Android API %4$d，版本 %5$s，%6$s + 由 %s 构建 + 调试版本 + 正式版本 + 复制进配置文件 + 故障转储 + 添加 + 发送配置文件 + 完整的 DN + 您导入的配置包含不再使用的 tls-remote 选项，该选项使用了不同的 DN 格式。 + RDN （通用名称） + RDN 前缀 + tls-remote（不再使用） + 你可以通过访问 http://crowdin.net/project/ics-openvpn/invite 来帮助翻译 + %1$s 正在试图控制 %2$s + 如果继续，你将允许该应用完全控制 OpenVPN for Android，并拦截所有网络流量。除非你信任该应用，否则请不要继续。如果该应用是恶意应用，你需要自行承担所有的后果。 + 我信任此应用。 + 没有允许使用外部 API 的应用 + 已授权的应用：%s + 清除已授权的应用列表？\n当前已授权的应用：\n\n%s + diff --git a/ics-openvpn-stripped/main/src/main/res/values-zh-rTW/strings.xml b/ics-openvpn-stripped/main/src/main/res/values-zh-rTW/strings.xml new file mode 100755 index 00000000..75f72ecb --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-zh-rTW/strings.xml @@ -0,0 +1,172 @@ + + + + OpenVPN for Android + 伺服器地址: + 伺服器端口: + 位置 + 目法讀取檔案目錄 + 選擇 + 取消 + 沒有資料 + LZO壓縮 + 沒有證書 + 客戶端證書 + 客戶端證書密碼 + PKCS12 檔案 + CA證書 + 您必須選擇一個憑證 + 取得原始碼與個案追蹤，可上 http://code.google.com/p/ics-openvpn/ + 本程序使用了以下元件，其作者和授權資訊如下 + 關於 + 類型 + PKCS12 密碼 + 選擇… + 你必須選擇一個檔案 + 使用傳輸層防火牆(TLS-Auth) + TLS方向 + 以CIDR格式輸入IPv6地址/遮罩(例如 2000:dd::23/64) + 以CIDR格式輸入IPv4地址/遮罩(例如 1.2.3.4/24) + IPv4地址 + IPv6地址 + 使用自訂的OpenVPN選項，請加倍緊慎。請注意因Android API限制，很多與Tun相關的OpenVPN設定皆無法正常使用。如果你認為我們遺忘了重要的OpenVPN選項，請向作者反映。 + 用戶名稱 + 密碼 + 設定VPN + 新增設定檔 + 輸入新的設定檔名稱 + 重複的設定檔名稱 + 設定檔名稱 + 你必須選取一個使用者證書 + 未有找到錯誤 + 設定中含有錯誤 + 解析IPv4地址時發生錯誤 + 解析自訂路由時發生錯誤 + OpenVPN捷徑 + 連接到VPN + 在快捷方式找不到指定的設定檔 + 隨機主機名稱字首 + 在主機名稱前加入6個隨機字符 + 啟用自訂選項 + 自訂選項，使用時請小心！ + 路由被Android拒絕 + 斷線 + 清除記錄檔 + 確認取消 + 移除VPN + 檢查對方出示的是否TLS伺服器憑證 + 預期對方出示TLS伺服器憑證 + 啟用傳輸層防火牆(TLS-Auth) + TLS驗證檔 + 向伺服器請求IP地址, 路由和時間資訊 + 接受設定推送(Pull) + DNS + 忽略伺服器提供的DNS設定 + 使用自訂的DNS伺服器 + 搜索網域 + 要使用的DNS伺服器。 + DNS伺服器 + 當主要DNS伺服器無法使用，就會嘗試備用DNS伺服器 + 後備VPN伺服器 + 忽略伺服器推送的路由 + 忽略從伺服器推送的路由。 + 重定向所有流量到VPN + 使用VPN作為預設閘道 + 以CIDR格式輸入目的地路由，例如\"10.0.0.0/8 2002::/16\"，以上兩個路由將導向到VPN。 + 自訂路由 + 記錄的詳細級別 + 只要能夠經過驗證，接受從任何IP地址而來的伺服器訊息 + 容許浮動的伺服器 + 自訂選項 + 編輯VPN設定 + 要移除VPN設定檔 %s 嗎? + 一些自訂的Android4.0 ROM存在/dev/tun的擁有者權限問題，甚至完全沒有Tun模組。CM9用家請嘗試於\"全域設置\"下修正Tun擁有者。 + 無法開啟Tun網絡介面 + "錯誤: " + 清除 + 本地IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + %1$s %2$s + 分享記錄檔 + 分享 + ICS OpenVPN 記錄檔 + 已將記錄複製到剪貼簿 + Tap模式 + Android內置的VPN API並不支援Tap介面，故此本程序並不支援Tap模式。 + FAQ + 複製記錄檔條目 + 以快捷方式啟動 + 你的Android ROM不支援VPN服務API，抱歉了。 :( + 加密 + 輸入加密方法 + 驗證/加密 + 檔案瀏覽器 + 內嵌檔案 + 匯入過程中發生錯誤 + 無法從檔案系統中匯入檔案 + <內嵌於設定檔> + 匯入.ovpn檔案 + 匯入 + 匯入過程中無法讀取設定檔 + 讀取設定檔時發生錯誤 + 新增設定檔 + 成功讀取設定檔 + 不要綁定本地地址和端口 + 沒有本地綁定 + 匯入設定檔 + 保安上的考慮 + 匯入 + IPv4 + IPv6 + 等待狀態訊息… + PKCS12檔加密金鑰 + 私密金鑰密碼 + 密碼 + 檔案圖標 + 傳輸層防火牆(TLS Firewall) + 生成的設定檔 + 嘗試修正/dev/tun擁有者權限。已知有些CM9 ROM需要透過這個來才能使得VPN服務API得以運作。本功能需要Root。 + 修正 /dev/tun 的擁有者 + 顯示本程序生成的設定檔 + 正在編輯\"%s\" + 正在生成設定檔… + 當網絡狀況變更時強制重新連接(例如從WiFi變成手機網絡，反之亦然) + 網絡異動時重新連接 + 網絡狀態: %s + 選擇 + 顯示記錄視窗 + 於 %1$s (%2$s) %3$s 上運行, Android API 版本: %4$d + 連線警告和通知時發出音效 + 繁體中文 由 羊羊@自由網絡研究中心 <sora8964@gmail.com> 翻譯 + IP和DNS + 基本 + 路由 + 鮮為人知的OpenVPN設定，一般情況下不需要派上用場。 + 進階 + ICS Openvpn 設定 + 沒有任何DNS伺服器可用，可能無法進行網域名稱解析。請考慮設置自訂的DNS伺服器 + 快速入門 + 在連線前嘗試載入Tun模組，需要Root。 + 載入Tun模組 + 取得代理伺服器資訊時發生錯誤: %s + 使用代理伺服器 %1$s %2$d + 使用系統代理 + 使用系統配置的 HTTP/HTTPS 代理伺服器進行連接。 + 你可以透過 <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">PayPal</a> 提供捐助 + 如果在重新開機或關機前正連接VPN，開機時自動重新連接。在使用這個選項之前請先閱讀連線警告FAQ。 + 開機時重新連接 + 忽略 + 重置 + 配置變更只會在重新啟動VPN時才生效，現在要(重新)啟動VPN嗎？ + 設定已變更 + 重複的通知 + 路由/網絡介面 設定 + OpenVPN 運作記錄 + 匯入 OpenVPN 配置 + 電池消耗 + VPN與可攜式無線基地台 + 連線重試次數 + 嘗試重新連線之間的等待秒數 + 重新連接間隔時間 + OpenVPN非預期地崩潰，你或者會考慮在主選單下傳送Minidump給開發人員。 + 向開發人員傳送Minidump + diff --git a/ics-openvpn-stripped/main/src/main/res/values/strings.xml b/ics-openvpn-stripped/main/src/main/res/values/strings.xml new file mode 100755 index 00000000..6cd45b66 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values/strings.xml @@ -0,0 +1,321 @@ + + + + OpenVPN for Android + Server Address: + Server Port: + Location + Unable to read directory + Select + Cancel + No Data + LZO Compression + No Certificate + Client Certificate + Client Certificate Key + PKCS12 File + CA Certificate + You must select a certificate + Source code and issue tracker available at http://code.google.com/p/ics-openvpn/ + This program uses the following components; see the source code for full details on the licenses + About + Profiles + Type + PKCS12 Password + Select… + You must select a file + Use TLS Authentication + TLS Direction + Enter IPv6 Address/Netmask in CIDR Format (e.g. 2000:dd::23/64) + Enter IPv4 Address/Netmask in CIDR Format (e.g. 1.2.3.4/24) + IPv4 Address + IPv6 Address + Enter custom OpenVPN options. Use with caution. Also note that many of the tun related OpenVPN settings cannot be supported by design of the VPNSettings. If you think an important option is missing contact the author + Username + Password + For the static configuration the TLS Auth Keys will be used as static keys + Configure the VPN + Add Profile + Enter a name identifying the new Profile + Please enter a unique Profile Name + Profile Name + You must select a User certificate + No error found + Error in Configuration + Error parsing the IPv4 address + Error parsing the custom routes + (leave empty to query on demand) + OpenVPN Shortcut + Connect to VPN + Profile specified in shortcut not found + Random Host Prefix + Adds 6 random chars in front of hostname + Enable Custom Options + Specify custom options. Use with care! + Route rejected by Android + Disconnect + Disconnect VPN + clear log + Cancel Confirmation + Disconnect the connected VPN/cancel the connection attempt? + Remove VPN + Checks whether the server uses a certificate with TLS Server extensions (--remote-cert-tls server) + Expect TLS server certificate + Checks the Remote Server Certificate Subject DN + Certificate Hostname Check + Specify the check used to verify the remote certificate DN (e.g. C=DE, L=Paderborn, OU=Avian IP Carriers, CN=openvpn.blinkt.de)\n\nSpecify the complete DN or the RDN (openvpn.blinkt.de in the example) or an RDN prefix for verification.\n\nWhen using RDN prefix \"Server\" matches \"Server-1\" and \"Server-2\"\n\nLeaving the text field empty will check the RDN against the server hostname.\n\nFor more details see the OpenVPN 2.3.1+ manpage under —verify-x509-name + Remote certificate subject + Enables the TLS Key Authentication + TLS Auth File + Requests IP addresses, routes and timing options from the server. + No information is requested from the server. Settings need to be specified below. + Pull Settings + DNS + Override DNS Settings by Server + Use your own DNS Servers + searchDomain + DNS Server to be used. + DNS Server + Secondary DNS Server used if the normal DNS Server cannot be reached. + Backup DNS Server + Ignore pushed routes + Ignore routed pushed by the server. + Redirects all Traffic over the VPN + Use default Route + Enter custom routes. Only enter destination in CIDR format. \"10.0.0.0/8 2002::/16\" would direct the networks 10.0.0.0/8 and 2002::/16 over the VPN. + Routes that should NOT be routed over the VPN. Use the same syntax as for included routes. + Custom Routes + Excluded Networks + Log verbosity level + Allows authenticated packets from any IP + Allow floating server + Custom Options + Edit VPN Settings + Remove the VPN Profile \'%s\'? + On some custom ICS images the permission on /dev/tun might be wrong, or the tun module might be missing completely. For CM9 images try the fix ownership option under general settings + Failed to open the tun interface + "Error: " + Clear + Opening tun interface: + Local IPv4: %1$s/%2$d IPv6: %3$s MTU: %4$d + DNS Server: %1$s, Domain: %2$s + Routes: %1$s %2$s + Routes excluded: %1$s %2$s + VpnService routes installed: %1$s %2$s + Got interface information %1$s and %2$s, assuming second address is peer address of remote. Using /32 netmask for local IP. Mode given by OpenVPN is \"%3$s\". + Cannot make sense of %1$s and %2$s as IP route with CIDR netmask, using /32 as netmask. + Corrected route %1$s/%2$s to %3$s/%2$s + Cannot access the Android Keychain Certificates. This can be caused by a firmware upgrade or by restoring a backup of the app/app settings. Please edit the VPN and reselect the certificate under basic settings to recreate the permission to access the certificate. + %1$s %2$s + Send log file + Send + ICS OpenVPN log file + Copied log entry to clip board + Tap Mode + Tap Mode is not possible with the non root VPN API. Therefore this application cannot provide tap support + Again? Are you kidding? No, tap mode is really not supported and sending more mail asking if it will be supported will not help. + A third time? Actually, one could write a a tap emulator based on tun that would add layer2 information on send and strip layer2 information on receive. But this tap emulator would also have to implement ARP and possibly a DHCP client. I am not aware of anybody doing any work in this direction. Contact me if you want to start coding on this. + FAQ + Copying log entries + To copy a single log entry press and hold on the log entry. To copy/send the whole log use the Send Log option. Use the hardware menu button if not visible in the GUI. + Shortcut to start + You can place a shortcut to start OpenVPN on your desktop. Depending on your homescreen program you will have to add either a shortcut or a widget. + Your image does not support the VPNService API, sorry :( + Encryption + Enter encryption method + Enter the encryption cipher algorithm used by OpenVPN. Leave empty to use default cipher. + Enter the authentication digest used for OpenVPN. Leave empty to use default digest. + Authentication/Encryption + File Explorer + Inline File + Error importing File + Could not import File from filesystem + [[Inline file data]] + Refusing to open tun device without IP information + Import Profile from ovpn file + Import + Could not read Profile to import + Error reading config file + add Profile + Could not find file %1$s mentioned in the imported config file + Importing config file from source %1$s + Your configuration had a few configuration options that are not mapped to UI configurations. These options were added as custom configuration options. The custom configuration is displayed below: + Done reading config file. + Do not bind to local address and port + No local binding + Import configuration file + Security considerations + "As OpenVPN is security sensitive a few notes about security are sensible. All data on the sdcard is inherently insecure. Every app can read it (for example this program requires no special sd card rights). The data of this application can only be read by the application itself. By using the import option for cacert/cert/key in the file dialog the data is stored in the VPN profile. The VPN profiles are only accessible by this application. (Do not forget to delete the copies on the sd card afterwards). Even though accessible only by this application the data is still unencrypted. By rooting the telephone or other exploits it may be possible to retrieve the data. Saved passwords are stored in plain text as well. For pkcs12 files it is highly recommended that you import them into the android keystore." + Import + Error showing certificate selection + Got an exception trying to show the Android 4.0+ certificate selection dialog. This should never happen as this a standard feature of Android 4.0+. Maybe your Android ROM support for certificate storage is broken + IPv4 + IPv6 + Waiting for state message… + imported profile + imported profile %d + Broken Images + <p>Official HTC images are known to have a strange routing problem causing traffic not to flow through the tunnel (See also <a href="http://code.google.com/p/ics-openvpn/issues/detail?id=18">Issue 18</a> in the bug tracker.)</p><p>Older official SONY images from Xperia Arc S and Xperia Ray have been reported to be missing the VPNService completely from the image. (See also <a href="http://code.google.com/p/ics-openvpn/issues/detail?id=29">Issue 29</a> in the bug tracker.)</p><p>On custom build images the tun module might be missing or the rights of /dev/tun might be wrong. Some CM9 images need the "Fix ownership" option under "Device specific hacks" enabled.</p><p>Most importantly: If your device has a broken Android image, report it to your vendor. The more people who report an issue to the vendor, the more likely they are to fix it.</p> + PKCS12 File Encryption Key + Private Key Password + Password + file icon + TLS Authentication + Generated Config + Settings + Tries to set the owner of /dev/tun to system. Some CM9 images need this to make the VPNService API work. Requires root. + Fix ownership of /dev/tun + Shows the generated OpenVPN Configuration File + Editing \"%s\" + Building configuration… + Turning this option on will force a reconnect if the network state is changed (e.g. WiFi to/from mobile) + Reconnect on network change + Network Status: %s + The CA cert is usually returned from the Android Keystore. Specify a separate certificate if you get certificate verification errors. + Select + No CA Certificate returned while reading from Android keystore. Auhtentication will probably fail. + Shows the log window on connect. The log window can always be accessed from the notification status. + Show log window + Running on %1$s (%2$s) %3$s, Android API %4$d + Error signing with Android keystore key %1$s: %2$s + The VPN connection warning telling you that this app can intercept all traffic is imposed by the system to prevent abuse of the VPNService API.\nThe VPN connection notification (The key symbol) is also imposed by the Android system to signal an ongoing VPN connection. On some images this notification plays a sound.\nAndroid introduced these system dialogs for your own safety and made sure that they cannot be circumenvented. (On some images this unfortunely includes a notifciation sound) + Connection warning and notification sound + English translation by Arne Schwabe<arne@rfc2549.org> + IP and DNS + Basic + Routing + Obscure OpenVPN Settings. Normally not needed. + Advanced + ICS Openvpn Config + No DNS servers being used. Name resolution may not work. Consider setting custom DNS Servers. Please also note that Android will keep using your proxy settings specified for your mobile/Wi-Fi connection when no DNS servers are set. + Could not add DNS Server \"%1$s\", rejected by the system: %2$s + Could not configure IP Address \"%1$s\", rejected by the system: %2$s + <p>Get a working config (tested on your computer or download from your provider/organisation)</p><p>If it is a single file no with no extra pem/pks12 files you can email the file yourself and open the attachment. If you have multiple files put them on your sd card.</p><p>Click on the email attachment/Use the folder icon in the vpn list to import the config file</p><p>If there are errors about missing files put the missing files on your sd card.</p><p>Click on the save symbol to add the imported VPN to your VPN list</p><p>Connect the VPN by clicking on the name of the VPN</p><p>If there are error or warnings in the log try to understand the warnings/error and try to fix them</p> + Quick Start + Try to load the tun.ko kernel module before trying to connect. Needs rooted devices. + Load tun module + Import PKCS12 from configuration into Android Keystore + Error getting proxy settings: %s + Using proxy %1$s %2$d + Use system proxy + Use the system wide configuration for HTTP/HTTPS proxies to connect. + You can <a href=\"https://www.paypal.com/cgi-bin/webscr?hosted_button_id=R2M6ZP9AF25LS&amp;cmd=_s-xclick\">donate with PayPal</a> + OpenVPN will reconnect a VPN if it was active on system reboot/shutdown. Please read the Connection warning FAQ before using this option. + Reconnect on reboot + Ignore + Restart + Configuration changes are applied after restarting the VPN. (Re)start the VPN now? + Configuration changed + Could not determine last connected profile for editing + Duplicate notifications + If Android is under system memory (RAM) pressure, apps and service which are not needed at the moment are removed from active memory. This terminates an ongoing VPN connection. To ensure that the connection/OpenVPN survives the service runs with higher priority. To run with higher priority the application must display a notification. The key notification icon is imposed by the system as described in the previous FAQ entry. It does not count as app notification for purpose of running with higher priority. + No VPN profiles defined. + Use the <img src=\"ic_menu_add\"/> icon to add a new VPN + Use the <img src=\"ic_menu_archive\"/> icon to import an existing (.ovpn or .conf) profile from your sdcard. + Be sure to also check out the FAQ. There is a quick start guide. + Routing/Interface Configuration + The Routing and interface configuration is not done via traditional ifconfig/route commands but by using the VPNService API. This results in a different routing configuration than on other OSes. The configuration for the VPN tunnel consists of the IP address and the networks that should be routed over this interface. Especially no peer partner address or gateway address is needed. Special routes to reach the VPN Server (for example added when using redirect-gateway) are not needed either. The application will consequently ignore these settings when importing a configuration. The app ensures with the VPNService API that the connection to the server is not routed through the VPN tunnel. Only specifying networks to be routed via tunnel is supported. The app tries to detect networks that should not be routed over tunnel (e.g. route x.x.x.x y.y.y.y net_gateway) and calculates a route set that excludes this routes to emulate the behaviour of other platforms. The log windows shows the configuration of the VPNService upon establishing a connection. + Do not fallback to no VPN connection when OpenVPN is reconnecting. + Persistent tun + OpenVPN Log + Import OpenVPN configuration + Battery consumption + In my personal tests the main reason for high battery consumption of OpenVPN are the keepalive packets. Most OpenVPN servers have a configuration directive like \'keepalive 10 60\' which causes the client and server to exchange keepalive packets every ten seconds. <p> While these packets are small and do not use much traffic, they keep the mobile radio network busy and increase the energy consumption. (See also <a href="http://developer.android.com/training/efficient-downloads/efficient-network-access.html#RadioStateMachine">The Radio State Machine | Android Developers</a>) <p> This keepalive setting cannot be changed on the client. Only the system administrator of the OpenVPN can change the setting. <p> Unfortunately using a keepalive larger than 60 seconds with UDP can cause some NAT gateways to drop the connection due to an inactivity timeout. Using TCP with a long keep alive timeout works, but tunneling TCP over TCP performs extremely poorly on connections with high packet loss. (See <a href="http://sites.inka.de/bigred/devel/tcp-tcp.html">Why TCP Over TCP Is A Bad Idea</a>) + The Android Tethering feature (over WiFi, USB or Bluetooth) and the VPNService API (used by this program) do not work together. For more details see the <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=34\">issue #34</a> + VPN and Tethering + Connection retries + Reconnection settings + Number of seconds to wait between connection attempts. + Seconds between connections + OpenVPN crashed unexpectedly. Please consider using the send Minidump option in the main menu + Send Minidump to developer + Sends debugging information about last crash to developer + OpenVPN - %s + %1$s - %2$s + %1$s - %3$s, %2$s + Connecting + Waiting for server reply + Authenticating + Getting client configuration + Assigning IP addresses + Adding routes + Connected + Disconnect + Reconnecting + Exiting + Not running + Resolving host names + Connecting (TCP) + Authentication failed + Waiting for usable network + ↓%2$s/s %1$s - ↑%4$s/s %3$s + Not connected + Connecting to VPN %s + Connecting to VPN %s + Some versions of Android 4.1 have problems if the name of the keystore certificate contains non alphanumeric characters (like spaces, underscores or dashes). Try to reimport the certificate without special characters + Encryption cipher + Packets authentication + Enter packet authentication method + Running on %1$s (%2$s) %3$s, Android API %4$d, version %5$s, %6$s + built by %s + debug build + official build + Copy into profile + Crashdump + Add + Send config file + Complete DN + Your imported configuration used the old DEPRECATED tls-remote option which uses a different DN format. + RDN (common name) + RDN prefix + tls-remote (DEPRECATED) + You can help translating by visiting http://crowdin.net/project/ics-openvpn/invite + %1$s attempts to control %2$s + By proceeding, you are giving the application permission to completely control OpenVPN for Android and to intercept all network traffic.Do NOT accept unless you trust the application. Otherwise, you run the risk of having your data compromised by malicious software." + I trust this application. + No app allowed to use external API + Allowed apps: %s + Clear list of allowed external apps?\nCurrent list of allowed apps:\n\n%s + "Pause VPN when screen is off and less than 64 kB transferred data in 60s. When the \"Persistent Tun\" option is enabled pausing the VPN will leave your device with NO network connectivity. Without the \"Persistent Tun\" option the device will have no VPN connection/protection. + Pause VPN connection after screen off + Pausing connection in screen off state: less than %1$s in %2$ss + Warning: Persistent tun not enabled for this VPN. Traffic will use the normal Internet connection when the screen is off. + Save Password + Pause VPN + Resume VPN + VPN pause requested by user + VPN paused - screen off + Device specifics Hacks + Cannot display certificate information + Application behaviour + VPN behaviour + Allow changes to VPN Profiles + Hardware Keystore: + Icon of app trying to use OpenVPN for Android + "Starting with Android 4.3 the VPN confirmation is guarded against \"overlaying apps\". This results in the dialog not reacting to touch input. If you have an app that uses overlays it may cause this behaviour. If you find an offending app contact the author of the app. This problem affect all VPN applications on Android 4.3 and later. See also <a href=\"http://code.google.com/p/ics-openvpn/issues/detail?id=185\">Issue 185<a> for additional details" + Vpn Confirm Dialog on Android 4.3 and later + Alternatively you can send me a donation with the Play Store: + Thanks for donating %s! + Log cleared. + Show password + KeyChain Access error: %s + Short + ISO + Timestamps + None + Upload + Download + Vpn Status + View options + Unhandled exception: %1$s\n\n%2$s + %3$s: %1$s\n\n%2$s + If you have rooted your Android device you can install the <a href=\"http://xposed.info/\">Xposed framework</a> and a the <a href=\"http://repo.xposed.info/module/de.blinkt.vpndialogxposed\">VPN Dialog confirm module</a> at your own risk" + Full licenses + Networks directly connected to the local interfaces will not be routed over the VPN. Unchecking this option will redirect all traffic indented for local networks to VPN. + Bypass VPN for local networks + Username/Password file + [Imported from: %s] + Some files could not be found. Please select the files to import the profile: + To use this app you need a VPN provider/VPN gateway supporting OpenVPN (often provided by your employer). Check out http://community.openvpn.net/ for more information on OpenVPN and how to setup your own OpenVPN server. + Import log: + diff --git a/ics-openvpn-stripped/main/src/main/res/values/untranslatable.xml b/ics-openvpn-stripped/main/src/main/res/values/untranslatable.xml new file mode 100644 index 00000000..4d2bc4d9 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values/untranslatable.xml @@ -0,0 +1,44 @@ + + + + Copyright 2012–2014 Arne Schwabe <arne@rfc2549.org> + Copyright © 2002–2010 OpenVPN Technologies, Inc. <sales@openvpn.net>\n + + "OpenVPN" is a trademark of OpenVPN Technologies, Inc.\n + openvpn.uni-paderborn.de + 1194 + File Dialog based on work by Alexander Ponomarev + Copyright © 1996 – 2011 Markus Franz Xaver Johannes Oberhumer + This product includes software developed by the OpenSSL Project for use in the OpenSSL Toolkit\n + Copyright © 1998-2008 The OpenSSL Project. All rights reserved.\n\n + This product includes cryptographic software written by Eric Young (eay@cryptsoft.com)\n + Copyright © 1995-1998 Eric Young (eay@cryptsoft.com) All rights reserved. + OpenVPN + File Dialog + LZO + OpenSSL + Unknown state + Allows another app to control OpenVPN + Bouncy Castle Crypto APIs + Copyright © 2000–2012 The Legion Of The Bouncy Castle (http://www.bouncycastle.org) + + + 0 + 1 + + + + 1 + 2 + 5 + 50 + -1 + + + + Waiting for user permission to use VPN API + Waiting for user VPN password + VPN password input dialog cancelled + VPN API permission dialog cancelled + + \ No newline at end of file diff --git a/ics-openvpn-stripped/main/src/ovpn3/java/de/blinkt/openvpn/core/OpenVPNThreadv3.java b/ics-openvpn-stripped/main/src/ovpn3/java/de/blinkt/openvpn/core/OpenVPNThreadv3.java new file mode 100644 index 00000000..6d3dce69 --- /dev/null +++ b/ics-openvpn-stripped/main/src/ovpn3/java/de/blinkt/openvpn/core/OpenVPNThreadv3.java @@ -0,0 +1,277 @@ +package de.blinkt.openvpn.core; + +import net.openvpn.ovpn3.ClientAPI_Config; +import net.openvpn.ovpn3.ClientAPI_EvalConfig; +import net.openvpn.ovpn3.ClientAPI_Event; +import net.openvpn.ovpn3.ClientAPI_ExternalPKICertRequest; +import net.openvpn.ovpn3.ClientAPI_ExternalPKISignRequest; +import net.openvpn.ovpn3.ClientAPI_LogInfo; +import net.openvpn.ovpn3.ClientAPI_OpenVPNClient; +import net.openvpn.ovpn3.ClientAPI_ProvideCreds; +import net.openvpn.ovpn3.ClientAPI_Status; +import net.openvpn.ovpn3.ClientAPI_TransportStats; + +import java.lang.Override; + +import de.blinkt.openvpn.VpnProfile; +import de.blinkt.openvpn.core.OpenVPNManagement; +import de.blinkt.openvpn.core.OpenVpnService; +import de.blinkt.openvpn.core.VpnStatus; +import android.content.Context; + +public class OpenVPNThreadv3 extends ClientAPI_OpenVPNClient implements Runnable, OpenVPNManagement { + + static { + /*System.loadLibrary("crypto"); + System.loadLibrary("ssl");*/ + System.loadLibrary("polarssl-dynamic"); + System.loadLibrary("ovpn3"); + } + + private VpnProfile mVp; + private OpenVpnService mService; + + class StatusPoller implements Runnable + { + private long mSleeptime; + + boolean mStopped=false; + + public StatusPoller(long sleeptime) { + mSleeptime=sleeptime; + } + + public void run() { + while(!mStopped) { + try { + Thread.sleep(mSleeptime); + } catch (InterruptedException e) { + } + ClientAPI_TransportStats t = transport_stats(); + long in = t.getBytesIn(); + long out = t.getBytesOut(); + VpnStatus.updateByteCount(in, out); + } + } + + public void stop() { + mStopped=true; + } + } + + @Override + public void run() { + String configstr = mVp.getConfigFile((Context)mService,true); + if(!setConfig(configstr)) + return; + setUserPW(); + VpnStatus.logInfo(copyright()); + + StatusPoller statuspoller = new StatusPoller(5000); + new Thread(statuspoller,"Status Poller").start(); + + ClientAPI_Status status = connect(); + if(status.getError()) { + VpnStatus.logError(String.format("connect() error: %s: %s",status.getStatus(),status.getMessage())); + } else { + VpnStatus.logInfo("OpenVPN3 thread finished"); + } + statuspoller.stop(); + } + + @Override + public boolean tun_builder_set_remote_address(String address, boolean ipv6) { + mService.setMtu(1500); + return true; + } + + @Override + public boolean tun_builder_set_mtu(int mtu) { + mService.setMtu(mtu); + return true; + } + @Override + public boolean tun_builder_add_dns_server(String address, boolean ipv6) { + mService.addDNS(address); + return true; + } + + @Override + public boolean tun_builder_add_route(String address, int prefix_length, + boolean ipv6) { + if (address.equals("remote_host")) + return false; + + if(ipv6) + mService.addRoutev6(address + "/" + prefix_length,"tun"); + else + mService.addRoute(new CIDRIP(address, prefix_length)); + return true; + } + + @Override + public boolean tun_builder_add_search_domain(String domain) { + mService.setDomain(domain); + return true; + } + + @Override + public int tun_builder_establish() { + return mService.openTun().detachFd(); + } + + @Override + public boolean tun_builder_set_session_name(String name) { + VpnStatus.logInfo("We should call this session" + name); + return true; + } + + + + @Override + public boolean tun_builder_add_address(String address, int prefix_length, + boolean ipv6) { + if(!ipv6) + mService.setLocalIP(new CIDRIP(address, prefix_length)); + else + mService.setLocalIPv6(address+ "/" + prefix_length); + return true; + } + + @Override + public boolean tun_builder_new() { + + return true; + } + + @Override + public boolean tun_builder_reroute_gw(String server_address, + boolean server_address_ipv6, boolean ipv4, boolean ipv6, long flags) { + // ignore + return true; + } + + @Override + public boolean tun_builder_exclude_route(String address, int prefix_length, + boolean ipv6) { + //ignore + return true; + } + + + private boolean setConfig(String vpnconfig) { + + ClientAPI_Config config = new ClientAPI_Config(); + if(mVp.getPasswordPrivateKey()!=null) + config.setPrivateKeyPassword(mVp.getPasswordPrivateKey()); + + config.setContent(vpnconfig); + config.setTunPersist(mVp.mPersistTun); + config.setGuiVersion(mVp.getVersionEnvString(mService)); + config.setExternalPkiAlias("extpki"); + + ClientAPI_EvalConfig ec = eval_config(config); + if(ec.getExternalPki()) { + VpnStatus.logError("OpenVPN seem to think as external PKI"); + } + if (ec.getError()) { + VpnStatus.logError("OpenVPN config file parse error: " + ec.getMessage()); + return false; + } else { + config.setContent(vpnconfig); + return true; + } + } + + @Override + public void external_pki_cert_request(ClientAPI_ExternalPKICertRequest certreq) { + VpnStatus.logError("EXT PKI CERT"); + String[] ks = mVp.getKeyStoreCertificates((Context) mService); + if(ks==null) { + certreq.setError(true); + certreq.setErrorText("Error in pki cert request"); + return; + } + + String supcerts = ks[0]; + /* FIXME: How to differentiate between chain and ca certs in OpenVPN 3? */ + if (ks[1]!=null) + supcerts += "\n" + ks[1]; + certreq.setSupportingChain(supcerts); + certreq.setCert(ks[2]); + certreq.setError(false); + } + + @Override + public void external_pki_sign_request(ClientAPI_ExternalPKISignRequest signreq) { + signreq.setSig(mVp.getSignedData(signreq.getData())); + } + + void setUserPW() { + if(mVp.isUserPWAuth()) { + ClientAPI_ProvideCreds creds = new ClientAPI_ProvideCreds(); + creds.setCachePassword(true); + creds.setPassword(mVp.getPasswordAuth()); + creds.setUsername(mVp.mUsername); + provide_creds(creds); + } + } + + @Override + public boolean socket_protect(int socket) { + boolean b= mService.protect(socket); + return b; + + } + + public OpenVPNThreadv3(OpenVpnService openVpnService, VpnProfile vp) { + init_process(); + mVp =vp; + mService =openVpnService; + } + + @Override + public void pause(pauseReason pauseReason) + { + pause(); + } + + @Override + public void log(ClientAPI_LogInfo arg0) { + String logmsg =arg0.getText(); + while (logmsg.endsWith("\n")) + logmsg = logmsg.substring(0, logmsg.length()-1); + + VpnStatus.logInfo(logmsg); + } + + @Override + public void event(ClientAPI_Event event) { + VpnStatus.updateStateString(event.getName(), event.getInfo()); + if(event.getError()) + VpnStatus.logError(String.format("EVENT(Error): %s: %s",event.getName(),event.getInfo())); + } + + + // When a connection is close to timeout, the core will call this + // method. If it returns false, the core will disconnect with a + // CONNECTION_TIMEOUT event. If true, the core will enter a PAUSE + // state. + + @Override + public boolean pause_on_connection_timeout() { + VpnStatus.logInfo("pause on connection timeout?! "); + return true; + } + + public boolean stopVPN() { + stop(); + return true; + } + + @Override + public void reconnect() { + reconnect(1); + } + +} diff --git a/ics-openvpn-stripped/remoteExample/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java b/ics-openvpn-stripped/remoteExample/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java new file mode 100644 index 00000000..a44891ab --- /dev/null +++ b/ics-openvpn-stripped/remoteExample/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java @@ -0,0 +1,51 @@ +package de.blinkt.openvpn.api; + +import android.os.Parcel; +import android.os.Parcelable; + +public class APIVpnProfile implements Parcelable { + + public final String mUUID; + public final String mName; + public final boolean mUserEditable; + + public APIVpnProfile(Parcel in) { + mUUID = in.readString(); + mName = in.readString(); + mUserEditable = in.readInt() != 0; + } + + public APIVpnProfile(String uuidString, String name, boolean userEditable) { + mUUID=uuidString; + mName = name; + mUserEditable=userEditable; + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeString(mUUID); + dest.writeString(mName); + if(mUserEditable) + dest.writeInt(0); + else + dest.writeInt(1); + } + + public static final Parcelable.Creator CREATOR + = new Parcelable.Creator() { + public APIVpnProfile createFromParcel(Parcel in) { + return new APIVpnProfile(in); + } + + public APIVpnProfile[] newArray(int size) { + return new APIVpnProfile[size]; + } + }; + + +} diff --git a/ics-openvpn-stripped/remoteExample/src/main/res/values/strings.xml b/ics-openvpn-stripped/remoteExample/src/main/res/values/strings.xml new file mode 100644 index 00000000..bbaee226 --- /dev/null +++ b/ics-openvpn-stripped/remoteExample/src/main/res/values/strings.xml @@ -0,0 +1,15 @@ + + + + OpenVPN Remote + Hello world! + Settings + Allows another app to control OpenVPN + No Status yet + Not now + Show my IP + Disconnect + Start embedded profile + + + diff --git a/ics-openvpn-stripped/vpndialogxposed/src/main/res/values/strings.xml b/ics-openvpn-stripped/vpndialogxposed/src/main/res/values/strings.xml new file mode 100644 index 00000000..6eace130 --- /dev/null +++ b/ics-openvpn-stripped/vpndialogxposed/src/main/res/values/strings.xml @@ -0,0 +1,8 @@ + + + + VpnDialog Xposed Module + Select the apps that should be allowed to use the VpnService API without user confirmation + No Apps using the VPNService API found + + -- cgit v1.2.3 From aba5a16a97b43f95659e0f79f76549b1fe2e9d56 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Parm=C3=A9nides=20GV?= Date: Thu, 29 May 2014 10:05:47 +0200 Subject: No AIDL nor api, logfragment related xml files api folder and aidl files aren't needed for us. They are used for external apps that want to use ics-openvpn as an already installed package, while what we want is to avoid the installation of ics-openvpn including it (refactored) in bitmask android. --- .../src/main/java/de/blinkt/openvpn/LaunchVPN.java | 19 +- .../java/de/blinkt/openvpn/api/APIVpnProfile.java | 51 ---- .../java/de/blinkt/openvpn/api/ConfirmDialog.java | 126 -------- .../de/blinkt/openvpn/api/ExternalAppDatabase.java | 57 ---- .../blinkt/openvpn/api/ExternalOpenVPNService.java | 317 --------------------- .../openvpn/api/SecurityRemoteException.java | 12 - .../main/src/main/res/layout/log_silders.xml | 61 ++++ .../main/src/main/res/layout/vpnstatus.xml | 46 +++ .../main/src/main/res/values/dimens.xml | 7 + .../main/src/main/res/values/styles.xml | 64 +++++ .../java/de/blinkt/openvpn/api/APIVpnProfile.java | 51 ---- 11 files changed, 184 insertions(+), 627 deletions(-) delete mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java delete mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ConfirmDialog.java delete mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalAppDatabase.java delete mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalOpenVPNService.java delete mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/SecurityRemoteException.java create mode 100644 ics-openvpn-stripped/main/src/main/res/layout/log_silders.xml create mode 100644 ics-openvpn-stripped/main/src/main/res/layout/vpnstatus.xml create mode 100644 ics-openvpn-stripped/main/src/main/res/values/dimens.xml create mode 100644 ics-openvpn-stripped/main/src/main/res/values/styles.xml delete mode 100644 ics-openvpn-stripped/remoteExample/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java (limited to 'ics-openvpn-stripped') diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/LaunchVPN.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/LaunchVPN.java index c563899d..eead600c 100644 --- a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/LaunchVPN.java +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/LaunchVPN.java @@ -115,19 +115,12 @@ public class LaunchVPN extends Activity { if(requestCode==START_VPN_PROFILE) { if(resultCode == Activity.RESULT_OK) { - int needpw = mSelectedProfile.needUserPWInput(); - if(needpw !=0) { - VpnStatus.updateStateString("USER_VPN_PASSWORD", "", R.string.state_user_vpn_password, - ConnectionStatus.LEVEL_WAITING_FOR_USER_INPUT); - askForPW(needpw); - } else { - SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this); - boolean showlogwindow = prefs.getBoolean("showlogwindow", true); - - if(!mhideLog && showlogwindow) - showLogWindow(); - new startOpenVpnThread().start(); - } + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this); + boolean showlogwindow = prefs.getBoolean("showlogwindow", true); + + if(!mhideLog && showlogwindow) + showLogWindow(); + new startOpenVpnThread().start(); } else if (resultCode == Activity.RESULT_CANCELED) { // User does not want us to start, so we just vanish VpnStatus.updateStateString("USER_VPN_PERMISSION_CANCELLED", "", R.string.state_user_vpn_permission_cancelled, diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java deleted file mode 100644 index a44891ab..00000000 --- a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java +++ /dev/null @@ -1,51 +0,0 @@ -package de.blinkt.openvpn.api; - -import android.os.Parcel; -import android.os.Parcelable; - -public class APIVpnProfile implements Parcelable { - - public final String mUUID; - public final String mName; - public final boolean mUserEditable; - - public APIVpnProfile(Parcel in) { - mUUID = in.readString(); - mName = in.readString(); - mUserEditable = in.readInt() != 0; - } - - public APIVpnProfile(String uuidString, String name, boolean userEditable) { - mUUID=uuidString; - mName = name; - mUserEditable=userEditable; - } - - @Override - public int describeContents() { - return 0; - } - - @Override - public void writeToParcel(Parcel dest, int flags) { - dest.writeString(mUUID); - dest.writeString(mName); - if(mUserEditable) - dest.writeInt(0); - else - dest.writeInt(1); - } - - public static final Parcelable.Creator CREATOR - = new Parcelable.Creator() { - public APIVpnProfile createFromParcel(Parcel in) { - return new APIVpnProfile(in); - } - - public APIVpnProfile[] newArray(int size) { - return new APIVpnProfile[size]; - } - }; - - -} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ConfirmDialog.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ConfirmDialog.java deleted file mode 100644 index 3856a181..00000000 --- a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ConfirmDialog.java +++ /dev/null @@ -1,126 +0,0 @@ -/* - * Copyright (C) 2011 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package de.blinkt.openvpn.api; - -import android.app.Activity; -import android.app.AlertDialog; -import android.app.AlertDialog.Builder; -import android.content.DialogInterface; -import android.content.DialogInterface.OnShowListener; -import android.content.pm.ApplicationInfo; -import android.content.pm.PackageManager; -import android.util.Log; -import android.view.View; -import android.widget.Button; -import android.widget.CompoundButton; -import android.widget.ImageView; -import android.widget.TextView; -import se.leap.bitmaskclient.R; - - -public class ConfirmDialog extends Activity implements -CompoundButton.OnCheckedChangeListener, DialogInterface.OnClickListener { - private static final String TAG = "OpenVPNVpnConfirm"; - - private String mPackage; - - private Button mButton; - - private AlertDialog mAlert; - - @Override - protected void onResume() { - super.onResume(); - try { - mPackage = getCallingPackage(); - if (mPackage==null) { - finish(); - return; - } - - - PackageManager pm = getPackageManager(); - ApplicationInfo app = pm.getApplicationInfo(mPackage, 0); - - View view = View.inflate(this, R.layout.api_confirm, null); - ((ImageView) view.findViewById(R.id.icon)).setImageDrawable(app.loadIcon(pm)); - ((TextView) view.findViewById(R.id.prompt)).setText( - getString(R.string.prompt, app.loadLabel(pm), getString(R.string.app))); - ((CompoundButton) view.findViewById(R.id.check)).setOnCheckedChangeListener(this); - - - Builder builder = new AlertDialog.Builder(this); - - builder.setView(view); - - builder.setIconAttribute(android.R.attr.alertDialogIcon); - builder.setTitle(android.R.string.dialog_alert_title); - builder.setPositiveButton(android.R.string.ok,this); - builder.setNegativeButton(android.R.string.cancel,this); - - mAlert = builder.create(); - mAlert.setCanceledOnTouchOutside(false); - - mAlert.setOnShowListener (new OnShowListener() { - - @Override - public void onShow(DialogInterface dialog) { - mButton = mAlert.getButton(DialogInterface.BUTTON_POSITIVE); - mButton.setEnabled(false); - - } - }); - - //setCloseOnTouchOutside(false); - - mAlert.show(); - - } catch (Exception e) { - Log.e(TAG, "onResume", e); - finish(); - } - } - - @Override - public void onBackPressed() { - setResult(RESULT_CANCELED); - finish(); - } - - @Override - public void onCheckedChanged(CompoundButton button, boolean checked) { - mButton.setEnabled(checked); - } - - @Override - public void onClick(DialogInterface dialog, int which) { - - if (which == DialogInterface.BUTTON_POSITIVE) { - ExternalAppDatabase extapps = new ExternalAppDatabase(this); - extapps.addApp(mPackage); - setResult(RESULT_OK); - finish(); - } - - if (which == DialogInterface.BUTTON_NEGATIVE) { - setResult(RESULT_CANCELED); - finish(); - } - } - -} - diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalAppDatabase.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalAppDatabase.java deleted file mode 100644 index 02c369b1..00000000 --- a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalAppDatabase.java +++ /dev/null @@ -1,57 +0,0 @@ -package de.blinkt.openvpn.api; - -import java.util.HashSet; -import java.util.Set; - -import android.content.Context; -import android.content.SharedPreferences; -import android.content.SharedPreferences.Editor; -import android.preference.PreferenceManager; - -public class ExternalAppDatabase { - - Context mContext; - - public ExternalAppDatabase(Context c) { - mContext =c; - } - - private final String PREFERENCES_KEY = "PREFERENCES_KEY"; - - boolean isAllowed(String packagename) { - Set allowedapps = getExtAppList(); - - return allowedapps.contains(packagename); - - } - - public Set getExtAppList() { - SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext); - return prefs.getStringSet(PREFERENCES_KEY, new HashSet()); - } - - void addApp(String packagename) - { - Set allowedapps = getExtAppList(); - allowedapps.add(packagename); - saveExtAppList(allowedapps); - } - - private void saveExtAppList( Set allowedapps) { - SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext); - Editor prefedit = prefs.edit(); - prefedit.putStringSet(PREFERENCES_KEY, allowedapps); - prefedit.apply(); - } - - public void clearAllApiApps() { - saveExtAppList(new HashSet()); - } - - public void removeApp(String packagename) { - Set allowedapps = getExtAppList(); - allowedapps.remove(packagename); - saveExtAppList(allowedapps); - } - -} diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalOpenVPNService.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalOpenVPNService.java deleted file mode 100644 index 784ec72a..00000000 --- a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/ExternalOpenVPNService.java +++ /dev/null @@ -1,317 +0,0 @@ -package de.blinkt.openvpn.api; - -import java.io.IOException; -import java.io.StringReader; -import java.lang.ref.WeakReference; -import java.util.LinkedList; -import java.util.List; - -import android.annotation.TargetApi; -import android.app.Service; -import android.content.ComponentName; -import android.content.Context; -import android.content.Intent; -import android.content.ServiceConnection; -import android.content.pm.ApplicationInfo; -import android.content.pm.PackageManager; -import android.content.pm.PackageManager.NameNotFoundException; -import android.net.VpnService; -import android.os.*; -import se.leap.bitmaskclient.R; -import de.blinkt.openvpn.VpnProfile; -import de.blinkt.openvpn.core.ConfigParser; -import de.blinkt.openvpn.core.ConfigParser.ConfigParseError; -import de.blinkt.openvpn.core.VpnStatus; -import de.blinkt.openvpn.core.VpnStatus.ConnectionStatus; -import de.blinkt.openvpn.core.VpnStatus.StateListener; -import de.blinkt.openvpn.core.OpenVpnService; -import de.blinkt.openvpn.core.OpenVpnService.LocalBinder; -import de.blinkt.openvpn.core.ProfileManager; -import de.blinkt.openvpn.core.VPNLaunchHelper; - -@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) -public class ExternalOpenVPNService extends Service implements StateListener { - - private static final int SEND_TOALL = 0; - - final RemoteCallbackList mCallbacks = - new RemoteCallbackList(); - - private OpenVpnService mService; - private ExternalAppDatabase mExtAppDb; - - - private ServiceConnection mConnection = new ServiceConnection() { - - - @Override - public void onServiceConnected(ComponentName className, - IBinder service) { - // We've bound to LocalService, cast the IBinder and get LocalService instance - LocalBinder binder = (LocalBinder) service; - mService = binder.getService(); - } - - @Override - public void onServiceDisconnected(ComponentName arg0) { - mService = null; - } - - }; - - @Override - public void onCreate() { - super.onCreate(); - VpnStatus.addStateListener(this); - mExtAppDb = new ExternalAppDatabase(this); - - Intent intent = new Intent(getBaseContext(), OpenVpnService.class); - intent.setAction(OpenVpnService.START_SERVICE); - - bindService(intent, mConnection, Context.BIND_AUTO_CREATE); - mHandler.setService(this); - } - - private final IOpenVPNAPIService.Stub mBinder = new IOpenVPNAPIService.Stub() { - - private void checkOpenVPNPermission() throws SecurityRemoteException { - PackageManager pm = getPackageManager(); - - for (String apppackage : mExtAppDb.getExtAppList()) { - ApplicationInfo app; - try { - app = pm.getApplicationInfo(apppackage, 0); - if (Binder.getCallingUid() == app.uid) { - return; - } - } catch (NameNotFoundException e) { - // App not found. Remove it from the list - mExtAppDb.removeApp(apppackage); - } - - } - throw new SecurityException("Unauthorized OpenVPN API Caller"); - } - - @Override - public List getProfiles() throws RemoteException { - checkOpenVPNPermission(); - - ProfileManager pm = ProfileManager.getInstance(getBaseContext()); - - List profiles = new LinkedList(); - - for (VpnProfile vp : pm.getProfiles()) - profiles.add(new APIVpnProfile(vp.getUUIDString(), vp.mName, vp.mUserEditable)); - - return profiles; - } - - @Override - public void startProfile(String profileUUID) throws RemoteException { - checkOpenVPNPermission(); - - Intent shortVPNIntent = new Intent(Intent.ACTION_MAIN); - shortVPNIntent.setClass(getBaseContext(), de.blinkt.openvpn.LaunchVPN.class); - shortVPNIntent.putExtra(de.blinkt.openvpn.LaunchVPN.EXTRA_KEY, profileUUID); - shortVPNIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); - startActivity(shortVPNIntent); - } - - public void startVPN(String inlineconfig) throws RemoteException { - checkOpenVPNPermission(); - - ConfigParser cp = new ConfigParser(); - try { - cp.parseConfig(new StringReader(inlineconfig)); - VpnProfile vp = cp.convertProfile(); - if (vp.checkProfile(getApplicationContext()) != R.string.no_error_found) - throw new RemoteException(getString(vp.checkProfile(getApplicationContext()))); - - - ProfileManager.setTemporaryProfile(vp); - VPNLaunchHelper.startOpenVpn(vp, getBaseContext()); - - - } catch (IOException e) { - throw new RemoteException(e.getMessage()); - } catch (ConfigParseError e) { - throw new RemoteException(e.getMessage()); - } - } - - @Override - public boolean addVPNProfile(String name, String config) throws RemoteException { - checkOpenVPNPermission(); - - ConfigParser cp = new ConfigParser(); - try { - cp.parseConfig(new StringReader(config)); - VpnProfile vp = cp.convertProfile(); - vp.mName = name; - ProfileManager pm = ProfileManager.getInstance(getBaseContext()); - pm.addProfile(vp); - } catch (IOException e) { - VpnStatus.logException(e); - return false; - } catch (ConfigParseError e) { - VpnStatus.logException(e); - return false; - } - - return true; - } - - - @Override - public Intent prepare(String packagename) { - if (new ExternalAppDatabase(ExternalOpenVPNService.this).isAllowed(packagename)) - return null; - - Intent intent = new Intent(); - intent.setClass(ExternalOpenVPNService.this, ConfirmDialog.class); - return intent; - } - - @Override - public Intent prepareVPNService() throws RemoteException { - checkOpenVPNPermission(); - - if (VpnService.prepare(ExternalOpenVPNService.this) == null) - return null; - else - return new Intent(getBaseContext(), GrantPermissionsActivity.class); - } - - - @Override - public void registerStatusCallback(IOpenVPNStatusCallback cb) - throws RemoteException { - checkOpenVPNPermission(); - - if (cb != null) { - cb.newStatus(mMostRecentState.vpnUUID, mMostRecentState.state, - mMostRecentState.logmessage, mMostRecentState.level.name()); - mCallbacks.register(cb); - } - - - } - - @Override - public void unregisterStatusCallback(IOpenVPNStatusCallback cb) - throws RemoteException { - checkOpenVPNPermission(); - - if (cb != null) - mCallbacks.unregister(cb); - } - - @Override - public void disconnect() throws RemoteException { - checkOpenVPNPermission(); - if (mService != null && mService.getManagement() != null) - mService.getManagement().stopVPN(); - } - - @Override - public void pause() throws RemoteException { - checkOpenVPNPermission(); - if (mService != null) - mService.userPause(true); - } - - @Override - public void resume() throws RemoteException { - checkOpenVPNPermission(); - if (mService != null) - mService.userPause(false); - - } - }; - - - private UpdateMessage mMostRecentState; - - @Override - public IBinder onBind(Intent intent) { - return mBinder; - } - - @Override - public void onDestroy() { - super.onDestroy(); - mCallbacks.kill(); - unbindService(mConnection); - VpnStatus.removeStateListener(this); - } - - class UpdateMessage { - public String state; - public String logmessage; - public ConnectionStatus level; - public String vpnUUID; - - public UpdateMessage(String state, String logmessage, ConnectionStatus level) { - this.state = state; - this.logmessage = logmessage; - this.level = level; - } - } - - @Override - public void updateState(String state, String logmessage, int resid, ConnectionStatus level) { - mMostRecentState = new UpdateMessage(state, logmessage, level); - if (ProfileManager.getLastConnectedVpn() != null) - mMostRecentState.vpnUUID = ProfileManager.getLastConnectedVpn().getUUIDString(); - - Message msg = mHandler.obtainMessage(SEND_TOALL, mMostRecentState); - msg.sendToTarget(); - - } - - private static final OpenVPNServiceHandler mHandler = new OpenVPNServiceHandler(); - - - static class OpenVPNServiceHandler extends Handler { - WeakReference service = null; - - private void setService(ExternalOpenVPNService eos) { - service = new WeakReference(eos); - } - - @Override - public void handleMessage(Message msg) { - - RemoteCallbackList callbacks; - switch (msg.what) { - case SEND_TOALL: - if (service == null || service.get() == null) - return; - - callbacks = service.get().mCallbacks; - - - // Broadcast to all clients the new value. - final int N = callbacks.beginBroadcast(); - for (int i = 0; i < N; i++) { - try { - sendUpdate(callbacks.getBroadcastItem(i), (UpdateMessage) msg.obj); - } catch (RemoteException e) { - // The RemoteCallbackList will take care of removing - // the dead object for us. - } - } - callbacks.finishBroadcast(); - break; - } - } - - private void sendUpdate(IOpenVPNStatusCallback broadcastItem, - UpdateMessage um) throws RemoteException { - broadcastItem.newStatus(um.vpnUUID, um.state, um.logmessage, um.level.name()); - } - } - - -} \ No newline at end of file diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/SecurityRemoteException.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/SecurityRemoteException.java deleted file mode 100644 index 08d90e3b..00000000 --- a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/api/SecurityRemoteException.java +++ /dev/null @@ -1,12 +0,0 @@ -package de.blinkt.openvpn.api; - -import android.os.RemoteException; - -public class SecurityRemoteException extends RemoteException { - - /** - * - */ - private static final long serialVersionUID = 1L; - -} diff --git a/ics-openvpn-stripped/main/src/main/res/layout/log_silders.xml b/ics-openvpn-stripped/main/src/main/res/layout/log_silders.xml new file mode 100644 index 00000000..0ecb5daa --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/layout/log_silders.xml @@ -0,0 +1,61 @@ + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/ics-openvpn-stripped/main/src/main/res/layout/vpnstatus.xml b/ics-openvpn-stripped/main/src/main/res/layout/vpnstatus.xml new file mode 100644 index 00000000..eb7c53ee --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/layout/vpnstatus.xml @@ -0,0 +1,46 @@ + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/ics-openvpn-stripped/main/src/main/res/values/dimens.xml b/ics-openvpn-stripped/main/src/main/res/values/dimens.xml new file mode 100644 index 00000000..4f325078 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values/dimens.xml @@ -0,0 +1,7 @@ + + + 20dp + 8dp + false + + \ No newline at end of file diff --git a/ics-openvpn-stripped/main/src/main/res/values/styles.xml b/ics-openvpn-stripped/main/src/main/res/values/styles.xml new file mode 100644 index 00000000..95e709b3 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values/styles.xml @@ -0,0 +1,64 @@ + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/ics-openvpn-stripped/remoteExample/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java b/ics-openvpn-stripped/remoteExample/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java deleted file mode 100644 index a44891ab..00000000 --- a/ics-openvpn-stripped/remoteExample/src/main/java/de/blinkt/openvpn/api/APIVpnProfile.java +++ /dev/null @@ -1,51 +0,0 @@ -package de.blinkt.openvpn.api; - -import android.os.Parcel; -import android.os.Parcelable; - -public class APIVpnProfile implements Parcelable { - - public final String mUUID; - public final String mName; - public final boolean mUserEditable; - - public APIVpnProfile(Parcel in) { - mUUID = in.readString(); - mName = in.readString(); - mUserEditable = in.readInt() != 0; - } - - public APIVpnProfile(String uuidString, String name, boolean userEditable) { - mUUID=uuidString; - mName = name; - mUserEditable=userEditable; - } - - @Override - public int describeContents() { - return 0; - } - - @Override - public void writeToParcel(Parcel dest, int flags) { - dest.writeString(mUUID); - dest.writeString(mName); - if(mUserEditable) - dest.writeInt(0); - else - dest.writeInt(1); - } - - public static final Parcelable.Creator CREATOR - = new Parcelable.Creator() { - public APIVpnProfile createFromParcel(Parcel in) { - return new APIVpnProfile(in); - } - - public APIVpnProfile[] newArray(int size) { - return new APIVpnProfile[size]; - } - }; - - -} -- cgit v1.2.3 From f6139feeee3a2e5d68ce2e5848723d4c0a0ffda3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Parm=C3=A9nides=20GV?= Date: Thu, 29 May 2014 10:19:57 +0200 Subject: Last ics-openvpn compilation problem fixed. Forgot to add the menu for the log. Now we'll strive to fix se.leap.bitmaskclient problems: first compilation, then functionality. --- .../main/src/main/res/menu/logmenu.xml | 38 ++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 ics-openvpn-stripped/main/src/main/res/menu/logmenu.xml (limited to 'ics-openvpn-stripped') diff --git a/ics-openvpn-stripped/main/src/main/res/menu/logmenu.xml b/ics-openvpn-stripped/main/src/main/res/menu/logmenu.xml new file mode 100644 index 00000000..04592a26 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/menu/logmenu.xml @@ -0,0 +1,38 @@ + + + + + + + + + + + + + \ No newline at end of file -- cgit v1.2.3 From e50339824809da28beabfaf9ecea7414c131cbfe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Parm=C3=A9nides=20GV?= Date: Thu, 29 May 2014 20:19:24 +0200 Subject: ics-openvpn receives ifconfig from the server. Refactored AndroidManifest to include launchvpn and openvpnservice. Imported changes from ics-openvpn-upstream --- .../main/src/main/java/de/blinkt/openvpn/VpnProfile.java | 4 ++-- .../main/src/main/java/de/blinkt/openvpn/core/ConfigParser.java | 8 ++++++++ .../main/src/main/java/de/blinkt/openvpn/core/OpenVpnService.java | 8 ++++++++ 3 files changed, 18 insertions(+), 2 deletions(-) (limited to 'ics-openvpn-stripped') diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/VpnProfile.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/VpnProfile.java index afa70100..0596684c 100644 --- a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/VpnProfile.java +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/VpnProfile.java @@ -725,8 +725,8 @@ public class VpnProfile implements Serializable { //! Return an error if somethign is wrong public int checkProfile(Context context) { if (mAuthenticationType == TYPE_KEYSTORE || mAuthenticationType == TYPE_USERPASS_KEYSTORE) { - if (mAlias == null) - return R.string.no_keystore_cert_selected; + // if (mAlias == null) + // return R.string.no_keystore_cert_selected; } if (!mUsePull || mAuthenticationType == TYPE_STATICKEYS) { diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ConfigParser.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ConfigParser.java index 378b6b92..32e5cabb 100644 --- a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ConfigParser.java +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/ConfigParser.java @@ -26,6 +26,14 @@ public class ConfigParser { private boolean extraRemotesAsCustom=false; + /* + * TODO: We shouldn't be using this method. + * We need to figure out how to use just parseConfig, probably removing parseOptions. + */ + public void setDefinition(HashMap>> args) { + options = args; + } + public void parseConfig(Reader reader) throws IOException, ConfigParseError { diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVpnService.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVpnService.java index 8281aed8..d7bb827e 100644 --- a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVpnService.java +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/core/OpenVpnService.java @@ -72,6 +72,14 @@ public class OpenVpnService extends VpnService implements StateListener, Callbac private String mLastTunCfg; private String mRemoteGW; + //TODO We should know if this is running or not without this method + public boolean isRunning() { + if (mStarting == true || mProcessThread != null) + return true; + else + return false; + } + // From: http://stackoverflow.com/questions/3758606/how-to-convert-byte-size-into-human-readable-format-in-java public static String humanReadableByteCount(long bytes, boolean mbit) { if (mbit) -- cgit v1.2.3 From ac69881af1b7bfcdd185989f3e434556b1d62fed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Parm=C3=A9nides=20GV?= Date: Tue, 10 Jun 2014 11:19:48 +0200 Subject: Grabs eip authentication data correctly. Merged updated ics-openvpn-upstream (e7803cc8efcd1794e18b4e30a43d814c2834552d). --- .../main/java/de/blinkt/openvpn/VpnProfile.java | 27 ++++++--- .../java/de/blinkt/openvpn/views/SeekBarTicks.java | 69 ++++++++++++++++++++++ .../main/src/main/res/values-sw600dp/dimens.xml | 5 ++ .../main/src/main/res/values-sw600dp/styles.xml | 6 ++ .../src/main/res/values-w820dp/dimens.xml | 6 ++ .../remoteExample/src/main/res/values/dimens.xml | 6 ++ .../remoteExample/src/main/res/values/styles.xml | 8 +++ 7 files changed, 118 insertions(+), 9 deletions(-) create mode 100644 ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/views/SeekBarTicks.java create mode 100644 ics-openvpn-stripped/main/src/main/res/values-sw600dp/dimens.xml create mode 100644 ics-openvpn-stripped/main/src/main/res/values-sw600dp/styles.xml create mode 100644 ics-openvpn-stripped/remoteExample/src/main/res/values-w820dp/dimens.xml create mode 100644 ics-openvpn-stripped/remoteExample/src/main/res/values/dimens.xml create mode 100644 ics-openvpn-stripped/remoteExample/src/main/res/values/styles.xml (limited to 'ics-openvpn-stripped') diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/VpnProfile.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/VpnProfile.java index 0596684c..bdfa51c3 100644 --- a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/VpnProfile.java +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/VpnProfile.java @@ -2,6 +2,10 @@ package de.blinkt.openvpn; import se.leap.bitmaskclient.R; +import se.leap.bitmaskclient.Dashboard; +import se.leap.bitmaskclient.EIP; +import se.leap.bitmaskclient.Provider; + import android.content.Context; import android.content.Intent; import android.content.SharedPreferences; @@ -79,7 +83,7 @@ public class VpnProfile implements Serializable { // but needs to keep wrong name to guarante loading of old // profiles public transient boolean profileDleted = false; - public int mAuthenticationType = TYPE_KEYSTORE; + public int mAuthenticationType = TYPE_CERTIFICATES; public String mName; public String mAlias; public String mClientCertFilename; @@ -254,17 +258,22 @@ public class VpnProfile implements Serializable { cfg += " tcp-client\n"; + android.util.Log.d("vpnprofile", Integer.toString(mAuthenticationType)); switch (mAuthenticationType) { case VpnProfile.TYPE_USERPASS_CERTIFICATES: cfg += "auth-user-pass\n"; case VpnProfile.TYPE_CERTIFICATES: // Ca - cfg += insertFileData("ca", mCaFilename); - - // Client Cert + Key - cfg += insertFileData("key", mClientKeyFilename); - cfg += insertFileData("cert", mClientCertFilename); - + // cfg += insertFileData("ca", mCaFilename); + + // // Client Cert + Key + // cfg += insertFileData("key", mClientKeyFilename); + // cfg += insertFileData("cert", mClientCertFilename); + // FIXME This is all we need...The whole switch statement can go... + SharedPreferences preferences = context.getSharedPreferences(Dashboard.SHARED_PREFERENCES, context.MODE_PRIVATE); + cfg+="\n"+preferences.getString(Provider.CA_CERT, "")+"\n\n"; + cfg+="\n"+preferences.getString(EIP.PRIVATE_KEY, "")+"\n\n"; + cfg+="\n"+preferences.getString(EIP.CERTIFICATE, "")+"\n\n"; break; case VpnProfile.TYPE_USERPASS_PKCS12: cfg += "auth-user-pass\n"; @@ -555,8 +564,8 @@ public class VpnProfile implements Serializable { Intent intent = new Intent(context, OpenVpnService.class); if (mAuthenticationType == VpnProfile.TYPE_KEYSTORE || mAuthenticationType == VpnProfile.TYPE_USERPASS_KEYSTORE) { - if (getKeyStoreCertificates(context) == null) - return null; + // if (getKeyStoreCertificates(context) == null) + // return null; } intent.putExtra(prefix + ".ARGV", buildOpenvpnArgv(context.getCacheDir())); diff --git a/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/views/SeekBarTicks.java b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/views/SeekBarTicks.java new file mode 100644 index 00000000..88e8e164 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/java/de/blinkt/openvpn/views/SeekBarTicks.java @@ -0,0 +1,69 @@ +package de.blinkt.openvpn.views; + +import android.content.Context; +import android.content.res.TypedArray; +import android.graphics.Canvas; +import android.graphics.Paint; +import android.graphics.drawable.Drawable; +import android.util.AttributeSet; +import android.util.TypedValue; +import android.view.ViewConfiguration; +import android.widget.SeekBar; + +public class SeekBarTicks extends SeekBar { + private Paint mTickPaint; + private float mTickHeight; + + private float tickHeightRatio = 0.6f; + + public SeekBarTicks(Context context, AttributeSet attrs) { + super (context, attrs); + + initTicks (context, attrs, android.R.attr.seekBarStyle); + } + + + public SeekBarTicks(Context context, AttributeSet attrs, int defStyle) { + super(context, attrs, defStyle); + + initTicks (context, attrs, defStyle); + + /*mTickHeight = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, + tickHeightDP, + ctx.getResources().getDisplayMetrics()); */ + } + + private void initTicks(Context context, AttributeSet attrs, int defStyle) { + TypedArray a = context.obtainStyledAttributes(attrs, + new int[] { android.R.attr.secondaryProgress }, defStyle, 0); + + + int tickColor = a.getColor(0, android.R.color.black); + mTickPaint = new Paint(); + mTickPaint.setColor( context.getResources().getColor(tickColor)); + a.recycle(); + } + + + @Override + protected synchronized void onDraw(Canvas canvas) { + drawTicks(canvas); + super.onDraw(canvas); + } + + private void drawTicks(Canvas canvas) { + + final int available = getWidth() - getPaddingLeft() - getPaddingRight(); + final int availableHeight = getHeight() - getPaddingBottom() - getPaddingTop(); + + int extrapadding = (int) ((availableHeight- (availableHeight * tickHeightRatio))/2); + + int tickSpacing = available / (getMax() ); + + for (int i = 1; i < getMax(); i++) { + final float x = getPaddingLeft() + i * tickSpacing; + + canvas.drawLine(x, getPaddingTop()+extrapadding, x, getHeight()-getPaddingBottom()-extrapadding, mTickPaint); + } + } +} diff --git a/ics-openvpn-stripped/main/src/main/res/values-sw600dp/dimens.xml b/ics-openvpn-stripped/main/src/main/res/values-sw600dp/dimens.xml new file mode 100644 index 00000000..b83bb856 --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-sw600dp/dimens.xml @@ -0,0 +1,5 @@ + + + true + + \ No newline at end of file diff --git a/ics-openvpn-stripped/main/src/main/res/values-sw600dp/styles.xml b/ics-openvpn-stripped/main/src/main/res/values-sw600dp/styles.xml new file mode 100644 index 00000000..de0bb55d --- /dev/null +++ b/ics-openvpn-stripped/main/src/main/res/values-sw600dp/styles.xml @@ -0,0 +1,6 @@ + + + + 16dp + + \ No newline at end of file diff --git a/ics-openvpn-stripped/remoteExample/src/main/res/values-w820dp/dimens.xml b/ics-openvpn-stripped/remoteExample/src/main/res/values-w820dp/dimens.xml new file mode 100644 index 00000000..63fc8164 --- /dev/null +++ b/ics-openvpn-stripped/remoteExample/src/main/res/values-w820dp/dimens.xml @@ -0,0 +1,6 @@ + + + 64dp + diff --git a/ics-openvpn-stripped/remoteExample/src/main/res/values/dimens.xml b/ics-openvpn-stripped/remoteExample/src/main/res/values/dimens.xml new file mode 100644 index 00000000..a0171a70 --- /dev/null +++ b/ics-openvpn-stripped/remoteExample/src/main/res/values/dimens.xml @@ -0,0 +1,6 @@ + + + 16dp + 16dp + + diff --git a/ics-openvpn-stripped/remoteExample/src/main/res/values/styles.xml b/ics-openvpn-stripped/remoteExample/src/main/res/values/styles.xml new file mode 100644 index 00000000..ff6c9d2c --- /dev/null +++ b/ics-openvpn-stripped/remoteExample/src/main/res/values/styles.xml @@ -0,0 +1,8 @@ + + + + + + -- cgit v1.2.3