Merge pull request #2126 from kiraware/fix-indonesian-translation

Fix Indonesian translation with printf formatting

.cirrus.yml

@@ -11,12 +11,12 @@ FreeBSD_task:
       SSL:
   matrix:
     freebsd_instance:
-      image_family: freebsd-14-0
+      image_family: freebsd-14-2
   prepare_script:
-    - pkg install -y pkgconf cmake git libsodium $SSL
+    - pkg install -y pkgconf cmake git libsodium cpu_features $SSL
     - git submodule update --init --recursive
   configure_script:
-    - ./configure
+    - CMAKE_FLAGS="-DUSE_SYSTEM_CPU_FEATURES=1" CFLAGS="-I/usr/local/include/cpu_features" ./configure
   build_script:
     - make -j $(sysctl -n hw.ncpu || echo 4) -C build
   test_script:

.github/workflows/docker-aio.yml

@@ -0,0 +1,98 @@
+name: docker-aio
+
+on:
+  push:
+    branches: 
+      - 'master'
+    tags:
+      - '*'
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  docker:
+    name: docker-aio
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'SoftEtherVPN' }}
+    steps:
+      -
+        name: Docker meta vpnserver
+        id: metavpnserver
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ github.repository_owner }}/vpnserver
+          tags: |
+            type=raw,value=latest,enable={{is_default_branch}}
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+      - 
+        name: Docker meta vpnclient
+        id: metavpnclient
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ github.repository_owner }}/vpnclient
+          tags: |
+            type=raw,value=latest,enable={{is_default_branch}}
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+      - 
+        name: Docker meta vpnbridge
+        id: metavpnbridge
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ github.repository_owner }}/vpnbridge
+          tags: |
+            type=raw,value=latest,enable={{is_default_branch}}
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+      -
+        name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          image: tonistiigi/binfmt:qemu-v9.2.0
+#
+# TODO: unpin qemu version after default is updated
+#
+      -
+        name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      -
+        name: Login to DockerHub
+        if: ${{ github.event_name != 'pull_request' }}
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      -
+        name: Build and push vpnserver
+        uses: docker/build-push-action@v6
+        with:
+          file: ./Dockerfile
+          target: vpnserver
+          push: ${{ github.event_name != 'pull_request' }}
+          platforms: linux/amd64,linux/arm64
+          tags: ${{ steps.metavpnserver.outputs.tags }}
+          labels: ${{ steps.metavpnserver.outputs.labels }}
+      -
+        name: Build and push vpnclient
+        uses: docker/build-push-action@v6
+        with:
+          file: ./Dockerfile
+          target: vpnclient
+          push: ${{ github.event_name != 'pull_request' }}
+          platforms: linux/amd64,linux/arm64
+          tags: ${{ steps.metavpnclient.outputs.tags }}
+          labels: ${{ steps.metavpnclient.outputs.labels }}
+      -
+        name: Build and push vpnbridge
+        uses: docker/build-push-action@v6
+        with:
+          file: ./Dockerfile
+          target: vpnbridge
+          push: ${{ github.event_name != 'pull_request' }}
+          platforms: linux/amd64,linux/arm64
+          tags: ${{ steps.metavpnbridge.outputs.tags }}
+          labels: ${{ steps.metavpnbridge.outputs.labels }}

.github/workflows/fedora-rawhide.yml

@@ -25,10 +25,10 @@ jobs:
         submodules: true
     - name: Install dependencies
       run: |
-        dnf -y install git cmake ncurses-devel openssl-devel-engine libsodium-devel readline-devel zlib-devel gcc-c++ clang
+        dnf -y install git cmake ncurses-devel openssl-devel-engine libsodium-devel readline-devel zlib-devel gcc-c++ clang google-cpu_features-devel
     - name: Compile with ${{ matrix.cc }}
       run: |
         export CC=${{ matrix.cc }}
-        ./configure
+        CMAKE_FLAGS="-DUSE_SYSTEM_CPU_FEATURES=1" CFLAGS="-I/usr/include/cpu_features" ./configure
         make -C build
 

.github/workflows/linux.yml

@@ -26,6 +26,13 @@ jobs:
         cd build
         cpack -C Release -G DEB 
 
