0x524a
21646af4ca
- Introduced benchmarks for various device security operations including GetRemoteUser, SetRemoteUser, and IP address filter management. - Enhanced XML request handling by defining common structures for IP address filters to improve code efficiency and readability. - Updated existing methods to utilize the new SOAP client creation method for better credential management. - Pre-allocated slices in XML request structures to optimize performance during serialization.
787 lines
20 KiB
Go
787 lines
20 KiB
Go
package onvif
|
|
|
|
import (
|
|
"context"
|
|
"encoding/xml"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func newMockDeviceSecurityServer() *httptest.Server {
|
|
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
decoder := xml.NewDecoder(r.Body)
|
|
var envelope struct {
|
|
Body struct {
|
|
Content []byte `xml:",innerxml"`
|
|
} `xml:"Body"`
|
|
}
|
|
_ = decoder.Decode(&envelope)
|
|
bodyContent := string(envelope.Body.Content)
|
|
|
|
w.Header().Set("Content-Type", "application/soap+xml")
|
|
|
|
switch {
|
|
case strings.Contains(bodyContent, "GetRemoteUser"):
|
|
_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
|
|
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">
|
|
<s:Body>
|
|
<tds:GetRemoteUserResponse xmlns:tds="http://www.onvif.org/ver10/device/wsdl">
|
|
<tds:RemoteUser>
|
|
<tt:Username>remote_admin</tt:Username>
|
|
<tt:Password></tt:Password>
|
|
<tt:UseDerivedPassword>true</tt:UseDerivedPassword>
|
|
</tds:RemoteUser>
|
|
</tds:GetRemoteUserResponse>
|
|
</s:Body>
|
|
</s:Envelope>`))
|
|
|
|
case strings.Contains(bodyContent, "SetRemoteUser"):
|
|
_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
|
|
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">
|
|
<s:Body>
|
|
<tds:SetRemoteUserResponse xmlns:tds="http://www.onvif.org/ver10/device/wsdl"/>
|
|
</s:Body>
|
|
</s:Envelope>`))
|
|
|
|
case strings.Contains(bodyContent, "GetIPAddressFilter"):
|
|
_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
|
|
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">
|
|
<s:Body>
|
|
<tds:GetIPAddressFilterResponse xmlns:tds="http://www.onvif.org/ver10/device/wsdl">
|
|
<tds:IPAddressFilter>
|
|
<tt:Type>Allow</tt:Type>
|
|
<tt:IPv4Address>
|
|
<tt:Address>192.168.1.0</tt:Address>
|
|
<tt:PrefixLength>24</tt:PrefixLength>
|
|
</tt:IPv4Address>
|
|
</tds:IPAddressFilter>
|
|
</tds:GetIPAddressFilterResponse>
|
|
</s:Body>
|
|
</s:Envelope>`))
|
|
|
|
case strings.Contains(bodyContent, "SetIPAddressFilter"),
|
|
strings.Contains(bodyContent, "AddIPAddressFilter"),
|
|
strings.Contains(bodyContent, "RemoveIPAddressFilter"):
|
|
_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
|
|
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">
|
|
<s:Body>
|
|
<tds:SetIPAddressFilterResponse xmlns:tds="http://www.onvif.org/ver10/device/wsdl"/>
|
|
</s:Body>
|
|
</s:Envelope>`))
|
|
|
|
case strings.Contains(bodyContent, "GetZeroConfiguration"):
|
|
_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
|
|
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">
|
|
<s:Body>
|
|
<tds:GetZeroConfigurationResponse xmlns:tds="http://www.onvif.org/ver10/device/wsdl">
|
|
<tds:ZeroConfiguration>
|
|
<tt:InterfaceToken>eth0</tt:InterfaceToken>
|
|
<tt:Enabled>true</tt:Enabled>
|
|
<tt:Addresses>169.254.1.100</tt:Addresses>
|
|
</tds:ZeroConfiguration>
|
|
</tds:GetZeroConfigurationResponse>
|
|
</s:Body>
|
|
</s:Envelope>`))
|
|
|
|
case strings.Contains(bodyContent, "SetZeroConfiguration"):
|
|
_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
|
|
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">
|
|
<s:Body>
|
|
<tds:SetZeroConfigurationResponse xmlns:tds="http://www.onvif.org/ver10/device/wsdl"/>
|
|
</s:Body>
|
|
</s:Envelope>`))
|
|
|
|
case strings.Contains(bodyContent, "GetPasswordComplexityConfiguration"):
|
|
_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
|
|
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">
|
|
<s:Body>
|
|
<tds:GetPasswordComplexityConfigurationResponse xmlns:tds="http://www.onvif.org/ver10/device/wsdl">
|
|
<tds:MinLen>8</tds:MinLen>
|
|
<tds:Uppercase>1</tds:Uppercase>
|
|
<tds:Number>1</tds:Number>
|
|
<tds:SpecialChars>1</tds:SpecialChars>
|
|
<tds:BlockUsernameOccurrence>true</tds:BlockUsernameOccurrence>
|
|
<tds:PolicyConfigurationLocked>false</tds:PolicyConfigurationLocked>
|
|
</tds:GetPasswordComplexityConfigurationResponse>
|
|
</s:Body>
|
|
</s:Envelope>`))
|
|
|
|
case strings.Contains(bodyContent, "SetPasswordComplexityConfiguration"):
|
|
_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
|
|
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">
|
|
<s:Body>
|
|
<tds:SetPasswordComplexityConfigurationResponse xmlns:tds="http://www.onvif.org/ver10/device/wsdl"/>
|
|
</s:Body>
|
|
</s:Envelope>`))
|
|
|
|
case strings.Contains(bodyContent, "GetPasswordHistoryConfiguration"):
|
|
_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
|
|
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">
|
|
<s:Body>
|
|
<tds:GetPasswordHistoryConfigurationResponse xmlns:tds="http://www.onvif.org/ver10/device/wsdl">
|
|
<tds:Enabled>true</tds:Enabled>
|
|
<tds:Length>5</tds:Length>
|
|
</tds:GetPasswordHistoryConfigurationResponse>
|
|
</s:Body>
|
|
</s:Envelope>`))
|
|
|
|
case strings.Contains(bodyContent, "SetPasswordHistoryConfiguration"):
|
|
_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
|
|
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">
|
|
<s:Body>
|
|
<tds:SetPasswordHistoryConfigurationResponse xmlns:tds="http://www.onvif.org/ver10/device/wsdl"/>
|
|
</s:Body>
|
|
</s:Envelope>`))
|
|
|
|
case strings.Contains(bodyContent, "GetAuthFailureWarningConfiguration"):
|
|
_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
|
|
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">
|
|
<s:Body>
|
|
<tds:GetAuthFailureWarningConfigurationResponse xmlns:tds="http://www.onvif.org/ver10/device/wsdl">
|
|
<tds:Enabled>true</tds:Enabled>
|
|
<tds:MonitorPeriod>60</tds:MonitorPeriod>
|
|
<tds:MaxAuthFailures>5</tds:MaxAuthFailures>
|
|
</tds:GetAuthFailureWarningConfigurationResponse>
|
|
</s:Body>
|
|
</s:Envelope>`))
|
|
|
|
case strings.Contains(bodyContent, "SetAuthFailureWarningConfiguration"):
|
|
_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
|
|
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">
|
|
<s:Body>
|
|
<tds:SetAuthFailureWarningConfigurationResponse xmlns:tds="http://www.onvif.org/ver10/device/wsdl"/>
|
|
</s:Body>
|
|
</s:Envelope>`))
|
|
|
|
default:
|
|
w.WriteHeader(http.StatusNotFound)
|
|
}
|
|
}))
|
|
}
|
|
|
|
func TestGetRemoteUser(t *testing.T) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, err := NewClient(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create client: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
remoteUser, err := client.GetRemoteUser(ctx)
|
|
if err != nil {
|
|
t.Fatalf("GetRemoteUser failed: %v", err)
|
|
}
|
|
|
|
if remoteUser.Username != "remote_admin" {
|
|
t.Errorf("Expected username 'remote_admin', got %s", remoteUser.Username)
|
|
}
|
|
|
|
if !remoteUser.UseDerivedPassword {
|
|
t.Error("UseDerivedPassword should be true")
|
|
}
|
|
}
|
|
|
|
func TestSetRemoteUser(t *testing.T) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, err := NewClient(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create client: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
remoteUser := &RemoteUser{
|
|
Username: "new_remote",
|
|
Password: "password123",
|
|
UseDerivedPassword: true,
|
|
}
|
|
|
|
err = client.SetRemoteUser(ctx, remoteUser)
|
|
if err != nil {
|
|
t.Fatalf("SetRemoteUser failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestGetIPAddressFilter(t *testing.T) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, err := NewClient(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create client: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
filter, err := client.GetIPAddressFilter(ctx)
|
|
if err != nil {
|
|
t.Fatalf("GetIPAddressFilter failed: %v", err)
|
|
}
|
|
|
|
if filter.Type != IPAddressFilterAllow {
|
|
t.Errorf("Expected Allow filter type, got %s", filter.Type)
|
|
}
|
|
|
|
if len(filter.IPv4Address) != 1 {
|
|
t.Fatalf("Expected 1 IPv4 address, got %d", len(filter.IPv4Address))
|
|
}
|
|
|
|
if filter.IPv4Address[0].Address != "192.168.1.0" {
|
|
t.Errorf("Expected address 192.168.1.0, got %s", filter.IPv4Address[0].Address)
|
|
}
|
|
|
|
if filter.IPv4Address[0].PrefixLength != 24 {
|
|
t.Errorf("Expected prefix length 24, got %d", filter.IPv4Address[0].PrefixLength)
|
|
}
|
|
}
|
|
|
|
func TestSetIPAddressFilter(t *testing.T) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, err := NewClient(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create client: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
filter := &IPAddressFilter{
|
|
Type: IPAddressFilterAllow,
|
|
IPv4Address: []PrefixedIPv4Address{
|
|
{Address: "10.0.0.0", PrefixLength: 8},
|
|
},
|
|
}
|
|
|
|
err = client.SetIPAddressFilter(ctx, filter)
|
|
if err != nil {
|
|
t.Fatalf("SetIPAddressFilter failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestAddIPAddressFilter(t *testing.T) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, err := NewClient(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create client: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
filter := &IPAddressFilter{
|
|
Type: IPAddressFilterAllow,
|
|
IPv4Address: []PrefixedIPv4Address{
|
|
{Address: "172.16.0.0", PrefixLength: 12},
|
|
},
|
|
}
|
|
|
|
err = client.AddIPAddressFilter(ctx, filter)
|
|
if err != nil {
|
|
t.Fatalf("AddIPAddressFilter failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestRemoveIPAddressFilter(t *testing.T) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, err := NewClient(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create client: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
filter := &IPAddressFilter{
|
|
Type: IPAddressFilterAllow,
|
|
IPv4Address: []PrefixedIPv4Address{
|
|
{Address: "172.16.0.0", PrefixLength: 12},
|
|
},
|
|
}
|
|
|
|
err = client.RemoveIPAddressFilter(ctx, filter)
|
|
if err != nil {
|
|
t.Fatalf("RemoveIPAddressFilter failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestGetZeroConfiguration(t *testing.T) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, err := NewClient(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create client: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
zeroConf, err := client.GetZeroConfiguration(ctx)
|
|
if err != nil {
|
|
t.Fatalf("GetZeroConfiguration failed: %v", err)
|
|
}
|
|
|
|
if zeroConf.InterfaceToken != "eth0" {
|
|
t.Errorf("Expected interface token 'eth0', got %s", zeroConf.InterfaceToken)
|
|
}
|
|
|
|
if !zeroConf.Enabled {
|
|
t.Error("Zero configuration should be enabled")
|
|
}
|
|
|
|
if len(zeroConf.Addresses) != 1 || zeroConf.Addresses[0] != "169.254.1.100" {
|
|
t.Errorf("Expected address 169.254.1.100, got %v", zeroConf.Addresses)
|
|
}
|
|
}
|
|
|
|
func TestSetZeroConfiguration(t *testing.T) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, err := NewClient(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create client: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
err = client.SetZeroConfiguration(ctx, "eth0", true)
|
|
if err != nil {
|
|
t.Fatalf("SetZeroConfiguration failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestGetPasswordComplexityConfiguration(t *testing.T) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, err := NewClient(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create client: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
config, err := client.GetPasswordComplexityConfiguration(ctx)
|
|
if err != nil {
|
|
t.Fatalf("GetPasswordComplexityConfiguration failed: %v", err)
|
|
}
|
|
|
|
if config.MinLen != 8 {
|
|
t.Errorf("Expected MinLen 8, got %d", config.MinLen)
|
|
}
|
|
|
|
if config.Uppercase != 1 {
|
|
t.Errorf("Expected Uppercase 1, got %d", config.Uppercase)
|
|
}
|
|
|
|
if config.Number != 1 {
|
|
t.Errorf("Expected Number 1, got %d", config.Number)
|
|
}
|
|
|
|
if config.SpecialChars != 1 {
|
|
t.Errorf("Expected SpecialChars 1, got %d", config.SpecialChars)
|
|
}
|
|
|
|
if !config.BlockUsernameOccurrence {
|
|
t.Error("BlockUsernameOccurrence should be true")
|
|
}
|
|
|
|
if config.PolicyConfigurationLocked {
|
|
t.Error("PolicyConfigurationLocked should be false")
|
|
}
|
|
}
|
|
|
|
func TestSetPasswordComplexityConfiguration(t *testing.T) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, err := NewClient(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create client: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
config := &PasswordComplexityConfiguration{
|
|
MinLen: 10,
|
|
Uppercase: 2,
|
|
Number: 2,
|
|
SpecialChars: 1,
|
|
BlockUsernameOccurrence: true,
|
|
PolicyConfigurationLocked: false,
|
|
}
|
|
|
|
err = client.SetPasswordComplexityConfiguration(ctx, config)
|
|
if err != nil {
|
|
t.Fatalf("SetPasswordComplexityConfiguration failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestGetPasswordHistoryConfiguration(t *testing.T) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, err := NewClient(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create client: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
config, err := client.GetPasswordHistoryConfiguration(ctx)
|
|
if err != nil {
|
|
t.Fatalf("GetPasswordHistoryConfiguration failed: %v", err)
|
|
}
|
|
|
|
if !config.Enabled {
|
|
t.Error("Password history should be enabled")
|
|
}
|
|
|
|
if config.Length != 5 {
|
|
t.Errorf("Expected Length 5, got %d", config.Length)
|
|
}
|
|
}
|
|
|
|
func TestSetPasswordHistoryConfiguration(t *testing.T) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, err := NewClient(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create client: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
config := &PasswordHistoryConfiguration{
|
|
Enabled: true,
|
|
Length: 10,
|
|
}
|
|
|
|
err = client.SetPasswordHistoryConfiguration(ctx, config)
|
|
if err != nil {
|
|
t.Fatalf("SetPasswordHistoryConfiguration failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestGetAuthFailureWarningConfiguration(t *testing.T) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, err := NewClient(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create client: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
config, err := client.GetAuthFailureWarningConfiguration(ctx)
|
|
if err != nil {
|
|
t.Fatalf("GetAuthFailureWarningConfiguration failed: %v", err)
|
|
}
|
|
|
|
if !config.Enabled {
|
|
t.Error("Auth failure warning should be enabled")
|
|
}
|
|
|
|
if config.MonitorPeriod != 60 {
|
|
t.Errorf("Expected MonitorPeriod 60, got %d", config.MonitorPeriod)
|
|
}
|
|
|
|
if config.MaxAuthFailures != 5 {
|
|
t.Errorf("Expected MaxAuthFailures 5, got %d", config.MaxAuthFailures)
|
|
}
|
|
}
|
|
|
|
func TestSetAuthFailureWarningConfiguration(t *testing.T) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, err := NewClient(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create client: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
config := &AuthFailureWarningConfiguration{
|
|
Enabled: true,
|
|
MonitorPeriod: 120,
|
|
MaxAuthFailures: 3,
|
|
}
|
|
|
|
err = client.SetAuthFailureWarningConfiguration(ctx, config)
|
|
if err != nil {
|
|
t.Fatalf("SetAuthFailureWarningConfiguration failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestIPAddressFilterTypeConstants(t *testing.T) {
|
|
if IPAddressFilterAllow != "Allow" {
|
|
t.Errorf("IPAddressFilterAllow should be 'Allow', got %s", IPAddressFilterAllow)
|
|
}
|
|
|
|
if IPAddressFilterDeny != "Deny" {
|
|
t.Errorf("IPAddressFilterDeny should be 'Deny', got %s", IPAddressFilterDeny)
|
|
}
|
|
}
|
|
|
|
// Benchmarks for device security operations.
|
|
|
|
func BenchmarkGetRemoteUser(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_, _ = client.GetRemoteUser(ctx)
|
|
}
|
|
}
|
|
|
|
func BenchmarkSetRemoteUser(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
remoteUser := &RemoteUser{
|
|
Username: "test_user",
|
|
Password: "password123",
|
|
UseDerivedPassword: true,
|
|
}
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_ = client.SetRemoteUser(ctx, remoteUser)
|
|
}
|
|
}
|
|
|
|
func BenchmarkGetIPAddressFilter(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_, _ = client.GetIPAddressFilter(ctx)
|
|
}
|
|
}
|
|
|
|
func BenchmarkSetIPAddressFilter(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
filter := &IPAddressFilter{
|
|
Type: IPAddressFilterAllow,
|
|
IPv4Address: []PrefixedIPv4Address{
|
|
{Address: "192.168.1.0", PrefixLength: 24},
|
|
{Address: "10.0.0.0", PrefixLength: 8},
|
|
},
|
|
IPv6Address: []PrefixedIPv6Address{
|
|
{Address: "fe80::", PrefixLength: 64},
|
|
},
|
|
}
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_ = client.SetIPAddressFilter(ctx, filter)
|
|
}
|
|
}
|
|
|
|
func BenchmarkAddIPAddressFilter(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
filter := &IPAddressFilter{
|
|
Type: IPAddressFilterAllow,
|
|
IPv4Address: []PrefixedIPv4Address{
|
|
{Address: "172.16.0.0", PrefixLength: 12},
|
|
},
|
|
}
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_ = client.AddIPAddressFilter(ctx, filter)
|
|
}
|
|
}
|
|
|
|
func BenchmarkRemoveIPAddressFilter(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
filter := &IPAddressFilter{
|
|
Type: IPAddressFilterAllow,
|
|
IPv4Address: []PrefixedIPv4Address{
|
|
{Address: "172.16.0.0", PrefixLength: 12},
|
|
},
|
|
}
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_ = client.RemoveIPAddressFilter(ctx, filter)
|
|
}
|
|
}
|
|
|
|
func BenchmarkGetZeroConfiguration(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_, _ = client.GetZeroConfiguration(ctx)
|
|
}
|
|
}
|
|
|
|
func BenchmarkSetZeroConfiguration(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_ = client.SetZeroConfiguration(ctx, "eth0", true)
|
|
}
|
|
}
|
|
|
|
func BenchmarkGetPasswordComplexityConfiguration(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_, _ = client.GetPasswordComplexityConfiguration(ctx)
|
|
}
|
|
}
|
|
|
|
func BenchmarkSetPasswordComplexityConfiguration(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
config := &PasswordComplexityConfiguration{
|
|
MinLen: 10,
|
|
Uppercase: 2,
|
|
Number: 2,
|
|
SpecialChars: 1,
|
|
BlockUsernameOccurrence: true,
|
|
PolicyConfigurationLocked: false,
|
|
}
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_ = client.SetPasswordComplexityConfiguration(ctx, config)
|
|
}
|
|
}
|
|
|
|
func BenchmarkGetPasswordHistoryConfiguration(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_, _ = client.GetPasswordHistoryConfiguration(ctx)
|
|
}
|
|
}
|
|
|
|
func BenchmarkSetPasswordHistoryConfiguration(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
config := &PasswordHistoryConfiguration{
|
|
Enabled: true,
|
|
Length: 10,
|
|
}
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_ = client.SetPasswordHistoryConfiguration(ctx, config)
|
|
}
|
|
}
|
|
|
|
func BenchmarkGetAuthFailureWarningConfiguration(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_, _ = client.GetAuthFailureWarningConfiguration(ctx)
|
|
}
|
|
}
|
|
|
|
func BenchmarkSetAuthFailureWarningConfiguration(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
config := &AuthFailureWarningConfiguration{
|
|
Enabled: true,
|
|
MonitorPeriod: 120,
|
|
MaxAuthFailures: 3,
|
|
}
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_ = client.SetAuthFailureWarningConfiguration(ctx, config)
|
|
}
|
|
}
|
|
|
|
// BenchmarkIPAddressFilterWithManyAddresses tests performance with larger address lists.
|
|
func BenchmarkIPAddressFilterWithManyAddresses(b *testing.B) {
|
|
server := newMockDeviceSecurityServer()
|
|
defer server.Close()
|
|
|
|
client, _ := NewClient(server.URL)
|
|
ctx := context.Background()
|
|
|
|
// Create filter with many addresses to test pre-allocation efficiency
|
|
filter := &IPAddressFilter{
|
|
Type: IPAddressFilterAllow,
|
|
IPv4Address: make([]PrefixedIPv4Address, 100),
|
|
IPv6Address: make([]PrefixedIPv6Address, 50),
|
|
}
|
|
|
|
for i := 0; i < 100; i++ {
|
|
filter.IPv4Address[i] = PrefixedIPv4Address{
|
|
Address: "192.168.1.0",
|
|
PrefixLength: 24,
|
|
}
|
|
}
|
|
|
|
for i := 0; i < 50; i++ {
|
|
filter.IPv6Address[i] = PrefixedIPv6Address{
|
|
Address: "fe80::",
|
|
PrefixLength: 64,
|
|
}
|
|
}
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_ = client.SetIPAddressFilter(ctx, filter)
|
|
}
|
|
}
|