feat: add security system with system-wide proxy, DNS protection and encryption
- System-wide proxy: automatic Windows proxy configuration for all apps - DNS leak protection: force all DNS queries through VPN - Config encryption: AES-256-GCM encryption for all config files - File protection: strict access permissions for config directory - Leak detection: built-in security check system - Kill Switch: temporarily disabled (will be improved in next version) Security features: ✓ Automatic system proxy setup ✓ DNS leak protection (optional) ✓ AES-256-GCM config encryption ✓ File and directory protection ✓ Security leak checker ⚠ Kill Switch disabled (caused internet blocking issues) Emergency recovery scripts included: - ОТКЛЮЧИТЬ_KILLSWITCH.bat - EMERGENCY_FIX_INTERNET.bat - ЕСЛИ_СЛОМАЛСЯ_ИНТЕРНЕТ.txt Documentation: - Markdown/SECURITY_GUIDE.md - full security guide - БЕЗОПАСНОСТЬ_БЫСТРЫЙ_СТАРТ.md - quick start guide - CHANGELOG_SECURITY.md - detailed changelog
This commit is contained in:
240
internal/security/dns.go
Normal file
240
internal/security/dns.go
Normal file
@@ -0,0 +1,240 @@
|
||||
package security
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os/exec"
|
||||
"runtime"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// DNSProtection управляет защитой от DNS утечек
|
||||
type DNSProtection struct {
|
||||
originalDNS []string
|
||||
enabled bool
|
||||
}
|
||||
|
||||
// NewDNSProtection создает новый объект защиты DNS
|
||||
func NewDNSProtection() *DNSProtection {
|
||||
return &DNSProtection{
|
||||
originalDNS: []string{},
|
||||
enabled: false,
|
||||
}
|
||||
}
|
||||
|
||||
// Enable включает защиту от DNS утечек
|
||||
func (dp *DNSProtection) Enable(vpnDNS []string) error {
|
||||
if runtime.GOOS != "windows" {
|
||||
return dp.enableUnix(vpnDNS)
|
||||
}
|
||||
return dp.enableWindows(vpnDNS)
|
||||
}
|
||||
|
||||
// Disable отключает защиту и восстанавливает оригинальные DNS
|
||||
func (dp *DNSProtection) Disable() error {
|
||||
if runtime.GOOS != "windows" {
|
||||
return dp.disableUnix()
|
||||
}
|
||||
return dp.disableWindows()
|
||||
}
|
||||
|
||||
// enableWindows включает защиту DNS на Windows
|
||||
func (dp *DNSProtection) enableWindows(vpnDNS []string) error {
|
||||
// Получаем список активных сетевых интерфейсов
|
||||
cmd := exec.Command("netsh", "interface", "show", "interface")
|
||||
output, err := cmd.Output()
|
||||
if err != nil {
|
||||
return fmt.Errorf("ошибка получения списка интерфейсов: %w", err)
|
||||
}
|
||||
|
||||
// Парсим вывод для получения имен интерфейсов
|
||||
lines := strings.Split(string(output), "\n")
|
||||
var activeInterfaces []string
|
||||
|
||||
for _, line := range lines {
|
||||
if strings.Contains(line, "Connected") || strings.Contains(line, "Подключено") {
|
||||
fields := strings.Fields(line)
|
||||
if len(fields) >= 4 {
|
||||
// Имя интерфейса обычно последнее поле
|
||||
interfaceName := strings.Join(fields[3:], " ")
|
||||
activeInterfaces = append(activeInterfaces, interfaceName)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Сохраняем текущие DNS для каждого интерфейса
|
||||
for _, iface := range activeInterfaces {
|
||||
cmd = exec.Command("netsh", "interface", "ip", "show", "dns", iface)
|
||||
output, err := cmd.Output()
|
||||
if err == nil {
|
||||
dp.originalDNS = append(dp.originalDNS, string(output))
|
||||
}
|
||||
}
|
||||
|
||||
// Устанавливаем VPN DNS для всех активных интерфейсов
|
||||
for _, iface := range activeInterfaces {
|
||||
// Устанавливаем первичный DNS
|
||||
if len(vpnDNS) > 0 {
|
||||
cmd = exec.Command("netsh", "interface", "ip", "set", "dns",
|
||||
iface, "static", vpnDNS[0])
|
||||
if err := cmd.Run(); err != nil {
|
||||
fmt.Printf("Предупреждение: не удалось установить DNS для %s: %v\n", iface, err)
|
||||
}
|
||||
}
|
||||
|
||||
// Добавляем вторичные DNS
|
||||
for i := 1; i < len(vpnDNS); i++ {
|
||||
cmd = exec.Command("netsh", "interface", "ip", "add", "dns",
|
||||
iface, vpnDNS[i], fmt.Sprintf("index=%d", i+1))
|
||||
cmd.Run() // Игнорируем ошибки для дополнительных DNS
|
||||
}
|
||||
}
|
||||
|
||||
// Очищаем DNS кэш
|
||||
exec.Command("ipconfig", "/flushdns").Run()
|
||||
|
||||
dp.enabled = true
|
||||
return nil
|
||||
}
|
||||
|
||||
// disableWindows отключает защиту DNS на Windows
|
||||
func (dp *DNSProtection) disableWindows() error {
|
||||
if !dp.enabled {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Получаем список активных интерфейсов
|
||||
cmd := exec.Command("netsh", "interface", "show", "interface")
|
||||
output, err := cmd.Output()
|
||||
if err != nil {
|
||||
return fmt.Errorf("ошибка получения списка интерфейсов: %w", err)
|
||||
}
|
||||
|
||||
lines := strings.Split(string(output), "\n")
|
||||
var activeInterfaces []string
|
||||
|
||||
for _, line := range lines {
|
||||
if strings.Contains(line, "Connected") || strings.Contains(line, "Подключено") {
|
||||
fields := strings.Fields(line)
|
||||
if len(fields) >= 4 {
|
||||
interfaceName := strings.Join(fields[3:], " ")
|
||||
activeInterfaces = append(activeInterfaces, interfaceName)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Восстанавливаем автоматическое получение DNS
|
||||
for _, iface := range activeInterfaces {
|
||||
cmd = exec.Command("netsh", "interface", "ip", "set", "dns",
|
||||
iface, "dhcp")
|
||||
cmd.Run() // Игнорируем ошибки
|
||||
}
|
||||
|
||||
// Очищаем DNS кэш
|
||||
exec.Command("ipconfig", "/flushdns").Run()
|
||||
|
||||
dp.enabled = false
|
||||
dp.originalDNS = []string{}
|
||||
return nil
|
||||
}
|
||||
|
||||
// enableUnix включает защиту DNS на Unix системах
|
||||
func (dp *DNSProtection) enableUnix(vpnDNS []string) error {
|
||||
// Сохраняем оригинальный resolv.conf
|
||||
cmd := exec.Command("cat", "/etc/resolv.conf")
|
||||
output, err := cmd.Output()
|
||||
if err != nil {
|
||||
return fmt.Errorf("ошибка чтения resolv.conf: %w", err)
|
||||
}
|
||||
dp.originalDNS = strings.Split(string(output), "\n")
|
||||
|
||||
// Создаем новый resolv.conf с VPN DNS
|
||||
var newResolv strings.Builder
|
||||
for _, dns := range vpnDNS {
|
||||
newResolv.WriteString(fmt.Sprintf("nameserver %s\n", dns))
|
||||
}
|
||||
|
||||
// Записываем новый resolv.conf
|
||||
cmd = exec.Command("sh", "-c", fmt.Sprintf("echo '%s' > /etc/resolv.conf", newResolv.String()))
|
||||
if err := cmd.Run(); err != nil {
|
||||
return fmt.Errorf("ошибка записи resolv.conf: %w", err)
|
||||
}
|
||||
|
||||
dp.enabled = true
|
||||
return nil
|
||||
}
|
||||
|
||||
// disableUnix отключает защиту DNS на Unix системах
|
||||
func (dp *DNSProtection) disableUnix() error {
|
||||
if !dp.enabled || len(dp.originalDNS) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Восстанавливаем оригинальный resolv.conf
|
||||
content := strings.Join(dp.originalDNS, "\n")
|
||||
cmd := exec.Command("sh", "-c", fmt.Sprintf("echo '%s' > /etc/resolv.conf", content))
|
||||
if err := cmd.Run(); err != nil {
|
||||
return fmt.Errorf("ошибка восстановления resolv.conf: %w", err)
|
||||
}
|
||||
|
||||
dp.enabled = false
|
||||
dp.originalDNS = []string{}
|
||||
return nil
|
||||
}
|
||||
|
||||
// IsEnabled проверяет, включена ли защита DNS
|
||||
func (dp *DNSProtection) IsEnabled() bool {
|
||||
return dp.enabled
|
||||
}
|
||||
|
||||
// GetCurrentDNS возвращает текущие DNS серверы
|
||||
func GetCurrentDNS() ([]string, error) {
|
||||
if runtime.GOOS == "windows" {
|
||||
return getCurrentDNSWindows()
|
||||
}
|
||||
return getCurrentDNSUnix()
|
||||
}
|
||||
|
||||
func getCurrentDNSWindows() ([]string, error) {
|
||||
cmd := exec.Command("nslookup", "localhost")
|
||||
output, err := cmd.Output()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var dnsServers []string
|
||||
lines := strings.Split(string(output), "\n")
|
||||
for _, line := range lines {
|
||||
if strings.Contains(line, "Address:") {
|
||||
parts := strings.Split(line, ":")
|
||||
if len(parts) >= 2 {
|
||||
dns := strings.TrimSpace(parts[1])
|
||||
if dns != "" && dns != "127.0.0.1" {
|
||||
dnsServers = append(dnsServers, dns)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return dnsServers, nil
|
||||
}
|
||||
|
||||
func getCurrentDNSUnix() ([]string, error) {
|
||||
cmd := exec.Command("cat", "/etc/resolv.conf")
|
||||
output, err := cmd.Output()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var dnsServers []string
|
||||
lines := strings.Split(string(output), "\n")
|
||||
for _, line := range lines {
|
||||
if strings.HasPrefix(strings.TrimSpace(line), "nameserver") {
|
||||
parts := strings.Fields(line)
|
||||
if len(parts) >= 2 {
|
||||
dnsServers = append(dnsServers, parts[1])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return dnsServers, nil
|
||||
}
|
||||
212
internal/security/encryption.go
Normal file
212
internal/security/encryption.go
Normal file
@@ -0,0 +1,212 @@
|
||||
package security
|
||||
|
||||
import (
|
||||
"crypto/aes"
|
||||
"crypto/cipher"
|
||||
"crypto/rand"
|
||||
"crypto/sha256"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
|
||||
"golang.org/x/crypto/pbkdf2"
|
||||
)
|
||||
|
||||
const (
|
||||
saltSize = 32
|
||||
iterations = 100000
|
||||
keySize = 32
|
||||
)
|
||||
|
||||
// GetMachineKey генерирует ключ на основе уникальных характеристик машины
|
||||
func GetMachineKey() ([]byte, error) {
|
||||
// Используем hostname и другие системные параметры
|
||||
hostname, err := os.Hostname()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Добавляем путь к исполняемому файлу для уникальности
|
||||
exePath, err := os.Executable()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Комбинируем для создания уникального ключа
|
||||
combined := hostname + exePath
|
||||
hash := sha256.Sum256([]byte(combined))
|
||||
return hash[:], nil
|
||||
}
|
||||
|
||||
// Encrypt шифрует данные с использованием AES-256-GCM
|
||||
func Encrypt(plaintext []byte, password string) (string, error) {
|
||||
// Генерируем соль
|
||||
salt := make([]byte, saltSize)
|
||||
if _, err := io.ReadFull(rand.Reader, salt); err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
// Получаем машинный ключ
|
||||
machineKey, err := GetMachineKey()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
// Комбинируем пароль с машинным ключом
|
||||
combinedPassword := append([]byte(password), machineKey...)
|
||||
|
||||
// Генерируем ключ шифрования
|
||||
key := pbkdf2.Key(combinedPassword, salt, iterations, keySize, sha256.New)
|
||||
|
||||
// Создаем AES cipher
|
||||
block, err := aes.NewCipher(key)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
// Используем GCM для аутентифицированного шифрования
|
||||
gcm, err := cipher.NewGCM(block)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
// Генерируем nonce
|
||||
nonce := make([]byte, gcm.NonceSize())
|
||||
if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
// Шифруем
|
||||
ciphertext := gcm.Seal(nonce, nonce, plaintext, nil)
|
||||
|
||||
// Комбинируем соль и зашифрованные данные
|
||||
result := append(salt, ciphertext...)
|
||||
|
||||
return base64.StdEncoding.EncodeToString(result), nil
|
||||
}
|
||||
|
||||
// Decrypt расшифровывает данные
|
||||
func Decrypt(encryptedData string, password string) ([]byte, error) {
|
||||
// Декодируем из base64
|
||||
data, err := base64.StdEncoding.DecodeString(encryptedData)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if len(data) < saltSize {
|
||||
return nil, fmt.Errorf("неверный формат зашифрованных данных")
|
||||
}
|
||||
|
||||
// Извлекаем соль
|
||||
salt := data[:saltSize]
|
||||
ciphertext := data[saltSize:]
|
||||
|
||||
// Получаем машинный ключ
|
||||
machineKey, err := GetMachineKey()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Комбинируем пароль с машинным ключом
|
||||
combinedPassword := append([]byte(password), machineKey...)
|
||||
|
||||
// Генерируем ключ
|
||||
key := pbkdf2.Key(combinedPassword, salt, iterations, keySize, sha256.New)
|
||||
|
||||
// Создаем AES cipher
|
||||
block, err := aes.NewCipher(key)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Используем GCM
|
||||
gcm, err := cipher.NewGCM(block)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
nonceSize := gcm.NonceSize()
|
||||
if len(ciphertext) < nonceSize {
|
||||
return nil, fmt.Errorf("неверный размер зашифрованных данных")
|
||||
}
|
||||
|
||||
nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]
|
||||
|
||||
// Расшифровываем
|
||||
plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("ошибка расшифровки: неверный пароль или поврежденные данные")
|
||||
}
|
||||
|
||||
return plaintext, nil
|
||||
}
|
||||
|
||||
// SecureDelete безопасно удаляет файл (перезаписывает случайными данными)
|
||||
func SecureDelete(filepath string) error {
|
||||
// Получаем размер файла
|
||||
info, err := os.Stat(filepath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
size := info.Size()
|
||||
|
||||
// Открываем файл для записи
|
||||
file, err := os.OpenFile(filepath, os.O_WRONLY, 0)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer file.Close()
|
||||
|
||||
// Перезаписываем случайными данными 3 раза
|
||||
for i := 0; i < 3; i++ {
|
||||
randomData := make([]byte, size)
|
||||
if _, err := rand.Read(randomData); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if _, err := file.WriteAt(randomData, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if err := file.Sync(); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
// Удаляем файл
|
||||
return os.Remove(filepath)
|
||||
}
|
||||
|
||||
// SetFilePermissions устанавливает строгие права доступа к файлу
|
||||
func SetFilePermissions(path string) error {
|
||||
// Только владелец может читать и писать
|
||||
return os.Chmod(path, 0600)
|
||||
}
|
||||
|
||||
// ProtectDirectory защищает директорию и все файлы в ней
|
||||
func ProtectDirectory(dirPath string) error {
|
||||
// Устанавливаем права на директорию
|
||||
if err := os.Chmod(dirPath, 0700); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Защищаем все файлы в директории
|
||||
entries, err := os.ReadDir(dirPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
for _, entry := range entries {
|
||||
if !entry.IsDir() {
|
||||
filePath := filepath.Join(dirPath, entry.Name())
|
||||
if err := SetFilePermissions(filePath); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
190
internal/security/killswitch.go
Normal file
190
internal/security/killswitch.go
Normal file
@@ -0,0 +1,190 @@
|
||||
package security
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os/exec"
|
||||
"runtime"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// KillSwitch управляет блокировкой интернета при разрыве VPN
|
||||
type KillSwitch struct {
|
||||
enabled bool
|
||||
originalRules []string
|
||||
}
|
||||
|
||||
// NewKillSwitch создает новый Kill Switch
|
||||
func NewKillSwitch() *KillSwitch {
|
||||
return &KillSwitch{
|
||||
enabled: false,
|
||||
originalRules: []string{},
|
||||
}
|
||||
}
|
||||
|
||||
// Enable включает Kill Switch (блокирует весь трафик кроме VPN)
|
||||
func (ks *KillSwitch) Enable(vpnInterface string, allowedIPs []string) error {
|
||||
if runtime.GOOS != "windows" {
|
||||
return ks.enableUnix(vpnInterface, allowedIPs)
|
||||
}
|
||||
return ks.enableWindows(vpnInterface, allowedIPs)
|
||||
}
|
||||
|
||||
// Disable отключает Kill Switch (восстанавливает нормальный трафик)
|
||||
func (ks *KillSwitch) Disable() error {
|
||||
if runtime.GOOS != "windows" {
|
||||
return ks.disableUnix()
|
||||
}
|
||||
return ks.disableWindows()
|
||||
}
|
||||
|
||||
// enableWindows включает Kill Switch на Windows через Windows Firewall
|
||||
func (ks *KillSwitch) enableWindows(vpnInterface string, allowedIPs []string) error {
|
||||
// Создаем правило блокировки всего исходящего трафика
|
||||
cmd := exec.Command("netsh", "advfirewall", "firewall", "add", "rule",
|
||||
"name=VPN_KillSwitch_Block_Out",
|
||||
"dir=out",
|
||||
"action=block",
|
||||
"enable=yes")
|
||||
|
||||
if err := cmd.Run(); err != nil {
|
||||
return fmt.Errorf("ошибка создания правила блокировки: %w", err)
|
||||
}
|
||||
|
||||
// Создаем правило блокировки всего входящего трафика
|
||||
cmd = exec.Command("netsh", "advfirewall", "firewall", "add", "rule",
|
||||
"name=VPN_KillSwitch_Block_In",
|
||||
"dir=in",
|
||||
"action=block",
|
||||
"enable=yes")
|
||||
|
||||
if err := cmd.Run(); err != nil {
|
||||
return fmt.Errorf("ошибка создания правила блокировки: %w", err)
|
||||
}
|
||||
|
||||
// Разрешаем локальный трафик (127.0.0.1)
|
||||
cmd = exec.Command("netsh", "advfirewall", "firewall", "add", "rule",
|
||||
"name=VPN_KillSwitch_Allow_Localhost",
|
||||
"dir=out",
|
||||
"action=allow",
|
||||
"remoteip=127.0.0.1",
|
||||
"enable=yes")
|
||||
|
||||
cmd.Run() // Игнорируем ошибку
|
||||
|
||||
// Разрешаем трафик к VPN серверам
|
||||
for _, ip := range allowedIPs {
|
||||
cmd = exec.Command("netsh", "advfirewall", "firewall", "add", "rule",
|
||||
fmt.Sprintf("name=VPN_KillSwitch_Allow_%s", strings.ReplaceAll(ip, ".", "_")),
|
||||
"dir=out",
|
||||
"action=allow",
|
||||
fmt.Sprintf("remoteip=%s", ip),
|
||||
"enable=yes")
|
||||
|
||||
cmd.Run() // Игнорируем ошибки для отдельных IP
|
||||
}
|
||||
|
||||
ks.enabled = true
|
||||
return nil
|
||||
}
|
||||
|
||||
// disableWindows отключает Kill Switch на Windows
|
||||
func (ks *KillSwitch) disableWindows() error {
|
||||
if !ks.enabled {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Удаляем все правила Kill Switch
|
||||
rules := []string{
|
||||
"VPN_KillSwitch_Block_Out",
|
||||
"VPN_KillSwitch_Block_In",
|
||||
"VPN_KillSwitch_Allow_Localhost",
|
||||
}
|
||||
|
||||
for _, rule := range rules {
|
||||
cmd := exec.Command("netsh", "advfirewall", "firewall", "delete", "rule",
|
||||
fmt.Sprintf("name=%s", rule))
|
||||
cmd.Run() // Игнорируем ошибки
|
||||
}
|
||||
|
||||
// Удаляем правила для разрешенных IP (пытаемся удалить все возможные)
|
||||
// Получаем список всех правил с префиксом VPN_KillSwitch_Allow_
|
||||
listCmd := exec.Command("netsh", "advfirewall", "firewall", "show", "rule", "name=all")
|
||||
output, _ := listCmd.Output()
|
||||
|
||||
lines := strings.Split(string(output), "\n")
|
||||
for _, line := range lines {
|
||||
if strings.Contains(line, "VPN_KillSwitch_Allow_") {
|
||||
parts := strings.Split(line, ":")
|
||||
if len(parts) >= 2 {
|
||||
ruleName := strings.TrimSpace(parts[1])
|
||||
deleteCmd := exec.Command("netsh", "advfirewall", "firewall", "delete", "rule",
|
||||
fmt.Sprintf("name=%s", ruleName))
|
||||
deleteCmd.Run()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ks.enabled = false
|
||||
return nil
|
||||
}
|
||||
|
||||
// enableUnix включает Kill Switch на Unix системах через iptables
|
||||
func (ks *KillSwitch) enableUnix(vpnInterface string, allowedIPs []string) error {
|
||||
// Сохраняем текущие правила
|
||||
cmd := exec.Command("iptables-save")
|
||||
output, err := cmd.Output()
|
||||
if err != nil {
|
||||
return fmt.Errorf("ошибка сохранения правил iptables: %w", err)
|
||||
}
|
||||
ks.originalRules = strings.Split(string(output), "\n")
|
||||
|
||||
// Блокируем весь исходящий трафик по умолчанию
|
||||
cmd = exec.Command("iptables", "-P", "OUTPUT", "DROP")
|
||||
if err := cmd.Run(); err != nil {
|
||||
return fmt.Errorf("ошибка установки политики OUTPUT: %w", err)
|
||||
}
|
||||
|
||||
// Разрешаем локальный трафик
|
||||
cmd = exec.Command("iptables", "-A", "OUTPUT", "-o", "lo", "-j", "ACCEPT")
|
||||
cmd.Run()
|
||||
|
||||
// Разрешаем трафик через VPN интерфейс
|
||||
if vpnInterface != "" {
|
||||
cmd = exec.Command("iptables", "-A", "OUTPUT", "-o", vpnInterface, "-j", "ACCEPT")
|
||||
cmd.Run()
|
||||
}
|
||||
|
||||
// Разрешаем трафик к VPN серверам
|
||||
for _, ip := range allowedIPs {
|
||||
cmd = exec.Command("iptables", "-A", "OUTPUT", "-d", ip, "-j", "ACCEPT")
|
||||
cmd.Run()
|
||||
}
|
||||
|
||||
ks.enabled = true
|
||||
return nil
|
||||
}
|
||||
|
||||
// disableUnix отключает Kill Switch на Unix системах
|
||||
func (ks *KillSwitch) disableUnix() error {
|
||||
if !ks.enabled {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Восстанавливаем политику по умолчанию
|
||||
cmd := exec.Command("iptables", "-P", "OUTPUT", "ACCEPT")
|
||||
if err := cmd.Run(); err != nil {
|
||||
return fmt.Errorf("ошибка восстановления политики: %w", err)
|
||||
}
|
||||
|
||||
// Очищаем цепочку OUTPUT
|
||||
cmd = exec.Command("iptables", "-F", "OUTPUT")
|
||||
cmd.Run()
|
||||
|
||||
ks.enabled = false
|
||||
return nil
|
||||
}
|
||||
|
||||
// IsEnabled проверяет, включен ли Kill Switch
|
||||
func (ks *KillSwitch) IsEnabled() bool {
|
||||
return ks.enabled
|
||||
}
|
||||
237
internal/security/manager.go
Normal file
237
internal/security/manager.go
Normal file
@@ -0,0 +1,237 @@
|
||||
package security
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
)
|
||||
|
||||
// SecurityManager управляет всеми аспектами безопасности VPN
|
||||
type SecurityManager struct {
|
||||
killSwitch *KillSwitch
|
||||
dnsProtection *DNSProtection
|
||||
configDir string
|
||||
password string
|
||||
}
|
||||
|
||||
// SecurityConfig хранит настройки безопасности
|
||||
type SecurityConfig struct {
|
||||
KillSwitchEnabled bool `json:"kill_switch_enabled"`
|
||||
DNSProtectionEnabled bool `json:"dns_protection_enabled"`
|
||||
EncryptionEnabled bool `json:"encryption_enabled"`
|
||||
VPNDNSServers []string `json:"vpn_dns_servers"`
|
||||
AllowedVPNIPs []string `json:"allowed_vpn_ips"`
|
||||
}
|
||||
|
||||
// NewSecurityManager создает новый менеджер безопасности
|
||||
func NewSecurityManager(configDir string, password string) *SecurityManager {
|
||||
return &SecurityManager{
|
||||
killSwitch: NewKillSwitch(),
|
||||
dnsProtection: NewDNSProtection(),
|
||||
configDir: configDir,
|
||||
password: password,
|
||||
}
|
||||
}
|
||||
|
||||
// LoadSecurityConfig загружает конфигурацию безопасности
|
||||
func (sm *SecurityManager) LoadSecurityConfig() (*SecurityConfig, error) {
|
||||
configPath := filepath.Join(sm.configDir, "security.json")
|
||||
|
||||
// Если файл не существует, создаем дефолтную конфигурацию с ОТКЛЮЧЕННЫМ Kill Switch
|
||||
if _, err := os.Stat(configPath); os.IsNotExist(err) {
|
||||
defaultConfig := &SecurityConfig{
|
||||
KillSwitchEnabled: false, // ОТКЛЮЧЕНО ПО УМОЛЧАНИЮ!
|
||||
DNSProtectionEnabled: true,
|
||||
EncryptionEnabled: true,
|
||||
VPNDNSServers: []string{"1.1.1.1", "8.8.8.8"},
|
||||
AllowedVPNIPs: []string{},
|
||||
}
|
||||
sm.SaveSecurityConfig(defaultConfig)
|
||||
return defaultConfig, nil
|
||||
}
|
||||
|
||||
data, err := os.ReadFile(configPath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("ошибка чтения конфигурации безопасности: %w", err)
|
||||
}
|
||||
|
||||
var config SecurityConfig
|
||||
if err := json.Unmarshal(data, &config); err != nil {
|
||||
return nil, fmt.Errorf("ошибка парсинга конфигурации: %w", err)
|
||||
}
|
||||
|
||||
return &config, nil
|
||||
}
|
||||
|
||||
// SaveSecurityConfig сохраняет конфигурацию безопасности
|
||||
func (sm *SecurityManager) SaveSecurityConfig(config *SecurityConfig) error {
|
||||
configPath := filepath.Join(sm.configDir, "security.json")
|
||||
|
||||
data, err := json.MarshalIndent(config, "", " ")
|
||||
if err != nil {
|
||||
return fmt.Errorf("ошибка сериализации конфигурации: %w", err)
|
||||
}
|
||||
|
||||
if err := os.WriteFile(configPath, data, 0600); err != nil {
|
||||
return fmt.Errorf("ошибка сохранения конфигурации: %w", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// EnableProtection включает все защитные механизмы
|
||||
func (sm *SecurityManager) EnableProtection(vpnInterface string, vpnServerIP string) error {
|
||||
config, err := sm.LoadSecurityConfig()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// KILL SWITCH ПОЛНОСТЬЮ ОТКЛЮЧЕН - НЕ ИСПОЛЬЗУЕТСЯ!
|
||||
// Оставляем только защиту DNS
|
||||
|
||||
// Включаем защиту DNS
|
||||
if config.DNSProtectionEnabled {
|
||||
if err := sm.dnsProtection.Enable(config.VPNDNSServers); err != nil {
|
||||
fmt.Printf("⚠ Предупреждение: не удалось включить защиту DNS: %v\n", err)
|
||||
} else {
|
||||
fmt.Println("✓ Защита DNS включена (предотвращение DNS утечек)")
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// DisableProtection отключает все защитные механизмы
|
||||
func (sm *SecurityManager) DisableProtection() error {
|
||||
var errors []error
|
||||
|
||||
// KILL SWITCH НЕ ИСПОЛЬЗУЕТСЯ - пропускаем
|
||||
|
||||
// Отключаем защиту DNS
|
||||
if sm.dnsProtection.IsEnabled() {
|
||||
if err := sm.dnsProtection.Disable(); err != nil {
|
||||
errors = append(errors, fmt.Errorf("ошибка отключения защиты DNS: %w", err))
|
||||
} else {
|
||||
fmt.Println("✓ Защита DNS отключена")
|
||||
}
|
||||
}
|
||||
|
||||
if len(errors) > 0 {
|
||||
return fmt.Errorf("ошибки при отключении защиты: %v", errors)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// EncryptConfigFile шифрует файл конфигурации
|
||||
func (sm *SecurityManager) EncryptConfigFile(filePath string) error {
|
||||
// Читаем файл
|
||||
data, err := os.ReadFile(filePath)
|
||||
if err != nil {
|
||||
return fmt.Errorf("ошибка чтения файла: %w", err)
|
||||
}
|
||||
|
||||
// Шифруем
|
||||
encrypted, err := Encrypt(data, sm.password)
|
||||
if err != nil {
|
||||
return fmt.Errorf("ошибка шифрования: %w", err)
|
||||
}
|
||||
|
||||
// Сохраняем зашифрованный файл
|
||||
encryptedPath := filePath + ".encrypted"
|
||||
if err := os.WriteFile(encryptedPath, []byte(encrypted), 0600); err != nil {
|
||||
return fmt.Errorf("ошибка сохранения зашифрованного файла: %w", err)
|
||||
}
|
||||
|
||||
// Безопасно удаляем оригинальный файл
|
||||
if err := SecureDelete(filePath); err != nil {
|
||||
return fmt.Errorf("ошибка удаления оригинального файла: %w", err)
|
||||
}
|
||||
|
||||
// Переименовываем зашифрованный файл
|
||||
if err := os.Rename(encryptedPath, filePath); err != nil {
|
||||
return fmt.Errorf("ошибка переименования файла: %w", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// DecryptConfigFile расшифровывает файл конфигурации
|
||||
func (sm *SecurityManager) DecryptConfigFile(filePath string) ([]byte, error) {
|
||||
// Читаем зашифрованный файл
|
||||
encryptedData, err := os.ReadFile(filePath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("ошибка чтения файла: %w", err)
|
||||
}
|
||||
|
||||
// Расшифровываем
|
||||
decrypted, err := Decrypt(string(encryptedData), sm.password)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("ошибка расшифровки: %w", err)
|
||||
}
|
||||
|
||||
return decrypted, nil
|
||||
}
|
||||
|
||||
// ProtectConfigDirectory защищает директорию с конфигурациями
|
||||
func (sm *SecurityManager) ProtectConfigDirectory() error {
|
||||
if err := ProtectDirectory(sm.configDir); err != nil {
|
||||
return fmt.Errorf("ошибка защиты директории: %w", err)
|
||||
}
|
||||
|
||||
fmt.Printf("✓ Директория конфигураций защищена: %s\n", sm.configDir)
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetSecurityStatus возвращает текущий статус безопасности
|
||||
func (sm *SecurityManager) GetSecurityStatus() map[string]interface{} {
|
||||
config, _ := sm.LoadSecurityConfig()
|
||||
|
||||
currentDNS, _ := GetCurrentDNS()
|
||||
|
||||
return map[string]interface{}{
|
||||
"kill_switch_enabled": sm.killSwitch.IsEnabled(),
|
||||
"dns_protection_enabled": sm.dnsProtection.IsEnabled(),
|
||||
"encryption_enabled": config.EncryptionEnabled,
|
||||
"current_dns_servers": currentDNS,
|
||||
"configured_vpn_dns": config.VPNDNSServers,
|
||||
"config_dir_protected": true,
|
||||
}
|
||||
}
|
||||
|
||||
// CheckForLeaks проверяет наличие утечек
|
||||
func (sm *SecurityManager) CheckForLeaks() ([]string, error) {
|
||||
var leaks []string
|
||||
|
||||
// Проверяем DNS утечки
|
||||
currentDNS, err := GetCurrentDNS()
|
||||
if err == nil {
|
||||
config, _ := sm.LoadSecurityConfig()
|
||||
if config.DNSProtectionEnabled {
|
||||
// Проверяем, что используются только VPN DNS
|
||||
for _, dns := range currentDNS {
|
||||
isVPNDNS := false
|
||||
for _, vpnDNS := range config.VPNDNSServers {
|
||||
if dns == vpnDNS {
|
||||
isVPNDNS = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !isVPNDNS {
|
||||
leaks = append(leaks, fmt.Sprintf("DNS утечка: используется %s вместо VPN DNS", dns))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Проверяем Kill Switch
|
||||
if !sm.killSwitch.IsEnabled() {
|
||||
config, _ := sm.LoadSecurityConfig()
|
||||
if config.KillSwitchEnabled {
|
||||
leaks = append(leaks, "Kill Switch не активен, возможна утечка трафика при разрыве VPN")
|
||||
}
|
||||
}
|
||||
|
||||
return leaks, nil
|
||||
}
|
||||
Reference in New Issue
Block a user