+    - name: Upload DEB packages as artifacts
+      if: github.ref == 'refs/heads/master'
+      uses: actions/upload-artifact@v4
+      with:
+        name: deb-packages
+        path: build/*.deb
+
     - name: Test
       run: |
        .ci/appveyor-deb-install-test.sh

.github/workflows/macos.yml

@@ -7,7 +7,7 @@ jobs:
   build_and_test:
     strategy:
       matrix:
-        os: [macos-14, macos-13, macos-12]
+        os: [macos-15, macos-14, macos-13]
     name: ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
     steps:

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.15)
 set(BUILD_NUMBER CACHE STRING "The number of the current build.")
 
 if ("${BUILD_NUMBER}" STREQUAL "")
-	set(BUILD_NUMBER "5186")
+	set(BUILD_NUMBER "5187")
 endif()
 
 if (BUILD_NUMBER LESS 5180)

CMakeSettings.json

@@ -1,5 +1,5 @@
 {
-  "environments": [ { "BuildNumber": "5186" } ],
+  "environments": [ { "BuildNumber": "5187" } ],
   "configurations": [
     {
       "name": "x64-native",

ContainerREADME.md

@@ -0,0 +1,104 @@
+# SoftetherVPN Container images
+
+This container is designed to be as small as possible and host a SoftEther VPN Server, Bridge or Client.
+It´s based on Alpine so resulting Image is kept as small as 15MB!
+
+## Not working 
+
+* bridging to a physical Ethernet adapter 
+
+## working
+
+* OpenVPN
+* L2tp
+* SSL 
+* SecureNAT
+* Wireguard (not with the "stable" tag)
+
+
+
+## Available Tags
+
+
+|Image|Description|
+|---|---|
+|softethervpn/vpnserver:stable|Latest stable release from https://github.com/SoftEtherVPN/SoftEtherVPN_Stable|
+|softethervpn/vpnserver:v4.39-9772-beta|Tagged build|
+|softethervpn/vpnserver:latest|Latest commits from https://github.com/SoftEtherVPN/SoftEtherVPN|
+
+
+You should always specify your wanted version like `softethervpn/vpnserver:5.02.5180`
+
+## Usage docker run
+
+This will keep your config and Logfiles in the docker volume `softetherdata`
+
+`docker run -d --rm --name softether-vpn-server -v softetherdata:/var/lib/softether -v softetherlogs:/var/log/softether -p 443:443/tcp -p 992:992/tcp -p 1194:1194/udp -p 5555:5555/tcp -p 500:500/udp -p 4500:4500/udp -p 1701:1701/udp --cap-add NET_ADMIN softethervpn/vpnserver:stable`
+
+## Port requirements
+
+As there are different operating modes for SoftetherVPN there is a variety of ports that might or might not be needed.
+For operation with Softether Clients at least 443, 992 or 5555 is needed.
+See https://www.softether.org/4-docs/1-manual/1/1.6 for reference on the Softether ports.
+Others are commented out in the docker-compose example.
+
+## Usage docker-compose
+
+The same command can be achieved by docker-compose, the docker compose file is in the repository.
+You can specify the respective docker-compose.yaml like so: 
+
+`docker-compose -f docker-compose.vpnclient.yaml up -d`
+
+By default the docker-compose.yaml is used: 
+
+```
+version: '3'
+
+services:
+  softether:
+    image: softethervpn/vpnserver:latest
+    cap_add:
+      - NET_ADMIN
+    restart: always
+    ports:
+      #- 53:53         #DNS tunneling
+      - 443:443         #Management and HTTPS tunneling
+      #- 992:992         #HTTPS tunneling
+      #- 1194:1194/udp #OpenVPN 
+      #- 5555:5555       #HTTPS tunneling
+      #- 500:500/udp   #IPsec/L2TP
+      #- 4500:4500/udp #IPsec/L2TP
+      #- 1701:1701/udp #IPsec/L2TP
+    volumes:
+      - "/etc/localtime:/etc/localtime:ro"
+      - "/etc/timezone:/etc/timezone:ro"
+      - "./softether_data:/var/lib/softether"
+      - "./softether_log:/var/log/softether"
+      # - "./adminip.txt:/var/lib/softether/adminip.txt:ro"
+```
+
+### Use vpncmd
+
+With newer releases vpncmd is directly in the container so you can use it to configure vpn. You can can run it once the container is running :
+
+`docker exec -it softether-vpn-server vpncmd localhost`
+example to configure a vpnclient
+
+```
+docker exec -it softether-vpn-server vpncmd localhost /client
+
+VPN Client> AccountSet homevpn /SERVER:192.168.1.1:443 /HUB:VPN
+VPN Client> AccountPasswordSet homevpn /PASSWORD:verysecurepassword /TYPE:standard
+VPN Client> AccountConnect homevpn
+
+#Automatically connect once container starts
+VPN Client> AccountStartupSet homevpn
+
+#Checking State
+VPN Client> AccountStatusGet homevpn
+
+```
+
+## Building 
+
+` docker build --target vpnclient -t softethevpn:latest .`

Dockerfile

@@ -0,0 +1,51 @@
+FROM alpine AS builder
+RUN mkdir /usr/local/src && apk add binutils --no-cache\
+        linux-headers \
+	build-base \
+        readline-dev \
+        openssl-dev \
+        ncurses-dev \
+        git \
+        cmake \
+        zlib-dev \
+        libsodium-dev \
+        gnu-libiconv 
+
+ENV LD_PRELOAD=/usr/lib/preloadable_libiconv.so
+ADD ./ /usr/local/src/SoftEtherVPN/
+WORKDIR /usr/local/src
+ENV USE_MUSL=YES
+ENV CMAKE_FLAGS="-DSE_PIDDIR=/run/softether -DSE_LOGDIR=/var/log/softether -DSE_DBDIR=/var/lib/softether"
+RUN cd SoftEtherVPN &&\
+        ./configure &&\
+	make -j $(getconf _NPROCESSORS_ONLN) -C build
+
+FROM alpine AS base
+RUN apk add --no-cache readline \
+        openssl \
+        libsodium \
+        gnu-libiconv \
+        iptables
+ENV LD_PRELOAD=/usr/lib/preloadable_libiconv.so
+WORKDIR /usr/local/bin
+VOLUME /var/log/softether
+VOLUME /var/lib/softether
+VOLUME /run/softether
+COPY --from=builder /usr/local/src/SoftEtherVPN/build/vpncmd /usr/local/src/SoftEtherVPN/build/hamcore.se2 ./
+COPY --from=builder /usr/local/src/SoftEtherVPN/build/libcedar.so /usr/local/src/SoftEtherVPN/build/libmayaqua.so /usr/local/lib/
+
+
+FROM base AS vpnserver
+COPY --from=builder /usr/local/src/SoftEtherVPN/build/vpnserver ./
+EXPOSE 443/tcp 992/tcp 1194/tcp 1194/udp 5555/tcp 500/udp 4500/udp
+CMD ["/usr/local/bin/vpnserver", "execsvc"]
+
+
+FROM base AS vpnclient
+COPY --from=builder /usr/local/src/SoftEtherVPN/build/vpnclient ./
+CMD ["/usr/local/bin/vpnclient", "execsvc"]
+
+
+FROM base AS vpnbridge
+COPY --from=builder /usr/local/src/SoftEtherVPN/build/vpnbridge ./
+CMD ["/usr/local/bin/vpnbridge", "execsvc"]

README.md

@@ -211,6 +211,10 @@ Also SoftEther VPN [Stable Edition](https://www.freshports.org/security/softethe
 Those can be found under https://www.softether-download.com/
 There you can also find SoftEtherVPN source code in zip and tar formats.
 
+## Docker Container Image
+
+Please look at the [ContainerREADME.md](ContainerREADME.md)
+
 ## Build from Source code
 
 see [BUILD_UNIX](src/BUILD_UNIX.md) or [BUILD_WINDOWS](src/BUILD_WINDOWS.md)

SoftEtherVPN-iOS/SoftEtherVPN-iOS/Protocol/SecureConnection.swift

@@ -0,0 +1,118 @@
+import Foundation
+import Network
+import Security
+
+/// SecureConnection handles the TLS connection with the SoftEther VPN server
+class SecureConnection {
+    
+    // MARK: - Properties
+    
+    private var connection: NWConnection?
+    private let host: String
+    private let port: UInt16
+    private let queue = DispatchQueue(label: "com.softether.connection", qos: .userInitiated)
+    
+    // MARK: - Initialization
+    
+    /// Initialize a secure connection
+    /// - Parameters:
+    ///   - host: Server hostname or IP address
+    ///   - port: Server port number
+    init(host: String, port: UInt16) {
+        self.host = host
+        self.port = port
+    }
+    
+    // MARK: - Public Methods
+    
+    /// Connect to the server using TLS
+    /// - Parameter completion: Callback with connection result
+    func connect(completion: @escaping (Bool, Error?) -> Void) {
+        let hostEndpoint = NWEndpoint.Host(host)
+        let portEndpoint = NWEndpoint.Port(rawValue: port)!
+        
+        // Create TLS parameters
+        let tlsOptions = NWProtocolTLS.Options()
+        
+        // Configure TLS for maximum compatibility with SoftEther
+        let securityOptions = tlsOptions.securityProtocolOptions
+        sec_protocol_options_set_tls_min_version(securityOptions, .TLSv12)
+        sec_protocol_options_set_tls_max_version(securityOptions, .TLSv13)
+        
+        // Allow all cipher suites for compatibility
+        sec_protocol_options_set_cipher_suites(securityOptions, nil, 0)
+        
+        // Disable certificate validation for initial development (ENABLE IN PRODUCTION)
+        sec_protocol_options_set_verify_block(securityOptions, { (_, _, trustResult, _) in
+            return true // Accept all certificates for testing
+        }, queue)
+        
+        // Create TCP options with TLS
+        let tcpOptions = NWProtocolTCP.Options()
+        tcpOptions.enableKeepalive = true
+        tcpOptions.keepaliveIdle = 30
+        
+        // Create connection parameters
+        let parameters = NWParameters(tls: tlsOptions, tcp: tcpOptions)
+        
+        // Create the connection
+        connection = NWConnection(host: hostEndpoint, port: portEndpoint, using: parameters)
+        
+        // Set up state handling
+        connection?.stateUpdateHandler = { [weak self] state in
+            switch state {
+            case .ready:
+                completion(true, nil)
+            case .failed(let error):
+                self?.disconnect()
+                completion(false, error)
+            case .cancelled:
+                completion(false, NSError(domain: "SoftEtherError", code: 1000, userInfo: [NSLocalizedDescriptionKey: "Connection cancelled"]))
+            default:
+                break
+            }
+        }
+        
+        // Start the connection
+        connection?.start(queue: queue)
+    }
+    
+    /// Disconnect from the server
+    func disconnect() {
+        connection?.cancel()
+        connection = nil
+    }
+    
+    /// Send data to the server
+    /// - Parameters:
+    ///   - data: Data to send
+    ///   - completion: Callback with error if any
+    func send(data: Data, completion: @escaping (Error?) -> Void) {
+        guard let connection = connection, connection.state == .ready else {
+            completion(NSError(domain: "SoftEtherError", code: 1001, userInfo: [NSLocalizedDescriptionKey: "Connection not ready"]))
+            return
+        }
+        
+        connection.send(content: data, completion: .contentProcessed { error in
+            completion(error)
+        })
+    }
+    
+    /// Receive data from the server
+    /// - Parameter completion: Callback with received data and error if any
+    func receive(completion: @escaping (Data?, Error?) -> Void) {
+        guard let connection = connection, connection.state == .ready else {
+            completion(nil, NSError(domain: "SoftEtherError", code: 1001, userInfo: [NSLocalizedDescriptionKey: "Connection not ready"]))
+            return
+        }
+        
+        connection.receive(minimumIncompleteLength: 1, maximumLength: 65536) { data, _, isComplete, error in
+            completion(data, error)
+            
+            if isComplete {
+                // Connection was closed by the peer
+                self.disconnect()
+            }
+        }
+    }
+}

SoftEtherVPN-iOS/SoftEtherVPN-iOS/Protocol/SoftEtherClientSignature.swift

@@ -0,0 +1,90 @@
+import Foundation
+
+/// Handles the specific client signature format that SoftEther expects
+class SoftEtherClientSignature {
+    
+    // MARK: - Constants
+    
+    private enum Constants {
+        static let clientBuildNumber: UInt32 = 5187
+        static let clientVersion: UInt32 = 5_02_0000 + clientBuildNumber
+        static let clientString = "SoftEther VPN Client"
+        static let softEtherMagic: [UInt8] = [0x5E, 0x68] // 'Se' in hex
+        
+        // Protocol identification constants from SoftEther source
+        static let cedar = "CEDAR"
+        static let sessionKey = "sessionkey"
+        static let protocol1 = "PROTOCOL"
+        static let protocol2 = "PROTOCOL2"
+    }
+    
+    // MARK: - Public Methods
+    
+    /// Generate the client signature packet that identifies this client as a legitimate SoftEther VPN client
+    /// - Returns: Data containing the formatted client signature
+    static func generateSignature() -> Data {
+        var data = Data()
+        
+        // 1. Add SoftEther magic bytes
+        data.append(contentsOf: Constants.softEtherMagic)
+        
+        // 2. Add client version in network byte order (big endian)
+        data.appendUInt32(Constants.clientVersion)
+        
+        // 3. Add client build number in network byte order
+        data.appendUInt32(Constants.clientBuildNumber)
+        
+        // 4. Add cedar protocol identifier
+        if let cedarData = Constants.cedar.data(using: .ascii) {
+            data.append(cedarData)
+            data.append(0) // null terminator
+        }
+        
+        // 5. Add client string with null terminator
+        if let clientString = (Constants.clientString + "\0").data(using: .ascii) {
+            data.append(clientString)
+        }
+        
+        // 6. Add protocol identifiers
+        if let protocolData = (Constants.protocol1 + "\0").data(using: .ascii) {
+            data.append(protocolData)
+        }
+        
+        if let protocol2Data = (Constants.protocol2 + "\0").data(using: .ascii) {
+            data.append(protocol2Data)
+        }
+        
+        // 7. Add session key marker
+        if let sessionKeyData = (Constants.sessionKey + "\0").data(using: .ascii) {
+            data.append(sessionKeyData)
+        }
+        
+        // 8. Add random data for session key (typically 20 bytes)
+        let randomSessionKey = SoftEtherCrypto.randomBytes(count: 20)
+        data.append(randomSessionKey)
+        
+        // 9. Calculate and append SHA-1 hash of the entire data for integrity verification
+        let hash = SoftEtherCrypto.sha1(data)
+        data.append(hash)
+        
+        return data
+    }
+    
+    /// Verify a server response to the client signature
+    /// - Parameter data: Response data from server
+    /// - Returns: True if valid response, false otherwise
+    static func verifyServerResponse(_ data: Data) -> Bool {
+        // Basic validation - a real implementation would parse and validate the server response format
+        // This is a minimal check to see if we have enough data and it starts with the magic bytes
+        guard data.count >= 8 else {
+            return false
+        }
+        
+        // Check if response starts with SoftEther magic bytes
+        if data[0] == Constants.softEtherMagic[0] && data[1] == Constants.softEtherMagic[1] {
+            return true
+        }
+        
+        return false
+    }
+}

SoftEtherVPN-iOS/SoftEtherVPN-iOS/Protocol/SoftEtherCrypto.swift

@@ -0,0 +1,97 @@
+import Foundation
+import CryptoKit
+
+/// Handles encryption operations for SoftEther protocol
+class SoftEtherCrypto {
+    
+    // MARK: - Constants
+    
+    private enum Constants {
+        static let sha1Size = 20
+        static let md5Size = 16
+    }
+    
+    // MARK: - Public Methods
+    
+    /// Generate secure random bytes
+    /// - Parameter count: Number of random bytes to generate
+    /// - Returns: Data containing random bytes
+    static func randomBytes(count: Int) -> Data {
+        var data = Data(count: count)
+        _ = data.withUnsafeMutableBytes { 
+            SecRandomCopyBytes(kSecRandomDefault, count, $0.baseAddress!)
+        }
+        return data
+    }
+    
+    /// Calculate SHA-1 hash
+    /// - Parameter data: Input data
+    /// - Returns: SHA-1 hash of the input data
+    static func sha1(_ data: Data) -> Data {
+        let digest = SHA1.hash(data: data)
+        return Data(digest)
+    }
+    
+    /// Calculate MD5 hash
+    /// - Parameter data: Input data
+    /// - Returns: MD5 hash of the input data
+    static func md5(_ data: Data) -> Data {
+        let digest = Insecure.MD5.hash(data: data)
+        return Data(digest)
+    }
+    
+    /// Encrypt data using RC4 algorithm (for SoftEther compatibility)
+    /// - Parameters:
+    ///   - data: Data to encrypt
+    ///   - key: Encryption key
+    /// - Returns: Encrypted data
+    static func rc4Encrypt(data: Data, key: Data) -> Data {
+        let rc4 = RC4(key: key)
+        return rc4.process(data)
+    }
+    
+    /// Decrypt data using RC4 algorithm (for SoftEther compatibility)
+    /// - Parameters:
+    ///   - data: Data to decrypt
+    ///   - key: Decryption key
+    /// - Returns: Decrypted data
+    static func rc4Decrypt(data: Data, key: Data) -> Data {
+        // RC4 is symmetric, so encryption and decryption are the same operation
+        return rc4Encrypt(data: data, key: key)
+    }
+}
+
+/// Simple RC4 implementation for SoftEther compatibility
+/// Note: RC4 is considered insecure, but SoftEther uses it in parts of its protocol
+private class RC4 {
+    private var state: [UInt8]
+    
+    init(key: Data) {
+        state = Array(0...255)
+        var j: Int = 0
+        
+        // Key scheduling algorithm
+        for i in 0..<256 {
+            let keyByte = key[i % key.count]
+            j = (j + Int(state[i]) + Int(keyByte)) & 0xFF
+            state.swapAt(i, j)
+        }
+    }
+    
+    func process(_ data: Data) -> Data {
+        var result = Data(count: data.count)
+        var i: Int = 0
+        var j: Int = 0
+        
+        // Generate keystream and XOR with plaintext
+        for k in 0..<data.count {
+            i = (i + 1) & 0xFF
+            j = (j + Int(state[i])) & 0xFF
+            state.swapAt(i, j)
+            let keyStreamByte = state[(Int(state[i]) + Int(state[j])) & 0xFF]
+            result[k] = data[k] ^ keyStreamByte
+        }
+        
+        return result
+    }
+}

SoftEtherVPN-iOS/SoftEtherVPN-iOS/Protocol/SoftEtherPacket.swift

@@ -0,0 +1,123 @@
+import Foundation
+
+/// Handles the SoftEther packet structure for communication
+class SoftEtherPacket {
+    
+    // MARK: - Constants
+    
+    private enum PacketType: UInt32 {
+        case clientSignature = 0x01
+        case serverResponse = 0x02
+        case sessionRequest = 0x03
+        case sessionResponse = 0x04
+        case data = 0x05
+        case keepAlive = 0x06
+    }
+    
+    private enum Constants {
+        static let headerSize: UInt32 = 16
+        static let maxPacketSize: UInt32 = 1024 * 1024 // 1MB
+    }
+    
+    // MARK: - Properties
+    
+    private var packetType: PacketType
+    private var packetId: UInt32
+    private var packetData: Data
+    
+    // MARK: - Initialization
+    
+    /// Initialize a packet with type, ID and data
+    /// - Parameters:
+    ///   - type: Packet type
+    ///   - id: Packet ID
+    ///   - data: Packet payload
+    init(type: UInt32, id: UInt32, data: Data) {
+        self.packetType = PacketType(rawValue: type) ?? .data
+        self.packetId = id
+        self.packetData = data
+    }
+    
+    /// Initialize a packet from raw data
+    /// - Parameter data: Raw packet data
+    init?(fromData data: Data) {
+        guard data.count >= Int(Constants.headerSize) else {
+            return nil
+        }
+        
+        // Parse header
+        let typeValue = data.readUInt32(at: 0)
+        self.packetId = data.readUInt32(at: 4)
+        let dataSize = data.readUInt32(at: 8)
+        
+        // Validate packet
+        guard let type = PacketType(rawValue: typeValue),
+              dataSize <= Constants.maxPacketSize,
+              data.count >= Int(Constants.headerSize + dataSize) else {
+            return nil
+        }
+        
+        self.packetType = type
+        
+        // Extract payload
+        let startIndex = Int(Constants.headerSize)
+        let endIndex = startIndex + Int(dataSize)
+        self.packetData = data.subdata(in: startIndex..<endIndex)
+    }
+    
+    // MARK: - Public Methods
+    
+    /// Serialize the packet to binary data format
+    /// - Returns: Serialized packet data
+    func serialize() -> Data {
+        var result = Data(capacity: Int(Constants.headerSize) + packetData.count)
+        
+        // Write header
+        result.appendUInt32(packetType.rawValue)
+        result.appendUInt32(packetId)
+        result.appendUInt32(UInt32(packetData.count))
+        result.appendUInt32(0) // Reserved
+        
+        // Write payload
+        result.append(packetData)
+        
+        return result
+    }
+    
+    /// Get the packet type
+    /// - Returns: Packet type
+    func getType() -> UInt32 {
+        return packetType.rawValue
+    }
+    
+    /// Get the packet ID
+    /// - Returns: Packet ID
+    func getId() -> UInt32 {
+        return packetId
+    }
+    
+    /// Get the packet payload
+    /// - Returns: Packet payload data
+    func getData() -> Data {
+        return packetData
+    }
+}
+
+// MARK: - Extensions
+
+extension Data {
+    /// Read a UInt32 value from the data at specified offset
+    /// - Parameter offset: Offset to read from
+    /// - Returns: UInt32 value in big-endian order
+    func readUInt32(at offset: Int) -> UInt32 {
+        let slice = self.subdata(in: offset..<(offset + 4))
+        return slice.withUnsafeBytes { $0.load(as: UInt32.self).bigEndian }
+    }
+    
+    /// Append a UInt32 value to the data in big-endian order
+    /// - Parameter value: UInt32 value to append
+    mutating func appendUInt32(_ value: UInt32) {
+        var bigEndian = value.bigEndian
+        append(UnsafeBufferPointer(start: &bigEndian, count: 1))
+    }
+}

SoftEtherVPN-iOS/SoftEtherVPN-iOS/Protocol/SoftEtherProtocol.swift

@@ -0,0 +1,184 @@
+import Foundation
+import Network
+import Security
+import CryptoKit
+
+/// SoftEtherProtocol manages the communication between iOS client and SoftEther VPN server
+class SoftEtherProtocol {
+    
+    // MARK: - Properties
+    
+    private var secureConnection: SecureConnection?
+    private var isConnected = false
+    private var host: String = ""
+    private var port: UInt16 = 443
+    private var nextPacketId: UInt32 = 1
+    
+    // MARK: - Public Methods
+    
+    /// Connect to a SoftEther VPN server
+    /// - Parameters:
+    ///   - host: The server hostname or IP address
+    ///   - port: The server port (default: 443)
+    ///   - completion: Callback with connection result
+    public func connect(to host: String, port: UInt16 = 443, completion: @escaping (Bool, Error?) -> Void) {
+        self.host = host
+        self.port = port
+        
+        // Create a secure connection
+        secureConnection = SecureConnection(host: host, port: port)
+        
+        // Connect using TLS
+        secureConnection?.connect { [weak self] success, error in
+            guard let self = self, success else {
+                completion(false, error ?? NSError(domain: "SoftEtherError", code: 1, userInfo: [NSLocalizedDescriptionKey: "TLS connection failed"]))
+                return
+            }
+            
+            // After successful TLS connection, send the client signature
+            self.sendClientSignature { success, error in
+                if success {
+                    self.isConnected = true
+                }
+                completion(success, error)
+            }
+        }
+    }
+    
+    /// Disconnect from the server
+    public func disconnect() {
+        secureConnection?.disconnect()
+        isConnected = false
+    }
+    
+    // MARK: - Private Methods
+    
+    /// Send the SoftEther client signature to identify as a legitimate client
+    /// - Parameter completion: Callback with result
+    private func sendClientSignature(completion: @escaping (Bool, Error?) -> Void) {
+        // Generate client signature using our specialized class
+        let signatureData = SoftEtherClientSignature.generateSignature()
+        
+        // Create a packet with the signature data
+        let packetId = self.nextPacketId
+        self.nextPacketId += 1
+        
+        let packet = SoftEtherPacket(type: 0x01, id: packetId, data: signatureData)
+        let packetData = packet.serialize()
+        
+        print("Sending client signature packet: \(packetData.count) bytes")
+        
+        // Send the packet
+        secureConnection?.send(data: packetData) { [weak self] error in
+            guard let self = self else { return }
+            
+            if let error = error {
+                print("Error sending client signature: \(error)")
+                completion(false, error)
+                return
+            }
+            
+            // After sending signature, wait for server response
+            self.receiveServerResponse { success, error in
+                completion(success, error)
+            }
+        }
+    }
+    
+    /// Receive and process server response after sending signature
+    /// - Parameter completion: Callback with result
+    private func receiveServerResponse(completion: @escaping (Bool, Error?) -> Void) {
+        secureConnection?.receive { data, error in
+            if let error = error {
+                print("Error receiving server response: \(error)")
+                completion(false, error)
+                return
+            }
+            
+            guard let data = data, data.count > 4 else {
+                let error = NSError(domain: "SoftEtherError", code: 2, userInfo: [NSLocalizedDescriptionKey: "Invalid server response"])
+                print("Invalid server response: insufficient data")
+                completion(false, error)
+                return
+            }
+            
+            print("Received server response: \(data.count) bytes")
+            
+            // Parse the response packet
+            guard let packet = SoftEtherPacket(fromData: data) else {
+                let error = NSError(domain: "SoftEtherError", code: 3, userInfo: [NSLocalizedDescriptionKey: "Invalid packet format"])
+                print("Could not parse server response packet")
+                completion(false, error)
+                return
+            }
+            
+            // Verify the response
+            let packetData = packet.getData()
+            let isValid = SoftEtherClientSignature.verifyServerResponse(packetData)
+            
+            if isValid {
+                print("Server accepted our client signature")
+                completion(true, nil)
+            } else {
+                print("Server rejected our client signature")
+                let error = NSError(domain: "SoftEtherError", code: 4, userInfo: [NSLocalizedDescriptionKey: "Server rejected client signature"])
+                completion(false, error)
+            }
+        }
+    }
+    
+    /// Send a data packet to the server
+    /// - Parameters:
+    ///   - data: Data to send
+    ///   - completion: Callback with result
+    func sendData(data: Data, completion: @escaping (Bool, Error?) -> Void) {
+        guard isConnected else {
+            completion(false, NSError(domain: "SoftEtherError", code: 5, userInfo: [NSLocalizedDescriptionKey: "Not connected to server"]))
+            return
+        }
+        
+        let packetId = self.nextPacketId
+        self.nextPacketId += 1
+        
+        let packet = SoftEtherPacket(type: 0x05, id: packetId, data: data)
+        let packetData = packet.serialize()
+        
+        secureConnection?.send(data: packetData) { error in
+            if let error = error {
+                completion(false, error)
+                return
+            }
+            
+            completion(true, nil)
+        }
+    }
+    
+    /// Receive data from the server
+    /// - Parameter completion: Callback with received data and result
+    func receiveData(completion: @escaping (Data?, Bool, Error?) -> Void) {
+        guard isConnected else {
+            completion(nil, false, NSError(domain: "SoftEtherError", code: 5, userInfo: [NSLocalizedDescriptionKey: "Not connected to server"]))
+            return
+        }
+        
+        secureConnection?.receive { data, error in
+            if let error = error {
+                completion(nil, false, error)
+                return
+            }
+            
+            guard let data = data, data.count > 4 else {
+                completion(nil, false, NSError(domain: "SoftEtherError", code: 2, userInfo: [NSLocalizedDescriptionKey: "Invalid server response"]))
+                return
+            }
+            
+            // Parse the packet
+            guard let packet = SoftEtherPacket(fromData: data) else {
+                completion(nil, false, NSError(domain: "SoftEtherError", code: 3, userInfo: [NSLocalizedDescriptionKey: "Invalid packet format"]))
+                return
+            }
+            
+            completion(packet.getData(), true, nil)
+        }
+    }
+}

SoftEtherVPN-iOS/SoftEtherVPN-iOS/SoftEtherVPNClient.swift

@@ -0,0 +1,149 @@
+import Foundation
+import UIKit
+
+/// SoftEtherVPNClient provides a simple interface for connecting to SoftEther VPN servers
+public class SoftEtherVPNClient {
+    
+    // MARK: - Properties
+    
+    private let protocol: SoftEtherProtocol
+    private var connectionState: ConnectionState = .disconnected
+    
+    // MARK: - Public Types
+    
+    /// Connection states for the VPN client
+    public enum ConnectionState {
+        case disconnected
+        case connecting
+        case connected
+        case disconnecting
+        case error(Error)
+    }
+    
+    /// Connection delegate to receive state updates
+    public protocol ConnectionDelegate: AnyObject {
+        func connectionStateDidChange(_ state: ConnectionState)
+    }
+    
+    /// Weak reference to the delegate
+    public weak var delegate: ConnectionDelegate?
+    
+    // MARK: - Initialization
+    
+    public init() {
+        self.protocol = SoftEtherProtocol()
+    }
+    
+    // MARK: - Public Methods
+    
+    /// Connect to a SoftEther VPN server
+    /// - Parameters:
+    ///   - host: Server hostname or IP address
+    ///   - port: Server port (default: 443)
+    ///   - completion: Optional completion handler
+    public func connect(to host: String, port: UInt16 = 443, completion: ((Bool, Error?) -> Void)? = nil) {
+        // Update state
+        connectionState = .connecting
+        delegate?.connectionStateDidChange(connectionState)
+        
+        // Connect using the protocol implementation
+        protocol.connect(to: host, port: port) { [weak self] success, error in
+            guard let self = self else { return }
+            
+            if success {
+                self.connectionState = .connected
+            } else if let error = error {
+                self.connectionState = .error(error)
+            } else {
+                self.connectionState = .disconnected
+            }
+            
+            self.delegate?.connectionStateDidChange(self.connectionState)
+            completion?(success, error)
+        }
+    }
+    
+    /// Disconnect from the server
+    /// - Parameter completion: Optional completion handler
+    public func disconnect(completion: (() -> Void)? = nil) {
+        // Update state
+        connectionState = .disconnecting
+        delegate?.connectionStateDidChange(connectionState)
+        
+        // Disconnect
+        protocol.disconnect()
+        
+        // Update state again
+        connectionState = .disconnected
+        delegate?.connectionStateDidChange(connectionState)
+        
+        completion?()
+    }
+    
+    /// Get the current connection state
+    /// - Returns: Current ConnectionState
+    public func getConnectionState() -> ConnectionState {
+        return connectionState
+    }
+    
+    /// Check if currently connected
+    /// - Returns: True if connected, false otherwise
+    public func isConnected() -> Bool {
+        if case .connected = connectionState {
+            return true
+        }
+        return false
+    }
+    
+    // MARK: - Example Usage
+    
+    /// Example showing how to use this class in a view controller
+    public static func exampleUsage() -> String {
+        return """
+        // In your view controller:
+        
+        private let vpnClient = SoftEtherVPNClient()
+        
+        override func viewDidLoad() {
+            super.viewDidLoad()
+            
+            // Set delegate
+            vpnClient.delegate = self
+        }
+        
+        @IBAction func connectButtonTapped(_ sender: UIButton) {
+            if vpnClient.isConnected() {
+                vpnClient.disconnect()
+            } else {
+                vpnClient.connect(to: "vpn.example.com") { success, error in
+                    if !success {
+                        print("Failed to connect: \\(error?.localizedDescription ?? "Unknown error")")
+                    }
+                }
+            }
+        }
+        
+        // MARK: - ConnectionDelegate
+        
+        extension YourViewController: SoftEtherVPNClient.ConnectionDelegate {
+            func connectionStateDidChange(_ state: SoftEtherVPNClient.ConnectionState) {
+                switch state {
+                case .connected:
+                    connectButton.setTitle("Disconnect", for: .normal)
+                    statusLabel.text = "Connected"
+                case .connecting:
+                    statusLabel.text = "Connecting..."
+                case .disconnecting:
+                    statusLabel.text = "Disconnecting..."
+                case .disconnected:
+                    connectButton.setTitle("Connect", for: .normal)
+                    statusLabel.text = "Disconnected"
+                case .error(let error):
+                    statusLabel.text = "Error: \\(error.localizedDescription)"
+                    connectButton.setTitle("Connect", for: .normal)
+                }
+            }
+        }
+        """
+    }
+}

description

@@ -2,4 +2,4 @@ SoftEther VPN ("SoftEther" means "Software Ethernet") is an open-source cross-pl
 Its protocol is very fast and it can be used in very restricted environments, as it's able to transfer packets over DNS and ICMP.
 The server includes a free Dynamic DNS service, which can be used to access the server even if the public IP address changes.
 A NAT-Traversal function is also available, very useful in case the required ports cannot be opened on the firewall.
-The supported third party protocols are OpenVPN, L2TP/IPSec and SSTP.
+The supported third party protocols are OpenVPN, L2TP/IPSec, SSTP and WireGuard.

developer_tools/stbchecker/stbchecker.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">

docker-compose.vpnclient.yaml

@@ -0,0 +1,16 @@
+version: '3'
+
+services:
+  softether:
+    image: softethervpn/vpnclient:latest
+    devices:
+      - /dev/net/tun:/dev/net/tun
+    cap_add:
+      - NET_ADMIN
+    restart: always
+    volumes:
+      - "/etc/localtime:/etc/localtime:ro"
+      - "/etc/timezone:/etc/timezone:ro"
+      - "./softether_data:/var/lib/softether"
+      - "./softether_log:/var/log/softether"
+      # - "./adminip.txt:/var/lib/softether/adminip.txt:ro"

docker-compose.yaml

@@ -0,0 +1,22 @@
+services:
+  softether:
+    image: softethervpn/vpnserver:latest
+    hostname: softethervpnserver
+    cap_add:
+      - NET_ADMIN
+    restart: always
+    ports:
+      #- 53:53         #DNS tunneling
+      - 443:443         #Management and HTTPS tunneling
+      - 992:992         #HTTPS tunneling
+      #- 1194:1194/udp #OpenVPN 
+      #- 5555:5555       #HTTPS tunneling
+      #- 500:500/udp   #IPsec/L2TP
+      #- 4500:4500/udp #IPsec/L2TP
+      #- 1701:1701/udp #IPsec/L2TP
+    volumes:
+      - "/etc/localtime:/etc/localtime:ro"
+      - "/etc/timezone:/etc/timezone:ro"
+      - "./softether_data:/var/lib/softether"
+      - "./softether_log:/var/log/softether"
+      # - "./adminip.txt:/var/lib/softether/adminip.txt:ro"

src/CMakeLists.txt

@@ -127,6 +127,9 @@ if(UNIX)
   if(SE_PIDDIR)
     add_definitions(-DSE_PIDDIR="${SE_PIDDIR}")
   endif()
+
+  # Use system libraries instead of bundled
+  set(USE_SYSTEM_CPU_FEATURES false CACHE BOOL "Use system cpu_features")
 endif()
 
 # Cedar communication module

src/Cedar/Proto_L2TP.c

@@ -2138,9 +2138,9 @@ void L2TPProcessInterrupts(L2TP_SERVER *l2tp)
 		UINT64 l2tpTimeout = L2TP_TUNNEL_TIMEOUT;
 
 		// If we got on ANY session a higher timeout than the default L2TP tunnel timeout, increase it
-		for (i = 0; i < LIST_NUM(t->SessionList); i++)
+		for (j = 0; j < LIST_NUM(t->SessionList); j++)
 		{
-			L2TP_SESSION* s = LIST_DATA(t->SessionList, i);
+			L2TP_SESSION* s = LIST_DATA(t->SessionList, j);
 
 			if (s->TubeRecv != NULL && s->TubeRecv->DataTimeout > l2tpTimeout)
 			{

src/Mayaqua/3rdparty/cpu_features

@@ -1 +1 @@
-Subproject commit 26133d3b620c2c27f31d571efd27371100f891e9
+Subproject commit ba4bffa86cbb5456bdb34426ad22b9551278e2c0

src/Mayaqua/3rdparty/liboqs

@@ -1 +1 @@
-Subproject commit 51ddd33cc04d12bd47c8639c1254714879f4cdf3
+Subproject commit f4b96220e4bd208895172acc4fedb5a191d9f5b1

src/Mayaqua/3rdparty/oqs-provider

@@ -1 +1 @@
-Subproject commit 8f37521d5e27ab4d1e0d69a4b4a5bd17927b24b9
+Subproject commit ec1e8431f92b52e5d437107a37dbe3408649e8c3

src/Mayaqua/CMakeLists.txt

@@ -109,8 +109,21 @@ if(UNIX)
       $<$<BOOL:${LIB_RT}>:${LIB_RT}>
   )
 
-  if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(armv7l|aarch64|s390x)$" OR NOT HAVE_SYS_AUXV OR SKIP_CPU_FEATURES)
+  if (NOT HAVE_SYS_AUXV OR SKIP_CPU_FEATURES)
     add_definitions(-DSKIP_CPU_FEATURES)
+  elseif(${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD" AND NOT CMAKE_SYSTEM_PROCESSOR MATCHES "^(amd64|i386)")
+    message("cpu_features is not available on FreeBSD/${CMAKE_SYSTEM_PROCESSOR}")
+    add_definitions(-DSKIP_CPU_FEATURES)
+  elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin" AND NOT CMAKE_SYSTEM_NAME MATCHES "^(arm64|x86_64)")
+    # macOS runs only on Intel or ARM architecrues, should not reach here
+    add_definitions(-DSKIP_CPU_FEATURES)
+  elseif(${CMAKE_SYSTEM_NAME} STREQUAL "SunOS" OR ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD")
+    message("cpu_features is not available on ${CMAKE_SYSTEM_NAME}")
+    add_definitions(-DSKIP_CPU_FEATURES)
+  elseif(USE_SYSTEM_CPU_FEATURES)
+    CHECK_INCLUDE_FILE(cpu_features_macros.h HAVE_CPU_FEATURES)
+    message("-- Using system's cpu_features")
+    target_link_libraries(mayaqua PRIVATE cpu_features)
   else()
     add_subdirectory(3rdparty/cpu_features)
     set_property(TARGET cpu_features PROPERTY POSITION_INDEPENDENT_CODE ON)

src/Mayaqua/Microsoft.c

@@ -4259,7 +4259,7 @@ UINT MsService(char *name, SERVICE_FUNCTION *start, SERVICE_FUNCTION *stop, UINT
 
 		if ((mode == SVC_MODE_INSTALL || mode == SVC_MODE_UNINSTALL || mode == SVC_MODE_START ||
 			mode == SVC_MODE_STOP || mode == SVC_MODE_SERVICE) &&
-			(ms->IsNt == false))
+			(IsNt() == false))
 		{
 			// Tried to use the command for the NT in non-WindowsNT system
 			MsgBox(NULL, MB_ICONSTOP, _UU("SVC_NT_ONLY"));

src/Mayaqua/Microsoft.h

@@ -170,7 +170,6 @@ typedef struct MS
 {
 	HINSTANCE hInst;
 	HINSTANCE hKernel32;
-	bool IsNt;
 	bool IsAdmin;
 	HANDLE hCurrentProcess;
 	UINT CurrentProcessId;

src/Mayaqua/Network.h

@@ -60,7 +60,7 @@ struct DYN_VALUE
 #define	DEFAULT_CIPHER_LIST			"ECDHE+AESGCM:ECDHE+CHACHA20:DHE+AESGCM:DHE+CHACHA20:ECDHE+AES256:DHE+AES256:RSA+AES"
 
 #if OPENSSL_VERSION_NUMBER >= 0x30000000L
-#define PQ_GROUP_LIST				"p521_kyber1024:x25519_kyber768:P-521:X25519:P-256"
+#define PQ_GROUP_LIST				"X25519MLKEM768:p521_kyber1024:x25519_kyber768:P-521:X25519:P-256"
 #endif
 
 // SSL logging function

src/bin/hamcore/languages.txt

@@ -9,3 +9,4 @@
 4 ko Korean 한국어 949 ko,kr,euc_kr,cp949,euckr
 5 ru Russian Русский 1049 ru
 6 pt_br Portuguese-Brazil Português-Brasil 1046 pt_br
+7 id Indonesian Bahasa 1057 id

src/bin/hamcore/vpnweb_sample_id.htm

@@ -0,0 +1,71 @@
+<HTML>
+<HEAD>
+	<TITLE>Halaman Penyebaran Web Installer VPN Client</TITLE>
+	<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
+	<META http-equiv="Content-Language" content="id">
+	<style type="text/css">
+	<!--
+BODY, TABLE, TR, TABLE, TD, H1, H2, H3, H4, P, LI, DIV
+{
+	font-family: "Arial", "Geneva", "Helvetica", "sans-serif", "MS PGothic", "MS UI Gothic", "Osaka";
+	font-size:small;
+	line-height:1.2em;
+}
+	-->
+	</style>
+</HEAD>
+<BODY>
+
+<h3>Contoh File HTML Halaman Penyebaran Web Installer VPN Client</h3>
+<p>File HTML ini adalah contoh.<br>
+Untuk membuat Web Installer menggunakan "SoftEther VPN Client Web Installer", silakan merujuk pada penjelasan berikut dan kode sumber HTML dari file ini.</p>
+<table border="1" cellspacing="0" cellpadding="4" style="border-collapse: collapse" bordercolor="#008000" id="table1">
+	<tr>
+		<td style="font-family: Consolas, Courier New, MS Gothic; font-size: 10pt">&lt;OBJECT ID=&quot;VpnWebInstaller&quot;<br>
+&nbsp;&nbsp;&nbsp; CLASSID=&quot;CLSID:64F1A16B-C3EE-484C-B551-35338A9BB6D2&quot;<br>
+&nbsp;&nbsp;&nbsp; CODEBASE=&quot;vpnweb.cab#Version=$VER_MAJOR$,$VER_MINOR$,0,$VER_BUILD$&quot;&gt;<br>
+&nbsp;&nbsp;&nbsp; &lt;PARAM NAME=&quot;InstallerExeUrl&quot; VALUE=&quot;<b><font color="#008000">http://example.com/any_folder/vpninstall.exe</font></b>&quot;&gt;<br>
+&nbsp;&nbsp;&nbsp; &lt;PARAM NAME=&quot;InstallerInfUrl&quot; VALUE=&quot;<b><font color="#008000">http://example.com/any_folder/vpninstall.inf</font></b>&quot;&gt;<br>
+&nbsp;&nbsp;&nbsp; &lt;PARAM NAME=&quot;SettingUrl&quot; VALUE=&quot;<b><font color="#008000">http://example.com/any_folder/auto_setting.vpn</font></b>&quot;&gt;<br>
+&nbsp;&nbsp;&nbsp; &lt;PARAM NAME=&quot;LanguageID&quot; VALUE=&quot;<b><font color="#008000">ID</font></b>&quot;&gt;<br>
+		&lt;/OBJECT&gt;</td>
+	</tr>
+</table>
+<p>Untuk membuat halaman web yang memulai Web Installer VPN Client, masukkan kode HTML seperti di atas. Kode HTML tersebut merujuk pada path kontrol ActiveX, dan parameter yang akan diteruskan ke ActiveX.</p>
+<p>Anda harus memodifikasi string yang ditebalkan dengan font hijau di atas sesuai dengan lingkungan server web tempat Anda menyebarkan.<br>
+(Peringatan, contoh di atas tidak akan berfungsi jika tetap menggunakan kode asli, karena contoh asli menyebutkan URL contoh.)<br>
+<br>
+Untuk detail lebih lanjut, silakan merujuk pada manual online atau <b> <a target="_blank" href="http://www.softether.org/">http://www.softether.org/</a></b>.<br>
+<br>
+<b><font color="#808000">Catatan: parameter &quot;SettingUrl&quot; dan &quot;LanguageID&quot; adalah opsional.</font></b></p>
+<p>　</p>
+
+
+<!-- Kode di bawah adalah contoh untuk menyematkan kontrol ActiveX. -->
+<h3>Kode di bawah ini adalah contoh untuk menyematkan kontrol ActiveX.</h3>
+<p>Peringatan: File HTML ini adalah contoh. Parameter untuk kontrol vpnweb.cab adalah dummy.<BR> Oleh karena itu, setelah Anda mengklik tombol Mulai Koneksi VPN, Anda akan mendapatkan pesan kesalahan.</p>
+<table border="1" cellspacing="1" cellpadding="6" style="border-collapse: collapse" width="450" bordercolor="#808000" id="table2">
+	<tr>
+		<td align="center" valign="top">
+
+<OBJECT ID="VpnWebInstaller"
+	CLASSID="CLSID:64F1A16B-C3EE-484C-B551-35338A9BB6D2"
+	CODEBASE="vpnweb.cab#Version=$VER_MAJOR$,$VER_MINOR$,0,$VER_BUILD$">
+	<PARAM NAME="InstallerExeUrl" VALUE="http://example.com/any_folder/vpninstall.exe">
+	<PARAM NAME="InstallerInfUrl" VALUE="http://example.com/any_folder/vpninstall.inf">
+	<PARAM NAME="SettingUrl" VALUE="http://example.com/any_folder/auto_setting.vpn">
+	<PARAM NAME="LanguageID" VALUE="ID">
+</OBJECT>
+
+		</td>
+	</tr>
+</table>
+　<p>Jika Kontrol ActiveX Web Installer VPN Client tidak ditampilkan pada persegi panjang coklat di atas, periksa persyaratan, dan pastikan bahwa browser web Anda mengizinkan kontrol ActiveX.</p>
+
+
+<p>　</p>
+<p align="right"><i>Copyright (c) SoftEther Project di Universitas Tsukuba, Jepang. Semua Hak Dilindungi.</i></p>
+
+
+</BODY>
+</HTML>

src/bin/hamcore/warning_id.txt

@@ -0,0 +1,139 @@
+PENGUMUMAN PENTING TENTANG SOFTETHER VPN
+
+FUNGSI KOMUNIKASI VPN YANG TERTANAM DALAM PERANGKAT LUNAK INI LEBIH KUAT DARI SEBELUMNYA. KEMAMPUAN VPN YANG KUAT INI AKAN MEMBERIKAN ANDA MANFAAT BESAR. NAMUN, JIKA ANDA MENYALAHGUNAKAN PERANGKAT LUNAK INI, HAL INI DAPAT MERUGIKAN ANDA SENDIRI. UNTUK MENGHINDARI RISIKO TERSEBUT, DOKUMEN INI BERISI PENGUMUMAN PENTING UNTUK PELANGGAN YANG INGIN MENGGUNAKAN PERANGKAT LUNAK INI. PETUNJUK BERIKUT SANGAT PENTING. BACA DAN PAHAMI DENGAN SEKSAMA.SELAIN ITU, JIKA ANDA BERENCANA MENGGUNAKAN FUNGSI DYNAMIC DNS, NAT TRAVERSAL, ATAU VPN AZURE, BACA BAGIAN 3.5 DENGAN SEKSAMA. FUNGSI-FUNGSI INI ADALAH LAYANAN GRATIS YANG DISEDIAKAN MELALUI INTERNET, TIDAK DIJAMIN, DAN TIDAK DIMAKSUDKAN UNTUK DIGUNAKAN DALAM BISNIS ATAU PENGGUNAAN KOMERSIAL. JANGAN GUNAKAN LAYANAN INI UNTUK BISNIS ATAU KEGIATAN KOMERSIAL ANDA.
+
+
+1. Protokol Komunikasi VPN
+1.1. Protokol SoftEther VPN
+SoftEther VPN dapat melakukan komunikasi VPN. Berbeda dengan protokol VPN tradisional, SoftEther VPN memiliki implementasi dari "Protokol SoftEther VPN (SE-VPN Protocol)" yang dirancang baru. Protokol SE-VPN mengenkapsulasi paket Ethernet apa pun ke dalam koneksi HTTPS (HTTP over SSL). Oleh karena itu, protokol SE-VPN dapat berkomunikasi melewati firewall bahkan jika firewall dikonfigurasi untuk memblokir paket VPN tradisional oleh administrator jaringan. Protokol SE-VPN dirancang dan diimplementasikan untuk mematuhi TLS 1.0 (RFC 5246) dan HTTPS (RFC 2818). Namun, terkadang memiliki perilaku yang berbeda dari RFC. Jika Anda adalah seorang administrator jaringan dan ingin memblokir protokol SE-VPN pada firewall, Anda dapat menerapkan kebijakan "daftar putih" pada firewall untuk memfilter semua paket TCP atau UDP di perbatasan kecuali paket yang secara eksplisit diizinkan menuju situs web dan server tertentu.
+
+1.2. Fungsi NAT Traversal
+Secara umum, jika Anda menggunakan sistem VPN tradisional, Anda harus meminta administrator jaringan untuk membuat NAT atau firewall agar "membuka" atau "meneruskan" port TCP atau UDP tertentu. Namun, ada permintaan untuk menghilangkan beban kerja tersebut bagi administrator jaringan. Untuk memenuhi permintaan tersebut, SoftEther VPN memiliki fungsi "NAT Traversal" yang baru diimplementasikan. NAT Traversal diaktifkan secara default. Server SoftEther VPN yang berjalan di komputer di balik NAT atau firewall dapat menerima koneksi VPN dari Internet tanpa konfigurasi khusus pada firewall atau NAT. Jika Anda ingin menonaktifkan fungsi NAT Traversal, ubah "DisableNatTraversal" menjadi "true" pada file konfigurasi SoftEther VPN Server. Untuk menonaktifkannya di sisi klien, tambahkan sufiks "/tcp" pada nama host tujuan.
+
+1.3. Fungsi Dynamic DNS
+Sistem VPN tradisional membutuhkan alamat IP global statis pada server VPN. Mengingat keterbatasan alamat IP global, SoftEther Corporation mengimplementasikan "Fungsi Dynamic DNS" pada SoftEther VPN Server. Dynamic DNS diaktifkan secara default. Fungsi Dynamic DNS memberi tahu alamat IP global saat ini dari PC ke Server Dynamic DNS yang dioperasikan oleh SoftEther Corporation. Nama host unik secara global (FQDN) seperti "abc.softether.net" ("abc" bervariasi dan unik untuk setiap pengguna) akan diberikan pada Server VPN. Jika Anda memberi tahu nama host unik ini kepada pengguna VPN, mereka dapat menggunakannya sebagai nama host tujuan VPN Server pada VPN Client dan dapat terhubung ke VPN Server tanpa perlu mengetahui alamat IP sebelumnya. Jika alamat IP VPN Server berubah, alamat IP yang terdaftar terkait dengan nama host layanan Dynamic DNS akan diperbarui secara otomatis. Dengan mekanisme ini, tidak diperlukan lagi alamat IP global statis yang biasanya memerlukan biaya bulanan dari ISP. Anda dapat menggunakan koneksi Internet berbiaya rendah dengan alamat IP dinamis untuk mengoperasikan sistem VPN tingkat perusahaan. Jika Anda ingin menonaktifkan Dynamic DNS, atur nilai "true" pada item "Disabled" dalam direktif "DDnsClient" pada file konfigurasi SoftEther VPN Server. * Catatan untuk penduduk Republik Rakyat Tiongkok: Jika VPN Server Anda berjalan di Republik Rakyat Tiongkok, sufiks DNS akan diganti menjadi domain "sedns.cn". Domain "sedns.cn" adalah layanan yang dimiliki dan dioperasikan oleh "Beijing Daiyuu SoftEther Technology Co., Ltd", sebuah perusahaan lokal Tiongkok.
+
+1.4. Fungsi VPN melalui ICMP / VPN melalui DNS
+Jika Anda ingin membuat koneksi VPN antara SoftEther VPN Client / Bridge dan SoftEther VPN Server, tetapi paket TCP dan UDP diblokir oleh firewall, maka Anda dapat mengenkripsi data ke dalam paket "ICMP" (juga dikenal sebagai Ping) atau "DNS". Fungsi ini memungkinkan koneksi VPN menggunakan ICMP atau DNS bahkan jika firewall atau router memblokir semua koneksi TCP atau UDP. Fungsi VPN melalui ICMP / VPN melalui DNS dirancang agar sesuai dengan spesifikasi standar ICMP dan DNS sebanyak mungkin, namun terkadang memiliki perilaku yang tidak sepenuhnya sesuai dengan standar tersebut. Oleh karena itu, beberapa router berkualitas rendah mungkin mengalami overflow memori atau masalah lainnya saat terlalu banyak paket ICMP atau DNS yang dilewatkan, dan router semacam itu bisa mengalami freeze atau reboot. Hal ini dapat memengaruhi pengguna lain di jaringan yang sama. Untuk menghindari risiko tersebut, tambahkan sufiks "/tcp" pada nama host tujuan yang ditentukan di sisi VPN-klien untuk menonaktifkan fungsi VPN melalui ICMP / DNS.
+
+1.5. Layanan Cloud VPN Azure
+Jika SoftEther VPN Server Anda berada di belakang NAT atau firewall, dan karena suatu alasan Anda tidak dapat menggunakan fungsi NAT Traversal, Dynamic DNS, atau VPN melalui ICMP/DNS, maka Anda dapat menggunakan layanan cloud VPN Azure. SoftEther Corporation mengoperasikan VPN Azure Cloud di Internet. Setelah VPN Server terhubung ke VPN Azure Cloud, nama host "abc.vpnazure.net" ("abc" adalah nama host unik) dapat digunakan untuk menghubungkan ke VPN Server melalui VPN Azure Cloud. Secara praktis, nama host ini mengarah ke alamat IP global salah satu server cloud yang dioperasikan oleh SoftEther Corporation. Jika VPN Client terhubung ke host VPN Azure tersebut, maka host VPN Azure akan meneruskan semua lalu lintas antara VPN Client dan VPN Server. VPN Azure dinonaktifkan secara default. Anda dapat mengaktifkannya dengan mudah menggunakan VPN Server Configuration Tool.
+
+1.6. Percepatan UDP
+SoftEther VPN memiliki Fungsi Percepatan UDP. Jika VPN terdiri dari dua situs dan mendeteksi bahwa saluran UDP dapat dibuat, maka UDP akan digunakan secara otomatis. Dengan fungsi ini, throughput UDP meningkat. Jika saluran UDP langsung dapat dibuat, paket UDP langsung akan digunakan. Namun, jika ada hambatan seperti firewall atau NAT, maka teknologi "UDP Hole Punching" akan digunakan. "UDP Hole Punching" menggunakan server cloud yang dioperasikan oleh SoftEther Corporation di Internet. Percepatan UDP dapat dinonaktifkan kapan saja dengan mengaturnya di sisi VPN-klien.
+
+
+2. Perangkat Lunak VPN
+2.1. SoftEther VPN Client
+Jika Anda menggunakan SoftEther VPN Client di Windows, driver perangkat Virtual Network Adapter akan diinstal pada Windows. Virtual Network Adapter diimplementasikan sebagai driver mode kernel untuk Windows. Driver ini ditandatangani secara digital oleh sertifikat yang diterbitkan oleh VeriSign, Inc. dan juga ditandatangani ulang oleh Symantec Corporation. Pesan yang meminta konfirmasi pemasangan driver mungkin akan muncul di layar. SoftEther VPN Client dapat merespons pesan tersebut jika memungkinkan. SoftEther VPN Client juga mengoptimalkan konfigurasi MMCSS (Multimedia Class Scheduler Service) di Windows. Anda dapat membatalkan optimasi MMCSS setelahnya.
+
+2.2. SoftEther VPN Server / Bridge
+Jika Anda menggunakan SoftEther VPN Server / Bridge di Windows dengan fungsi "Local Bridge", Anda harus menginstal driver pemrosesan paket Ethernet tingkat rendah pada komputer. Driver ini ditandatangani secara digital oleh sertifikat yang diterbitkan oleh VeriSign, Inc. dan juga ditandatangani ulang oleh Symantec Corporation. SoftEther VPN Server / Bridge dapat menonaktifkan fitur offloading TCP/IP pada adaptor jaringan fisik untuk fungsi Local Bridge. Di Windows Vista / 2008 atau versi lebih baru, VPN Server dapat menyuntikkan driver filter paket yang sesuai dengan spesifikasi Windows Filter Platform (WFP) ke dalam kernel untuk menyediakan fungsi IPsec. Driver filter paket ini hanya akan dimuat jika fungsi IPsec diaktifkan. Jika Anda mengaktifkan fungsi IPsec pada SoftEther VPN Server, maka fungsi IPsec bawaan Windows akan dinonaktifkan. Setelah Anda menonaktifkan fungsi IPsec SoftEther VPN Server, maka fungsi IPsec bawaan Windows akan aktif kembali. Untuk menyediakan fungsi Local Bridge, SoftEther VPN Server / Bridge menonaktifkan fungsi offloading TCP/IP pada sistem operasi.
+
+2.3. Instalasi Mode Pengguna
+Anda dapat menginstal SoftEther VPN Server dan SoftEther VPN Bridge sebagai "Mode Pengguna" di Windows. Dengan kata lain, meskipun Anda tidak memiliki hak administrator sistem Windows, Anda dapat menginstal SoftEther VPN sebagai pengguna biasa. Instalasi mode pengguna akan menonaktifkan beberapa fungsi, namun sebagian besar fungsi lainnya tetap berfungsi dengan baik. Oleh karena itu, misalnya, seorang karyawan dapat menginstal SoftEther VPN Server di komputer dalam jaringan kantor dan dapat terhubung ke server dari rumahnya. Untuk mewujudkan sistem seperti itu sendiri, tidak diperlukan hak administratif sistem dari sudut pandang teknis. Namun, melanggar peraturan perusahaan dengan menginstal perangkat lunak pada komputer tanpa izin dapat dianggap sebagai tindakan yang tidak diinginkan. Jika Anda seorang karyawan dan bekerja di sebuah perusahaan, dan kebijakan perusahaan melarang pemasangan perangkat lunak atau melakukan komunikasi ke Internet tanpa izin, Anda harus mendapatkan izin dari administrator jaringan atau pejabat eksekutif perusahaan sebelum menginstal SoftEther VPN. Jika Anda menginstal VPN Server / Bridge dalam Mode Pengguna, ikon akan muncul di task-tray Windows. Jika Anda merasa ikon tersebut mengganggu, Anda dapat menyembunyikannya. Namun, Anda tidak boleh menyalahgunakan fungsi penyembunyian ini untuk menginstal VPN Server di komputer orang lain sebagai spyware. Tindakan seperti itu dapat dianggap sebagai pelanggaran hukum pidana.
+
+2.4. Fungsi Keep Alive
+SoftEther VPN Server dan SoftEther VPN Bridge memiliki Fungsi Keep Alive secara default. Tujuan dari fungsi ini adalah untuk menjaga koneksi Internet tetap aktif. Fungsi ini secara berkala mengirimkan paket UDP dengan payload array-byte-acak. Fungsi ini berguna untuk menghindari pemutusan koneksi otomatis pada koneksi seluler atau dial-up. Anda dapat menonaktifkan Fungsi Keep Alive kapan saja.
+
+2.5. Penghapusan Instalasi
+Proses penghapusan instalasi perangkat lunak SoftEther VPN akan menghapus semua file program. Namun, file non-program (seperti file dan data yang dihasilkan selama penggunaan perangkat lunak) tidak akan dihapus. Secara teknis, file exe dan sumber daya dari uninstaller mungkin masih tersisa. File yang tersisa tersebut tidak akan mempengaruhi penggunaan komputer, tetapi Anda dapat menghapusnya secara manual. Driver mode kernel mungkin tidak akan dihapus, tetapi driver tersebut tidak akan dimuat setelah Windows di-boot ulang. Anda dapat menggunakan perintah "sc" di Windows untuk menghapus driver mode kernel secara manual.
+
+2.6. Keamanan
+Setelah instalasi, Anda harus mengatur kata sandi administrator pada SoftEther VPN Server / Bridge. Jika Anda mengabaikan hal ini, orang lain dapat mengakses SoftEther VPN Server / Bridge dan mengatur kata sandi tanpa izin Anda. Peringatan ini juga berlaku untuk SoftEther VPN Client di Linux.
+
+2.7. Pemberitahuan Pembaruan Otomatis
+Perangkat lunak SoftEther VPN untuk Windows memiliki fungsi pemberitahuan pembaruan otomatis. Perangkat lunak ini secara berkala mengakses server pembaruan SoftEther untuk memeriksa apakah ada versi terbaru yang dirilis. Jika ada versi terbaru, pesan pemberitahuan akan muncul di layar. Untuk mencapai tujuan ini, versi perangkat lunak, pengaturan bahasa, pengenal unik, alamat IP komputer Anda, dan hostname VPN Server yang terhubung akan dikirim ke server pembaruan SoftEther. Tidak ada informasi pribadi yang dikirim. Pemberitahuan pembaruan otomatis diaktifkan secara default, tetapi Anda dapat menonaktifkannya di layar konfigurasi. Pengaturan ini akan disimpan secara individual untuk setiap VPN Server tujuan melalui VPN Server Manager.
+
+2.8. Fungsi NAT Virtual
+Virtual Hub pada SoftEther VPN Server / Bridge memiliki "Fungsi NAT Virtual". Fungsi NAT Virtual memungkinkan berbagi satu alamat IP pada jaringan fisik dengan beberapa alamat IP pribadi dari VPN Client. Ada dua mode operasi Virtual NAT: Mode Pengguna (User-mode) dan Mode Kernel (Kernel-mode). Dalam mode pengguna, NAT Virtual berbagi alamat IP yang ditetapkan pada sistem operasi host. Berbeda dengan mode pengguna, mode kernel mencoba menemukan server DHCP di jaringan fisik. Jika ada dua atau lebih jaringan fisik, server DHCP akan dicari secara otomatis untuk setiap segmen secara berurutan. Jika server DHCP ditemukan dan alamat IP diperoleh, alamat IP tersebut akan digunakan oleh Virtual NAT. Dalam kasus ini, entri IP sebagai klien DHCP akan terdaftar di pool IP server DHCP fisik. Gateway default fisik dan server DNS akan digunakan oleh Virtual NAT untuk berkomunikasi dengan host di Internet. Dalam mode kernel, Virtual Hub memiliki alamat MAC virtual yang beroperasi di segmen Ethernet fisik. Untuk memeriksa konektivitas ke Internet, SoftEther VPN secara berkala mengirimkan paket kueri DNS untuk menyelesaikan alamat IP dari host "www.yahoo.com" atau "www.baidu.com", dan mencoba menghubungkan ke port TCP 80 dari alamat IP yang dihasilkan untuk pemeriksaan konektivitas.
+
+2.9. Instalasi Tanpa Pengawasan untuk Komponen Mode Kernel
+Ketika SoftEther VPN mendeteksi kebutuhan untuk menginstal komponen mode kernel di Windows, pesan konfirmasi akan muncul dari sistem Windows. Dalam situasi ini, perangkat lunak SoftEther VPN akan beralih ke mode Instalasi Tanpa Pengawasan untuk secara otomatis merespons "Ya" pada Windows. Hal ini bertujuan untuk mencegah terjadinya deadlock saat administrasi jarak jauh dilakukan.
+
+2.10. Windows Firewall
+Perangkat lunak SoftEther VPN akan mendaftarkan dirinya sebagai program aman. Entri ini akan tetap ada setelah penghapusan instalasi. Anda dapat menghapusnya secara manual melalui Control Panel Windows.
+
+
+3. Layanan Internet
+3.1. Layanan Internet yang Disediakan oleh SoftEther Corporation
+SoftEther Corporation menyediakan layanan Dynamic DNS, NAT Traversal, dan server VPN Azure di Internet. Layanan ini tersedia secara gratis. Pelanggan dapat mengakses layanan ini menggunakan perangkat lunak SoftEther VPN melalui Internet. Layanan ini direncanakan akan tersedia dalam versi Open-Source dari "SoftEther VPN" yang akan dirilis di masa mendatang.
+
+3.2. Informasi yang Dikirim dan Perlindungan Privasi
+Perangkat lunak SoftEther VPN dapat mengirim alamat IP, nama host, dan versi perangkat lunak VPN pada komputer pelanggan ke layanan cloud yang dioperasikan oleh SoftEther Corporation untuk menggunakan layanan di atas. Pengiriman informasi ini merupakan kebutuhan minimal agar layanan dapat berfungsi. Tidak ada informasi pribadi yang dikirimkan. SoftEther Corporation mencatat log server cloud minimal selama 90 hari dengan informasi yang diterima. Log ini digunakan untuk pemecahan masalah dan aktivitas sah lainnya. SoftEther Corporation dapat memberikan log kepada pegawai pemerintah Jepang yang bekerja di pengadilan, kantor polisi, atau kejaksaan jika diperintahkan oleh otoritas terkait. (Setiap pegawai negeri Jepang secara hukum bertanggung jawab untuk menjaga kerahasiaan informasi tersebut.) Selain itu, alamat IP dan informasi lain akan diproses secara statistik dan disediakan untuk publik tanpa mengungkapkan alamat IP konkret, guna mendukung kegiatan penelitian.
+
+3.3. Data Komunikasi melalui Layanan VPN Azure
+Terlepas dari aturan pada poin 3.2, jika pelanggan mengirim atau menerima paket VPN menggunakan Layanan Cloud VPN Azure, payload aktual akan disimpan dan diteruskan melalui memori volatil server dalam waktu yang sangat singkat. Perilaku ini diperlukan secara teknis untuk menyediakan "layanan relai VPN". Tidak ada payload yang direkam pada penyimpanan tetap seperti hard drive. Namun, "Undang-Undang Penyadapan untuk Prosedur Kriminal" (Undang-Undang ke-137 yang disahkan pada 18 Agustus 1999 di Jepang) mewajibkan perusahaan telekomunikasi untuk mengizinkan otoritas pemerintah Jepang melakukan penyadapan. Server VPN Azure yang secara fisik berlokasi di Jepang tunduk pada hukum ini.
+
+3.4. Kepatuhan terhadap Hukum Telekomunikasi Jepang
+SoftEther Corporation mematuhi hukum telekomunikasi Jepang yang berlaku dalam menyediakan layanan daring melalui Internet.
+
+3.5. Layanan Gratis dan Eksperimen Akademik
+SoftEther menyediakan Dynamic DNS, NAT Traversal, dan VPN Azure sebagai layanan eksperimen akademik. Oleh karena itu, layanan ini dapat digunakan secara gratis. Layanan ini bukan bagian dari "Produk Perangkat Lunak SoftEther VPN". Layanan ini disediakan tanpa jaminan apa pun. Layanan dapat dihentikan atau dihentikan sementara karena alasan teknis atau operasional. Dalam situasi seperti itu, pengguna tidak akan dapat menggunakan layanan tersebut. Pengguna harus memahami dan menerima risiko ini secara mandiri. SoftEther tidak akan bertanggung jawab atas akibat atau kerugian yang timbul akibat penggunaan atau ketidakmampuan menggunakan layanan. Bahkan jika pengguna telah membayar biaya lisensi versi komersial SoftEther VPN, biaya tersebut tidak mencakup layanan ini. Oleh karena itu, jika layanan daring dihentikan, tidak ada pengembalian dana atau kompensasi yang akan diberikan oleh SoftEther Corporation.
+
+3.6. Server Cloud Proxy DNS
+Di beberapa wilayah, ketika pengguna mengakses Internet, permintaan DNS terkadang mengalami gangguan atau hilang saat melewati jalur ISP. Jika SoftEther VPN Server, Client, atau Bridge mendeteksi kemungkinan bahwa akses ke server VPN aktual mungkin tidak stabil, maka permintaan DNS juga akan dialihkan ke server cloud proxy DNS yang dioperasikan oleh SoftEther Corporation. Server cloud proxy DNS akan merespons permintaan DNS dengan memberikan alamat IP yang benar.
+
+
+4. Peringatan Umum
+4.1. Memerlukan Persetujuan dari Administrator Jaringan
+SoftEther VPN memiliki fungsi yang kuat yang tidak memerlukan pengaturan khusus oleh administrator jaringan. Misalnya, Anda tidak perlu meminta administrator untuk mengonfigurasi firewall yang ada agar "membuka" port TCP/UDP. Fitur ini bertujuan untuk mengurangi waktu kerja dan biaya administrator jaringan serta menghindari risiko kesalahan konfigurasi saat membuka port tertentu pada firewall. Namun, setiap karyawan yang bekerja di perusahaan harus mendapatkan persetujuan dari administrator jaringan sebelum menginstal SoftEther VPN. Jika administrator jaringan Anda menolak memberikan persetujuan, Anda dapat mempertimbangkan untuk meminta persetujuan dari otoritas yang lebih tinggi (misalnya, pejabat eksekutif perusahaan). Jika Anda menggunakan SoftEther VPN tanpa persetujuan dari otoritas perusahaan, Anda mungkin mengalami kerugian. SoftEther Corporation tidak akan bertanggung jawab atas hasil atau kerusakan yang ditimbulkan akibat penggunaan SoftEther VPN.
+
+4.2. Patuhi Hukum di Negara Anda
+Jika hukum di negara Anda melarang penggunaan enkripsi, Anda harus menonaktifkan fungsi enkripsi SoftEther VPN sendiri. Demikian pula, di beberapa negara atau wilayah, beberapa fungsi SoftEther VPN mungkin dilarang oleh undang-undang. Hukum negara lain bukan menjadi tanggung jawab SoftEther Corporation karena perusahaan ini terletak dan terdaftar secara fisik di Jepang. Sebagai contoh, ada kemungkinan bahwa sebagian dari SoftEther VPN melanggar paten yang hanya berlaku di wilayah tertentu. SoftEther Corporation tidak memiliki kepentingan di wilayah spesifik di luar Jepang. Oleh karena itu, jika Anda ingin menggunakan SoftEther VPN di luar Jepang, Anda harus berhati-hati agar tidak melanggar hak pihak ketiga. Anda harus memverifikasi legalitas penggunaan SoftEther VPN di wilayah tertentu sebelum menggunakannya. Secara alami, ada hampir 200 negara di dunia, dan setiap negara memiliki hukum yang berbeda. Secara praktis, tidak mungkin untuk memverifikasi hukum dan regulasi di setiap negara serta memastikan perangkat lunak mematuhi semua hukum sebelum dirilis. Oleh karena itu, SoftEther Corporation hanya memverifikasi legalitas SoftEther VPN berdasarkan hukum dan regulasi Jepang. Jika seorang pengguna menggunakan SoftEther VPN di negara tertentu dan mengalami kerugian akibat tindakan pegawai pemerintah setempat, SoftEther Corporation tidak akan bertanggung jawab untuk mengganti atau menanggung kerugian tersebut, termasuk tanggung jawab pidana.
+
+
+5. Proyek Eksperimen Akademik VPN Gate
+(Bab ini hanya berlaku pada paket perangkat lunak SoftEther VPN yang berisi plug-in ekstensi untuk Proyek Eksperimen Akademik VPN Gate.)
+5.1. Tentang Proyek Eksperimen Akademik VPN Gate
+Proyek Eksperimen Akademik VPN Gate adalah layanan online yang dioperasikan hanya untuk tujuan penelitian akademik di sekolah pascasarjana Universitas Tsukuba, Jepang. Tujuan penelitian ini adalah untuk memperluas pengetahuan tentang teknologi "Global Distributed Public VPN Relay Server" (GDPVRS). Untuk detail lebih lanjut, silakan kunjungi http://www.vpngate.net/.
+
+5.2. Tentang Layanan VPN Gate
+Perangkat lunak SoftEther VPN Server dan SoftEther VPN Client mungkin berisi program "VPN Gate Service". Namun, VPN Gate Service dinonaktifkan secara default. 
+VPN Gate Service harus diaktifkan secara sukarela oleh pemilik komputer tempat SoftEther VPN Server atau SoftEther VPN Client diinstal. Setelah VPN Gate Service diaktifkan, komputer tersebut akan mulai berfungsi sebagai bagian dari Global Distributed Public VPN Relay Servers. Alamat IP, nama host, dan informasi terkait komputer akan dikirim dan terdaftar ke server direktori Proyek Eksperimen Akademik VPN Gate, serta akan dipublikasikan ke publik. Mekanisme ini memungkinkan pengguna perangkat lunak VPN Gate Client untuk terhubung ke VPN Gate Service yang berjalan di komputer Anda. Selama sesi VPN antara pengguna VPN Gate Client dan VPN Gate Service berlangsung, pengguna VPN Gate Client dapat mengirim/menerima paket IP melalui layanan ini. Alamat IP global dari komputer yang menjalankan VPN Gate Service akan digunakan sebagai alamat IP sumber dari komunikasi yang dimulai oleh pengguna VPN Gate Client.
+VPN Gate Service akan mengirim beberapa informasi ke Server Direktori Layanan Eksperimen Akademik VPN Gate. Informasi ini mencakup informasi operator yang dijelaskan di bagian 5.5, pengaturan log, waktu aktif, versi sistem operasi, jenis protokol, nomor port, informasi kualitas, informasi statistik, riwayat log VPN Gate Client (termasuk tanggal, alamat IP, nomor versi, dan ID), serta versi perangkat lunak. Informasi ini akan diekspos di direktori publik. VPN Gate Service juga menerima kunci untuk enkripsi yang dijelaskan di bagian 5.9 dari server direktori.
+
+5.3. Rincian Perilaku VPN Gate Service
+Jika Anda mengaktifkan VPN Gate Service secara manual (karena dinonaktifkan secara default), "VPNGATE" Virtual Hub akan dibuat di SoftEther VPN Server. Jika Anda menggunakan SoftEther VPN Client dan mencoba mengaktifkan VPN Gate Service, sebuah program setara dengan SoftEther VPN Server akan dijalankan dalam proses yang sama dengan SoftEther VPN Client, dan "VPNGATE" Virtual Hub akan dibuat. Secara default, "VPNGATE" Virtual Hub berisi pengguna bernama "VPN" yang memungkinkan siapa pun di Internet untuk membuat koneksi VPN ke Virtual Hub tersebut. Setelah VPN Client terhubung ke "VPNGATE" Virtual Hub, semua komunikasi antara pengguna dan Internet akan melewati Virtual Hub dan ditransmisikan/menerima melalui antarmuka jaringan fisik pada komputer yang menjalankan SoftEther VPN Server (atau SoftEther VPN Client). Akibatnya, host tujuan yang ditentukan oleh VPN Client akan mengidentifikasi bahwa sumber komunikasi berasal dari alamat IP komputer yang menjalankan VPN Gate Service. Namun, untuk alasan keamanan, paket yang ditujukan ke alamat dalam rentang 192.168.0.0/255.255.0.0, 172.16.0.0/255.240.0.0, atau 10.0.0.0/255.0.0.0 akan diblokir oleh "VPNGATE" Virtual Hub untuk melindungi jaringan lokal Anda. Oleh karena itu, jika Anda menjalankan VPN Gate Service dalam jaringan perusahaan atau jaringan pribadi, layanan ini tetap aman karena pengguna VPN Client anonim tidak akan diizinkan mengakses jaringan pribadi tersebut. VPN Gate Service juga berfungsi sebagai perantara untuk mengakses Server Direktori VPN Gate.
+Agar VPN Gate Service dapat melewati firewall dan NAT, layanan ini membuka port UDP menggunakan fungsi NAT Traversal yang dijelaskan di bagian 1.2. Selain itu, layanan ini membuka dan mendengarkan beberapa port TCP, serta beberapa port TCP dan UDP akan ditentukan sebagai target port untuk entri Universal Plug and Play (UPnP) Port Transfer yang diminta ke router lokal Anda. Paket permintaan UPnP akan dikirim secara berkala. Beberapa router mungkin mempertahankan port TCP/UDP yang terbuka secara permanen pada perangkat. Jika Anda ingin menutupnya, Anda harus melakukannya secara manual.
+VPN Gate Service juga menyediakan fungsi mirror-site untuk www.vpngate.net. Ini adalah mekanisme di mana salinan konten terbaru dari www.vpngate.net akan dihosting oleh server HTTP kecil yang berjalan di program VPN Gate Service. Layanan ini akan mendaftarkan dirinya ke daftar mirror-site di www.vpngate.net. Namun, layanan ini tidak akan meneruskan komunikasi lain yang tidak ditujukan ke www.vpngate.net.
+
+5.4. Komunikasi antara Internet melalui VPN Gate Service
+VPN Gate Service menyediakan perutean antara pengguna dan Internet dengan menggunakan Fungsi NAT Virtual yang dijelaskan di bagian 2.8. VPN Gate Service mengirimkan paket polling Ping ke server yang berlokasi di Universitas Tsukuba dan ke Google Public DNS Server dengan alamat 8.8.8.8 untuk memeriksa kualitas terbaru dari koneksi Internet Anda. VPN Gate Service juga mengirim dan menerima banyak paket acak dari/ke Speed Test Server di Universitas Tsukuba. Data kualitas ini akan dilaporkan ke VPN Gate Directory Server secara otomatis dan berkala. Hasilnya akan disimpan dan dipublikasikan ke publik. Meskipun komunikasi polling periodik ini disesuaikan agar tidak membebani koneksi Internet, dalam beberapa keadaan komunikasi ini mungkin akan memengaruhi bandwidth Anda.
+
+5.5. Informasi Operator VPN Gate Service
+Jika Anda mengaktifkan VPN Gate Service di komputer Anda, komputer tersebut akan menjadi bagian dari Global Distributed Public VPN Relay Servers. Oleh karena itu, informasi administratif operator dari VPN Gate Service Anda harus dilaporkan dan didaftarkan di VPN Gate Service Directory. Informasi operator mencakup nama operator dan alamat e-mail untuk pelaporan penyalahgunaan. Informasi ini dapat dimasukkan melalui layar konfigurasi VPN Gate. Informasi yang telah dimasukkan akan dikirimkan ke VPN Gate Directory Server, disimpan, dan dipublikasikan ke publik. Oleh karena itu, Anda harus berhati-hati dalam mengisi informasi ini. Jika Anda tidak mengisi informasi operator, nama host komputer Anda akan digunakan secara otomatis sebagai nama operator, dengan menambahkan string "'s owner" setelah nama host.
+
+5.6. Kepatuhan terhadap Hukum dalam Mengoperasikan VPN Gate Service
+Di beberapa negara atau wilayah, pengguna yang berencana untuk mengaktifkan dan mengoperasikan VPN Gate Service mungkin diwajibkan untuk mendapatkan lisensi atau mendaftarkan layanan ke pemerintah. Jika wilayah Anda memiliki peraturan semacam itu, Anda harus menyelesaikan proses perizinan yang diwajibkan sebelum mengaktifkan VPN Gate Service. Baik pengembang maupun operator Proyek Eksperimen Akademik VPN Gate tidak bertanggung jawab atas tanggung jawab hukum/pidana atau kerugian yang timbul akibat kegagalan mematuhi hukum setempat Anda.
+
+5.7. Melindungi Privasi Komunikasi
+Sebagian besar negara memiliki undang-undang yang mengharuskan operator layanan komunikasi, termasuk operator VPN Gate Service, untuk melindungi privasi komunikasi pihak ketiga. Saat Anda mengoperasikan VPN Gate Service, Anda harus selalu melindungi privasi pengguna.
+
+5.8. Log Paket
+Fungsi pencatatan paket (packet logging) diimplementasikan pada VPN Gate Service. Fitur ini merekam header utama dari paket TCP/IP yang dikirim melalui Virtual Hub. Fungsi ini berguna untuk menyelidiki "alamat IP asli" dari pengguna yang terhubung ke VPN Gate Service Anda dengan memeriksa log paket dan log koneksi. Log paket hanya dicatat untuk tujuan penyelidikan yang sah. Jangan mengintip atau membocorkan log paket kecuali untuk tujuan yang benar. Tindakan semacam itu akan melanggar ketentuan pada bagian 5.7.
+
+5.9. Fungsi Pengarsipan dan Pengkodean Otomatis Log Paket
+Layanan Eksperimen Akademik VPN Gate beroperasi di bawah konstitusi dan hukum Jepang. Konstitusi Jepang menuntut perlindungan ketat terhadap privasi komunikasi. Karena layanan ini berada di bawah aturan Jepang, program VPN Gate Service menerapkan mekanisme perlindungan "Pengkodean Otomatis File Log" dan fitur ini diaktifkan secara default.
+Saat ini, VPN Gate Service dikonfigurasi untuk mengkodekan file log paket yang telah melewati dua minggu atau lebih secara otomatis. Untuk melindungi privasi komunikasi, setelah file log paket dikodekan, bahkan administrator komputer lokal tidak dapat mengakses isi file log tersebut. Mekanisme ini bertujuan untuk melindungi privasi pengguna akhir dari VPN Gate Service.
+Anda dapat mengubah pengaturan VPN Gate Service untuk menonaktifkan fungsi pengkodean otomatis ini. Dalam konfigurasi ini, file log paket tidak akan dikodekan meskipun sudah melewati dua minggu. Semua log paket akan tetap tersimpan dalam bentuk teks biasa di disk. Oleh karena itu, Anda harus berhati-hati agar tidak melanggar privasi pengguna.
+Jika Anda memiliki kewajiban untuk mendekode file log paket yang telah dikodekan (misalnya: pengguna VPN Gate Service menyalahgunakan layanan Anda secara ilegal dan Anda perlu mendekode log paket untuk mematuhi hukum), hubungi administrator Layanan Eksperimen Akademik VPN Gate di Sekolah Pascasarjana Universitas Tsukuba, Jepang. Anda dapat menemukan alamat kontak di http://www.vpngate.net/. Administrator VPN Gate Service akan merespons permintaan dekode log paket jika ada permintaan hukum yang sah dari pengadilan atau otoritas yudisial lainnya, sesuai dengan hukum yang berlaku.
+
+5.10. Peringatan Jika Anda Mengoperasikan VPN Gate Service di Wilayah Jepang
+Jika seorang pengguna mengoperasikan VPN Gate Service di wilayah Jepang, tindakan tersebut dapat diatur oleh Hukum Telekomunikasi Jepang jika memenuhi kriteria yang ditentukan oleh hukum. Namun, menurut "Manual Kompetisi Bisnis Telekomunikasi Jepang [versi tambahan]", operasi komunikasi yang tidak bersifat komersial tidak dikategorikan sebagai "bisnis telekomunikasi". Oleh karena itu, operator VPN Gate Service biasa tidak dianggap sebagai "operator bisnis telekomunikasi" dan tidak diwajibkan untuk mendaftar ke pemerintah. Meskipun demikian, kewajiban hukum untuk melindungi privasi komunikasi tetap berlaku. Sebagai kesimpulan, jika Anda mengoperasikan VPN Gate Service di wilayah Jepang, Anda dilarang membocorkan rahasia komunikasi yang dikirim melalui layanan VPN Gate yang Anda operasikan.
+
+5.11. VPN Gate Client
+Jika SoftEther VPN Client memiliki plug-in VPN Gate Client, Anda dapat menggunakannya untuk mendapatkan daftar server VPN Gate Service yang sedang beroperasi di Internet dan membuat koneksi VPN ke server tertentu dalam daftar tersebut.
+VPN Gate Client secara berkala memperbarui daftar layanan VPN Gate terbaru. Harap berhati-hati jika Anda menggunakan jaringan Internet dengan sistem pembayaran per penggunaan.
+Saat Anda memulai perangkat lunak VPN Gate Client, layar yang menanyakan apakah Anda ingin mengaktifkan atau tidak VPN Gate Service akan muncul. Untuk informasi lebih lanjut tentang VPN Gate Service, silakan baca bagian-bagian di atas.
+
+5.12. Peringatan Sebelum Bergabung atau Mengeksploitasi Proyek Eksperimen Akademik VPN Gate
+Layanan Eksperimen Akademik VPN Gate dioperasikan sebagai proyek penelitian di sekolah pascasarjana Universitas Tsukuba, Jepang. Layanan ini tunduk pada hukum Jepang. Hukum negara lain bukan merupakan perhatian atau tanggung jawab kami.
+Secara alami, terdapat hampir 200 negara di dunia dengan hukum yang berbeda-beda. Tidak mungkin untuk memverifikasi hukum dan regulasi setiap negara serta memastikan bahwa perangkat lunak ini sesuai dengan semua hukum di seluruh dunia sebelum dirilis. Jika seorang pengguna menggunakan layanan VPN Gate di suatu negara tertentu dan mengalami kerugian akibat tindakan aparat berwenang di negara tersebut, pengembang layanan maupun perangkat lunak ini tidak akan bertanggung jawab untuk memulihkan atau memberikan kompensasi atas kerugian atau tanggung jawab pidana yang terjadi.
+Dengan menggunakan perangkat lunak dan layanan ini, pengguna harus mematuhi semua hukum dan aturan yang berlaku atas tanggung jawabnya sendiri. Pengguna akan sepenuhnya bertanggung jawab atas segala kerugian dan tanggung jawab yang timbul akibat penggunaan perangkat lunak dan layanan ini, baik di dalam maupun di luar wilayah Jepang.
+Jika Anda tidak setuju atau tidak memahami peringatan di atas, jangan gunakan fungsi apa pun dari Layanan Eksperimen Akademik VPN Gate.
+VPN Gate adalah proyek penelitian yang hanya bertujuan akademik. VPN Gate dikembangkan sebagai plug-in untuk SoftEther VPN dan UT-VPN. Namun, semua bagian dari VPN Gate dikembangkan dalam proyek penelitian ini di Universitas Tsukuba. Tidak ada bagian dari VPN Gate yang dikembangkan oleh SoftEther Corporation. Proyek Penelitian VPN Gate tidak dipimpin, dioperasikan, dipromosikan, atau dijamin oleh SoftEther Corporation.
+
+5.13. Fungsi Relay P2P dalam VPN Gate Client untuk Memperkuat Kemampuan Menghindari Firewall Sensor
+VPN Gate Client yang diterbitkan sejak Januari 2015 menyertakan fungsi Relay P2P. Fungsi Relay P2P diterapkan untuk memperkuat kemampuan menghindari firewall sensor. Jika fungsi Relay P2P di VPN Gate Client Anda diaktifkan, maka fungsi ini akan menerima koneksi VPN masuk dari pengguna VPN Gate yang sebagian besar berada di wilayah yang sama dengan Anda, dan menyediakan fungsi relay ke server VPN Gate eksternal yang di-host oleh pihak ketiga di lingkungan Internet bebas. Fungsi Relay P2P ini tidak menyediakan fungsi NAT bersama maupun menggantikan alamat IP keluar pengguna VPN Gate dengan alamat IP Anda. Fungsi ini hanya menyediakan layanan "refleksi" (hair-pin relaying), yaitu meneruskan koneksi dari pengguna VPN Gate yang masuk ke server VPN Gate eksternal. Dalam situasi ini, terowongan VPN melalui fungsi Relay P2P Anda pada akhirnya akan berakhir di server VPN Gate eksternal, bukan di VPN Gate Client Anda. Namun, server VPN Gate yang menjadi tujuan akhir akan mencatat alamat IP Anda sebagai alamat IP sumber dari terowongan VPN yang dimulai oleh fungsi Relay P2P Anda. Selain itu, paket data pengguna yang dikirim melalui fungsi Relay P2P Anda akan dicatat di komputer Anda sebagai log paket, sebagaimana dijelaskan dalam bagian 5.8. Setelah Anda menginstal VPN Gate Client, dan jika fungsi Relay P2P diaktifkan secara otomatis, maka semua ketentuan dalam bagian 5.2, 5.3, 5.4, 5.5, 5.6, 5.7, 5.8, 5.9, 5.10, 5.11, dan 5.12 akan berlaku bagi Anda dan komputer Anda, sama seperti ketika Anda mengaktifkan VPN Gate Service (fungsi server VPN Gate). Jika fungsi P2P diaktifkan, maka alamat IP komputer Anda dan nama operator default yang dijelaskan dalam bagian 5.5 akan terdaftar dalam daftar server VPN Gate yang disediakan oleh Proyek VPN Gate. Anda dapat mengubah informasi ini dengan mengedit file "vpn_gate_relay.config" secara manual. Perlu dicatat bahwa Anda harus menghentikan layanan VPN Client sebelum mengeditnya. VPN Gate Client akan secara otomatis mengaktifkan fungsi Relay P2P di komputer Anda jika VPN Gate Client mendeteksi bahwa komputer Anda mungkin berada di wilayah yang memiliki firewall sensor. Jika Anda ingin menonaktifkan fungsi Relay P2P, Anda harus mengatur flag "DisableRelayServer" menjadi "true" di file "vpn_client.config", yang merupakan file konfigurasi VPN Client. Perlu dicatat bahwa Anda harus menghentikan layanan VPN Client sebelum mengeditnya. VPN Gate Client tidak mengenali regulasi tertentu di negara atau wilayah Anda. VPN Gate Client akan mengaktifkan fungsi Relay P2P meskipun negara atau wilayah Anda memiliki undang-undang yang membatasi pengoperasian fungsi relay P2P. Oleh karena itu, dalam situasi seperti ini, Anda harus menonaktifkan fungsi Relay P2P di VPN Gate Client secara manual dengan mengatur flag "DisableRelayServer", jika Anda tinggal di wilayah yang memiliki pembatasan semacam itu, atas tanggung jawab Anda sendiri.
+

src/vpncmd/vpncmd.c

@@ -6,7 +6,9 @@
 // VPN Command Line Management Utility
 
 #include "Cedar/Cedar.h"
-
+#ifdef OS_WIN32
+#include "Cedar/CMInner.h"
+#endif
 #include "Cedar/Command.h"
 
 #include "Mayaqua/Internat.h"
@@ -39,6 +41,10 @@ int main(int argc, char *argv[])
 #endif
 	InitCedar();
 
+#ifdef OS_WIN32
+	CmExecUiHelperMain();
+#endif
+
 	s = GetCommandLineUniStr();
 
 	if (s == NULL)

systemd/softether-vpnbridge.service

@@ -4,11 +4,8 @@ After=network.target auditd.service
 ConditionPathExists=!@DIR@/softether/vpnbridge/do_not_run
 
 [Service]
-Type=forking
-EnvironmentFile=-@DIR@/softether/vpnbridge
-ExecStart=@DIR@/softether/vpnbridge/vpnbridge start
-ExecStop=@DIR@/softether/vpnbridge/vpnbridge stop
-KillMode=process
+Type=exec
+ExecStart=@DIR@/softether/vpnbridge/vpnbridge execsvc
 Restart=on-failure
 
 # Hardening

systemd/softether-vpnclient.service

@@ -4,11 +4,8 @@ After=network.target auditd.service
 ConditionPathExists=!@DIR@/softether/vpnclient/do_not_run
 
 [Service]
-Type=forking
-EnvironmentFile=-@DIR@/softether/vpnclient
-ExecStart=@DIR@/softether/vpnclient/vpnclient start
-ExecStop=@DIR@/softether/vpnclient/vpnclient stop
-KillMode=process
+Type=exec
+ExecStart=@DIR@/softether/vpnclient/vpnclient execsvc
 Restart=on-failure
 
 # Hardening

systemd/softether-vpnserver.service

@@ -4,12 +4,9 @@ After=network.target auditd.service
 ConditionPathExists=!@DIR@/softether/vpnserver/do_not_run
 
 [Service]
-Type=forking
+Type=exec
 TasksMax=infinity
-EnvironmentFile=-@DIR@/softether/vpnserver
-ExecStart=@DIR@/softether/vpnserver/vpnserver start
-ExecStop=@DIR@/softether/vpnserver/vpnserver stop
-KillMode=process
+ExecStart=@DIR@/softether/vpnserver/vpnserver execsvc
 Restart=on-failure
 
 # Hardening