diff --git a/Linguard/Cli.Test/AddInterfaceCommandShould.cs b/Linguard/Cli.Test/AddInterfaceCommandShould.cs
index 90a8438..9b3109d 100644
--- a/Linguard/Cli.Test/AddInterfaceCommandShould.cs
+++ b/Linguard/Cli.Test/AddInterfaceCommandShould.cs
@@ -1,6 +1,4 @@
-using System.Linq;
-using System.Net.NetworkInformation;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using Castle.Core.Internal;
 using Core.Test.Mocks;
 using FluentAssertions;
diff --git a/Linguard/Core.Test/ClientShould.cs b/Linguard/Core.Test/ClientShould.cs
index 608976e..50c0305 100644
--- a/Linguard/Core.Test/ClientShould.cs
+++ b/Linguard/Core.Test/ClientShould.cs
@@ -13,7 +13,9 @@ namespace Core.Test;
 
 public class ClientShould {
     private static readonly Mock<IConfigurationManager> ConfigurationManagerMock = new DefaultConfigurationManager();
-    private static IWireguardService WireguardService => new WireguardService(ConfigurationManagerMock.Object, new CommandRunner());
+    private static IWireguardService WireguardService => 
+        new WireguardService(ConfigurationManagerMock.Object, new CommandRunner(), 
+        new InterfaceService(ConfigurationManagerMock.Object, new CommandRunner()));
     [Fact]
     public void CreateValidWireguardConfig() {
         
diff --git a/Linguard/Core.Test/InterfaceShould.cs b/Linguard/Core.Test/InterfaceShould.cs
index 1ab3d85..7e5fb63 100644
--- a/Linguard/Core.Test/InterfaceShould.cs
+++ b/Linguard/Core.Test/InterfaceShould.cs
@@ -15,7 +15,9 @@ namespace Core.Test;
 
 public class InterfaceShould {
     private static readonly Mock<IConfigurationManager> ConfigurationManagerMock = new DefaultConfigurationManager();
-    private static IWireguardService WireguardService => new WireguardService(ConfigurationManagerMock.Object, new CommandRunner());
+    private static IWireguardService WireguardService => 
+        new WireguardService(ConfigurationManagerMock.Object, new CommandRunner(), 
+            new InterfaceService(ConfigurationManagerMock.Object, new CommandRunner()));
 
     [Fact]
     public void CreateValidWireguardConfiguration() {
diff --git a/Linguard/Core.Test/Mocks/NetworkInterfaceMock.cs b/Linguard/Core.Test/Mocks/NetworkInterfaceMock.cs
index 8dfdb3c..06dcab7 100644
--- a/Linguard/Core.Test/Mocks/NetworkInterfaceMock.cs
+++ b/Linguard/Core.Test/Mocks/NetworkInterfaceMock.cs
@@ -1,10 +1,17 @@
 using System.Net.NetworkInformation;
+using Bogus;
 using Moq;
 
 namespace Core.Test.Mocks; 
 
 public class NetworkInterfaceMock : Mock<NetworkInterface> {
-    public NetworkInterfaceMock(string name) {
+    public NetworkInterfaceMock(string name, OperationalStatus status = OperationalStatus.Unknown) {
         SetupGet(i => i.Name).Returns(name);
+        SetupGet(i => i.OperationalStatus).Returns(status);
+        var properties = new Mock<IPInterfaceProperties>();
+        properties.SetupGet(o => o.UnicastAddresses)
+            .Returns(new Mock<UnicastIPAddressInformationCollection>().Object);
+        Setup(o => o.GetIPProperties()).Returns(properties.Object);
+        Setup(o => o.GetPhysicalAddress()).Returns(new PhysicalAddress(new Faker().Random.Bytes(6)));
     }
 }
\ No newline at end of file
diff --git a/Linguard/Core.Test/YamlConfigurationSerializerShould.cs b/Linguard/Core.Test/YamlConfigurationSerializerShould.cs
index 090e1c2..9b1b55b 100644
--- a/Linguard/Core.Test/YamlConfigurationSerializerShould.cs
+++ b/Linguard/Core.Test/YamlConfigurationSerializerShould.cs
@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Net.NetworkInformation;
 using Core.Test.Mocks;
 using FluentAssertions;
 using Linguard.Core;
@@ -10,7 +8,6 @@
 using Linguard.Core.Models;
 using Linguard.Core.Models.Wireguard;
 using Linguard.Log;
-using Moq;
 using Xunit;
 
 namespace Core.Test; 
diff --git a/Linguard/Core/Configuration/Serialization/DefaultYamlConfigurationSerializer.cs b/Linguard/Core/Configuration/Serialization/DefaultYamlConfigurationSerializer.cs
index e93e8a2..43457cf 100644
--- a/Linguard/Core/Configuration/Serialization/DefaultYamlConfigurationSerializer.cs
+++ b/Linguard/Core/Configuration/Serialization/DefaultYamlConfigurationSerializer.cs
@@ -1,6 +1,4 @@
 using Linguard.Core.Drivers.TrafficStorage;
-using YamlDotNet.Core;
-using YamlDotNet.Serialization;
 using YamlDotNet.Serialization.NamingConventions;
 
 namespace Linguard.Core.Configuration.Serialization; 
diff --git a/Linguard/Core/Services/DefaultClientGenerator.cs b/Linguard/Core/Services/DefaultClientGenerator.cs
index 1cbb7a3..2feac8e 100644
--- a/Linguard/Core/Services/DefaultClientGenerator.cs
+++ b/Linguard/Core/Services/DefaultClientGenerator.cs
@@ -19,6 +19,14 @@ public DefaultClientGenerator(IWireguardService wireguard, IConfigurationManager
 
     public Client Generate(Interface iface) {
         return new Faker<Client>()
+            .RuleFor(c => c.Id, () => {
+                var clients = Configuration.Interfaces.SelectMany(i => i.Clients).ToList();
+                Guid id = default;
+                while (id == default || clients.Any(c => c.Id == id)) {
+                    id = Guid.NewGuid();
+                }
+                return id;
+            })
             .RuleFor(c => c.Nat, false)
             .RuleFor(c => c.Description, f => f.Lorem.Sentence())
             .RuleFor(c => c.Name, f => f.Person.FullName)
diff --git a/Linguard/Core/Services/DefaultInterfaceGenerator.cs b/Linguard/Core/Services/DefaultInterfaceGenerator.cs
index b625dbb..8920c5b 100644
--- a/Linguard/Core/Services/DefaultInterfaceGenerator.cs
+++ b/Linguard/Core/Services/DefaultInterfaceGenerator.cs
@@ -20,6 +20,13 @@ public DefaultInterfaceGenerator(IConfigurationManager configurationManager, IWi
 
     public Interface Generate() {
         return new Faker<Interface>()
+            .RuleFor(i => i.Id, () => {
+                Guid id = default;
+                while (id == default || Configuration.Interfaces.Any(iface => iface.Id == id)) {
+                    id = Guid.NewGuid();
+                }
+                return id;
+            })
             .RuleFor(i => i.Auto, true)
             .RuleFor(i => i.Description, f => f.Lorem.Sentence())
             .RuleFor(i => i.Gateway, f => {
diff --git a/Linguard/Core/Services/IInterfaceService.cs b/Linguard/Core/Services/IInterfaceService.cs
new file mode 100644
index 0000000..c15917c
--- /dev/null
+++ b/Linguard/Core/Services/IInterfaceService.cs
@@ -0,0 +1,13 @@
+using System.Net.NetworkInformation;
+using Linguard.Core.Models.Wireguard;
+
+namespace Linguard.Core.Services; 
+
+public interface IInterfaceService {
+    IEnumerable<NetworkInterface> NetworkInterfaces { get; }
+    Interface? GetInterface(Client client);
+    bool IsInterfaceUp(Interface iface);
+    bool IsInterfaceDown(Interface iface);
+    void StartInterface(Interface @interface);
+    void StopInterface(Interface @interface);
+}
\ No newline at end of file
diff --git a/Linguard/Core/Services/IWireguardService.cs b/Linguard/Core/Services/IWireguardService.cs
index f6b6481..8f137d9 100644
--- a/Linguard/Core/Services/IWireguardService.cs
+++ b/Linguard/Core/Services/IWireguardService.cs
@@ -5,11 +5,6 @@
 namespace Linguard.Core.Services; 
 
 public interface IWireguardService {
-    Interface? GetInterface(Client client);
-    bool IsInterfaceUp(Interface iface);
-    bool IsInterfaceDown(Interface iface);
-    void StartInterface(Interface @interface);
-    void StopInterface(Interface @interface);
     string? GenerateWireguardPrivateKey();
     string? GenerateWireguardPublicKey(string privateKey);
     string[] GenerateOnUpRules(string interfaceName, NetworkInterface gateway);
diff --git a/Linguard/Core/Services/InterfaceService.cs b/Linguard/Core/Services/InterfaceService.cs
new file mode 100644
index 0000000..309ff58
--- /dev/null
+++ b/Linguard/Core/Services/InterfaceService.cs
@@ -0,0 +1,47 @@
+using System.Net.NetworkInformation;
+using Linguard.Core.Configuration;
+using Linguard.Core.Managers;
+using Linguard.Core.Models.Wireguard;
+using Linguard.Core.OS;
+using Linguard.Core.Services.Exceptions;
+
+namespace Linguard.Core.Services; 
+
+public class InterfaceService : IInterfaceService {
+    
+    private readonly IConfigurationManager _configurationManager;
+    private readonly ICommandRunner _commandRunner;
+    
+    public InterfaceService(IConfigurationManager configurationManager, ICommandRunner commandRunner) {
+        _configurationManager = configurationManager;
+        _commandRunner = commandRunner;
+    }
+
+    private IWireguardConfiguration Configuration => _configurationManager.Configuration.Wireguard;
+
+    public IEnumerable<NetworkInterface> NetworkInterfaces => NetworkInterface.GetAllNetworkInterfaces();
+
+    public Interface? GetInterface(Client client) => Configuration.Interfaces
+        .SingleOrDefault(i => i.Clients.Contains(client));
+
+    public bool IsInterfaceUp(Interface iface) {
+        return NetworkInterfaces
+            .Any(i => i.Name.Equals(iface.Name) && i.OperationalStatus == OperationalStatus.Up);
+    }
+
+    public bool IsInterfaceDown(Interface iface) {
+        return !IsInterfaceUp(iface);
+    }
+    
+    public void StartInterface(Interface @interface) {
+        var result = _commandRunner
+            .Run($"sudo {Configuration.WireguardQuickBin} up {@interface.Name}");
+        if (!result.Success) throw new WireguardException(result.Stderr);
+    }
+
+    public void StopInterface(Interface @interface) {
+        var result = _commandRunner
+            .Run($"sudo {Configuration.WireguardQuickBin} down {@interface.Name}");
+        if (!result.Success) throw new WireguardException(result.Stderr);
+    }
+}
\ No newline at end of file
diff --git a/Linguard/Core/Services/WireguardService.cs b/Linguard/Core/Services/WireguardService.cs
index e3c3294..46f06d3 100644
--- a/Linguard/Core/Services/WireguardService.cs
+++ b/Linguard/Core/Services/WireguardService.cs
@@ -13,38 +13,17 @@ namespace Linguard.Core.Services;
 public class WireguardService : IWireguardService {
     private readonly IConfigurationManager _configurationManager;
     private readonly ICommandRunner _commandRunner;
-    
-    public WireguardService(IConfigurationManager configurationManager, ICommandRunner commandRunner) {
+    private readonly IInterfaceService _interfaceService;
+
+    public WireguardService(IConfigurationManager configurationManager, ICommandRunner commandRunner,
+        IInterfaceService interfaceService) {
         _configurationManager = configurationManager;
         _commandRunner = commandRunner;
+        _interfaceService = interfaceService;
     }
 
     private IWireguardConfiguration Configuration => _configurationManager.Configuration.Wireguard;
 
-    public Interface? GetInterface(Client client) => Configuration.Interfaces
-        .SingleOrDefault(i => i.Clients.Contains(client));
-
-    public bool IsInterfaceUp(Interface iface) {
-        return NetworkInterface.GetAllNetworkInterfaces()
-            .Any(i => i.Name.Equals(iface.Name) && i.OperationalStatus == OperationalStatus.Up);
-    }
-
-    public bool IsInterfaceDown(Interface iface) {
-        return !IsInterfaceUp(iface);
-    }
-    
-    public void StartInterface(Interface @interface) {
-        var result = _commandRunner
-            .Run($"sudo {Configuration.WireguardQuickBin} up {@interface.Name}");
-        if (!result.Success) throw new WireguardException(result.Stderr);
-    }
-
-    public void StopInterface(Interface @interface) {
-        var result = _commandRunner
-            .Run($"sudo {Configuration.WireguardQuickBin} down {@interface.Name}");
-        if (!result.Success) throw new WireguardException(result.Stderr);
-    }
-
     public string? GenerateWireguardPrivateKey() {
         var result = _commandRunner
             .Run($"sudo {Configuration.WireguardBin} genkey");
@@ -87,7 +66,7 @@ public string GenerateWireguardConfiguration(IWireguardPeer peer) {
 
     public DateTime GetLastHandshake(Client client) {
         var rawData = _commandRunner
-            .Run($"{Configuration.WireguardBin} show {GetInterface(client).Name} dump")
+            .Run($"{Configuration.WireguardBin} show {_interfaceService.GetInterface(client).Name} dump")
             .Stdout;
         try {
             return WireguardDumpParser.GetLastHandshake(rawData, client);
@@ -106,7 +85,7 @@ public IEnumerable<TrafficData> GetTrafficData() {
     }
     
     public TrafficData? GetTrafficData(Client client) {
-        var data = GetTrafficData(GetInterface(client));
+        var data = GetTrafficData(_interfaceService.GetInterface(client));
         return data.SingleOrDefault(e => e.Peer.Equals(client));
     }
 
diff --git a/Linguard/Web/Pages/EditInterface.razor b/Linguard/Web/Pages/EditInterface.razor
index 6ab227c..7ae0a32 100644
--- a/Linguard/Web/Pages/EditInterface.razor
+++ b/Linguard/Web/Pages/EditInterface.razor
@@ -16,6 +16,7 @@
 @inject NavigationManager _navigationManager
 @inject IJSRuntime _js
 @inject AbstractValidator<Interface> _validator
+@inject IInterfaceService _interfaceService
 
 @code {
     const string Title = "Interface";
@@ -37,7 +38,7 @@
     <div class="col">
         <h1 class="mb-3">
             @Title
-            @if (_wireguardService.IsInterfaceUp(Iface)) {
+            @if (_interfaceService.IsInterfaceUp(Iface)) {
                 <RadzenBadge class="float-end" IsPill="true" Text="up" BadgeStyle="BadgeStyle.Success" />
             }
             else {
diff --git a/Linguard/Web/Pages/Network.razor b/Linguard/Web/Pages/Network.razor
index acacd22..21168e1 100644
--- a/Linguard/Web/Pages/Network.razor
+++ b/Linguard/Web/Pages/Network.razor
@@ -2,6 +2,7 @@
 @using Linguard.Core.Utils
 @using System.Net.NetworkInformation
 @using System.Net.Sockets
+@using Linguard.Core.Services
 
 @code {
     const string Title = "Network";
@@ -34,6 +35,7 @@
     </Columns>
 </RadzenDataGrid>
 
+@inject IInterfaceService _interfaceService
 @code {
 
     class NetworkInterfaceViewModel {
@@ -49,11 +51,11 @@
 
     protected override void OnInitialized() {
         _interfaces = new List<NetworkInterfaceViewModel>();
-        var interfaces = NetworkInterface.GetAllNetworkInterfaces()
+        var interfaces = _interfaceService.NetworkInterfaces
             .OrderBy(i => i.Name)
             .ToList();
         foreach (var iface in interfaces) {
-            var addresses = iface.GetIPProperties().UnicastAddresses;
+            var addresses = iface.GetIPProperties().UnicastAddresses.ToList();
             var ipv4 = addresses.FirstOrDefault(
                 a => a.Address.AddressFamily == AddressFamily.InterNetwork);
             var ipv6 = addresses.FirstOrDefault(
diff --git a/Linguard/Web/Pages/Wireguard.razor b/Linguard/Web/Pages/Wireguard.razor
index 08f6a1f..ec82a59 100644
--- a/Linguard/Web/Pages/Wireguard.razor
+++ b/Linguard/Web/Pages/Wireguard.razor
@@ -8,7 +8,7 @@
 @using Linguard.Web.Services
 
 @inject IConfigurationManager _configurationManager
-@inject IWireguardService _wireguardService
+@inject IInterfaceService _interfaceService
 @inject IWebService _webService
 @inject NotificationService _notificationService
 @inject DialogService _dialogService
@@ -39,7 +39,7 @@
         <RadzenDataGridColumn TItem="Interface" Title="Actions" Resizable="false" 
                               Filterable="false" Sortable="false">
             <Template Context="data">
-                @if (_wireguardService.IsInterfaceDown(data)) {
+                @if (_interfaceService.IsInterfaceDown(data)) {
                     <RadzenButton Icon="play_arrow" ButtonStyle="ButtonStyle.Success" title="Start"
                                   Click="() => StartInterface(data)" />
                 }
@@ -92,8 +92,8 @@
         <RadzenDataGridColumn TItem="Client" Property="IPv6Address" Title="IPv6"/>
         <RadzenDataGridColumn TItem="Client" Title="Interface">
             <Template Context="data">
-                <a href="/interface/@(_wireguardService.GetInterface(data)?.Id)">
-                    @(_wireguardService.GetInterface(data)?.Name)
+                <a href="/interface/@(_interfaceService.GetInterface(data)?.Id)">
+                    @(_interfaceService.GetInterface(data)?.Name)
                 </a>
             </Template>
         </RadzenDataGridColumn>
@@ -133,7 +133,7 @@
 
     void StartInterface(Interface iface) {
         try {
-            _wireguardService.StartInterface(iface);
+            _interfaceService.StartInterface(iface);
             _interfacesGrid.Reload();
         }
         catch (Exception e) {
@@ -147,7 +147,7 @@
     
     void StopInterface(Interface @interface) {
         try {
-            _wireguardService.StopInterface(@interface);
+            _interfaceService.StopInterface(@interface);
             _interfacesGrid.Reload();
         }
         catch (Exception e) {
diff --git a/Linguard/Web/Program.cs b/Linguard/Web/Program.cs
index 31f8442..9403ac3 100644
--- a/Linguard/Web/Program.cs
+++ b/Linguard/Web/Program.cs
@@ -26,6 +26,7 @@
 builder.Services.AddTransient<ILogger, NLogLogger>();
 builder.Services.AddTransient<ICommandRunner, CommandRunner>();
 builder.Services.AddTransient<IWireguardService, WireguardService>();
+builder.Services.AddTransient<IInterfaceService, InterfaceService>();
 builder.Services.AddTransient<IInterfaceGenerator, DefaultInterfaceGenerator>();
 builder.Services.AddTransient<IClientGenerator, DefaultClientGenerator>();
 builder.Services.AddTransient<AbstractValidator<Interface>, InterfaceValidator>();
diff --git a/Linguard/Web/Services/LifetimeService.cs b/Linguard/Web/Services/LifetimeService.cs
index 6e86a28..ec54fad 100644
--- a/Linguard/Web/Services/LifetimeService.cs
+++ b/Linguard/Web/Services/LifetimeService.cs
@@ -15,15 +15,16 @@ public class LifetimeService : ILifetimeService {
     private static readonly string WorkingDirectoryEnvironmentVariable = $"{AssemblyInfo.Product}Workdir";
     
     private readonly Log.ILogger _logger;
-    private readonly IWireguardService _wireguardService;
+    private readonly IInterfaceService _interfaceService;
     private readonly IConfigurationManager _configurationManager;
     private IWireguardConfiguration Configuration => _configurationManager.Configuration.Wireguard;
     
     #endregion
     
-    public LifetimeService(IConfigurationManager configurationManager, IWireguardService wireguardService, Log.ILogger logger) {
+    public LifetimeService(IConfigurationManager configurationManager, IInterfaceService interfaceService, 
+        Log.ILogger logger) {
         _configurationManager = configurationManager;
-        _wireguardService = wireguardService;
+        _interfaceService = interfaceService;
         _logger = logger;
     }
 
@@ -84,7 +85,7 @@ private void StartInterfaces() {
         var started = 0;
         foreach (var iface in interfaces) {
             try {
-                _wireguardService.StartInterface(iface);
+                _interfaceService.StartInterface(iface);
                 started++;
             }
             catch (Exception e) {
@@ -101,7 +102,7 @@ private void StopInterfaces() {
         var stopped = 0;
         foreach (var iface in interfaces) {
             try {
-                _wireguardService.StopInterface(iface);
+                _interfaceService.StopInterface(iface);
                 stopped++;
             }
             catch (Exception e) {
diff --git a/Linguard/Web/Services/WebService.cs b/Linguard/Web/Services/WebService.cs
index 180110f..ebb5a31 100644
--- a/Linguard/Web/Services/WebService.cs
+++ b/Linguard/Web/Services/WebService.cs
@@ -12,18 +12,20 @@ namespace Linguard.Web.Services;
 public class WebService : IWebService {
     
     public WebService(IJSRuntime jsRuntime, IWireguardService wireguardService, 
-        IConfigurationManager configurationManager, QRCodeGenerator qrCodeGenerator) {
+        IConfigurationManager configurationManager, QRCodeGenerator qrCodeGenerator, IInterfaceService interfaceService) {
         JsRuntime = jsRuntime;
         WireguardService = wireguardService;
         ConfigurationManager = configurationManager;
         QrCodeGenerator = qrCodeGenerator;
+        InterfaceService = interfaceService;
     }
 
-    private IJSRuntime JsRuntime { get; set; }
-    private IWireguardService WireguardService { get; set; }
-    private IConfigurationManager ConfigurationManager { get; set; }
+    private IJSRuntime JsRuntime { get; }
+    private IWireguardService WireguardService { get; }
+    private IInterfaceService InterfaceService { get; }
+    private IConfigurationManager ConfigurationManager { get; }
     private IWireguardConfiguration Configuration => ConfigurationManager.Configuration.Wireguard;
-    private QRCodeGenerator QrCodeGenerator {get; set; }
+    private QRCodeGenerator QrCodeGenerator {get; }
 
     public async Task Download(string data, string filename) {
         var bytes = Encoding.UTF8.GetBytes(data);
@@ -58,7 +60,7 @@ public byte[] GetQrCode(IWireguardPeer peer) {
     }
 
     private void RemoveClient(Client client) {
-        WireguardService.GetInterface(client)?.Clients.Remove(client);
+        InterfaceService.GetInterface(client)?.Clients.Remove(client);
         ConfigurationManager.Save();
     }
     
diff --git a/Linguard/Web/Shared/ClientConfigurationForm.razor b/Linguard/Web/Shared/ClientConfigurationForm.razor
index 9f9571d..b12f518 100644
--- a/Linguard/Web/Shared/ClientConfigurationForm.razor
+++ b/Linguard/Web/Shared/ClientConfigurationForm.razor
@@ -179,7 +179,7 @@
 </div>
 
 @inject IConfigurationManager _configurationManager
-@inject IWireguardService _wireguardService
+@inject IInterfaceService _interfaceService
 
 @code {
     [Parameter]
@@ -202,7 +202,7 @@
     protected override void OnInitialized() {
         base.OnInitialized();
         if (Interface == default) {
-            Interface = _wireguardService.GetInterface(Client);
+            Interface = _interfaceService.GetInterface(Client);
         }
     }
 
diff --git a/Linguard/Web/Shared/PeerActions.razor b/Linguard/Web/Shared/PeerActions.razor
index 6f99ad4..780baf2 100644
--- a/Linguard/Web/Shared/PeerActions.razor
+++ b/Linguard/Web/Shared/PeerActions.razor
@@ -29,11 +29,11 @@
 </div>
 
 @inject IConfigurationManager _configurationManager
-@inject IWireguardService _wireguardService
 @inject IWebService _webService;
 @inject NotificationService _notificationService
 @inject DialogService _dialogService
 @inject NavigationManager _navigationManager
+@inject IInterfaceService _interfaceService
 
 @code {
     
@@ -50,7 +50,7 @@
     
     void StartInterface() {
         try {
-            _wireguardService.StartInterface((Interface) Peer);
+            _interfaceService.StartInterface((Interface) Peer);
         }
         catch (Exception e) {
             _notificationService.Notify(new NotificationMessage {
@@ -63,7 +63,7 @@
     
     void StopInterface() {
         try {
-            _wireguardService.StopInterface((Interface) Peer);
+            _interfaceService.StopInterface((Interface) Peer);
         }
         catch (Exception e) {
             _notificationService.Notify(new NotificationMessage {
diff --git a/Linguard/WebMock/App.razor b/Linguard/WebMock/App.razor
index b3282bf..3d6352f 100644
--- a/Linguard/WebMock/App.razor
+++ b/Linguard/WebMock/App.razor
@@ -1,6 +1,4 @@
-@using Linguard.Web.Shared
-
-<Router AppAssembly="@typeof(App).Assembly">
+<Router AppAssembly="@typeof(App).Assembly">
     <Found Context="routeData">
         <RouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)"/>
         <FocusOnNavigate RouteData="@routeData" Selector="h1"/>
diff --git a/Linguard/WebMock/InterfaceServiceMock.cs b/Linguard/WebMock/InterfaceServiceMock.cs
new file mode 100644
index 0000000..079435c
--- /dev/null
+++ b/Linguard/WebMock/InterfaceServiceMock.cs
@@ -0,0 +1,37 @@
+using System.Net.NetworkInformation;
+using Core.Test.Mocks;
+using Linguard.Core.Configuration;
+using Linguard.Core.Managers;
+using Linguard.Core.Models.Wireguard;
+using Linguard.Core.Services;
+using Moq;
+
+namespace WebMock; 
+
+public sealed class InterfaceServiceMock : Mock<IInterfaceService> {
+    private readonly List<NetworkInterface> _networkInterfaces = new();
+    private readonly IConfigurationManager _configurationManager;
+    private IWireguardConfiguration Configuration => _configurationManager.Configuration.Wireguard; 
+    public InterfaceServiceMock(IConfigurationManager configurationManager) {
+        _configurationManager = configurationManager;
+        SetupGet(o => o.NetworkInterfaces).Returns(_networkInterfaces);
+        Setup(o => o.StartInterface(It.IsAny<Interface>()))
+            .Callback<Interface>(i => {
+                if (Object.NetworkInterfaces.Any(iface => iface.Name.Equals(i.Name))) {
+                    return;
+                }
+                var mockedInterface = new NetworkInterfaceMock(i.Name, OperationalStatus.Up).Object;
+                _networkInterfaces.Add(mockedInterface);
+            });
+        Setup(o => o.StopInterface(It.IsAny<Interface>()))
+            .Callback<Interface>(i => {
+                _networkInterfaces.RemoveAll(iface => iface.Name.Equals(i.Name));
+            });
+        Setup(o => o.IsInterfaceDown(It.IsAny<Interface>()))
+            .Returns<Interface>(i => !Object.NetworkInterfaces.Any(iface => iface.Name.Equals(i.Name)));
+        Setup(o => o.IsInterfaceUp(It.IsAny<Interface>()))
+            .Returns<Interface>(i => !Object.IsInterfaceDown(i));
+        Setup(o => o.GetInterface(It.IsAny<Client>()))
+            .Returns<Client>(c => Configuration.Interfaces.SingleOrDefault(i => i.Clients.Contains(c)));
+    }
+}
\ No newline at end of file
diff --git a/Linguard/WebMock/Program.cs b/Linguard/WebMock/Program.cs
index ae68035..028a6d3 100644
--- a/Linguard/WebMock/Program.cs
+++ b/Linguard/WebMock/Program.cs
@@ -28,7 +28,9 @@
 var manager = new DefaultConfigurationManager().Object;
 builder.Services.AddSingleton(manager);
 builder.Services.AddTransient<ILogger, NLogLogger>();
-builder.Services.AddSingleton(new CommandRunnerMock().Object);
+var commandRunner = new CommandRunnerMock().Object;
+builder.Services.AddSingleton(commandRunner);
+builder.Services.AddSingleton(new InterfaceServiceMock(manager).Object);
 builder.Services.AddTransient<IWireguardService, WireguardService>();
 builder.Services.AddTransient<IInterfaceGenerator, DefaultInterfaceGenerator>();
 builder.Services.AddTransient<IClientGenerator, DefaultClientGenerator>();