feat: 重建 ONVIF 与 RTSP 视频接入 (#66)
This commit is contained in:
@@ -0,0 +1,296 @@
|
||||
package onvif
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/md5"
|
||||
"crypto/rand"
|
||||
"crypto/sha256"
|
||||
"encoding/xml"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrAuthentication = errors.New("设备拒绝了当前凭据")
|
||||
ErrRedirect = errors.New("设备返回了不允许的重定向")
|
||||
)
|
||||
|
||||
type Credential struct{ Username, Password string }
|
||||
type Profile struct {
|
||||
Token string `json:"token"`
|
||||
Name string `json:"name"`
|
||||
Width int `json:"width"`
|
||||
Height int `json:"height"`
|
||||
Encoding string `json:"encoding"`
|
||||
StreamURI string `json:"streamUri"`
|
||||
}
|
||||
type Client interface {
|
||||
Profiles(context.Context, string, Credential) ([]Profile, error)
|
||||
}
|
||||
type HTTPClient struct {
|
||||
client *http.Client
|
||||
policy Policy
|
||||
}
|
||||
|
||||
func NewHTTPClient(timeout time.Duration, policy Policy) *HTTPClient {
|
||||
if timeout <= 0 {
|
||||
timeout = 8 * time.Second
|
||||
}
|
||||
dialer := net.Dialer{Timeout: timeout}
|
||||
transport := &http.Transport{Proxy: nil, DialContext: func(ctx context.Context, network, address string) (net.Conn, error) {
|
||||
host, port, err := net.SplitHostPort(address)
|
||||
if err != nil {
|
||||
return nil, ErrAddressInvalid
|
||||
}
|
||||
_, ip, err := policy.ValidateURL(ctx, "http://"+net.JoinHostPort(host, port), "http")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return dialer.DialContext(ctx, network, net.JoinHostPort(ip.String(), port))
|
||||
}}
|
||||
return &HTTPClient{policy: policy, client: &http.Client{Timeout: timeout, Transport: transport, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}}
|
||||
}
|
||||
|
||||
func (c *HTTPClient) Profiles(ctx context.Context, address string, credential Credential) ([]Profile, error) {
|
||||
device, _, err := c.policy.ValidateURL(ctx, address, "http", "https")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
capabilities, err := c.soap(ctx, device.String(), credential, `<?xml version="1.0"?><s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope"><s:Body><GetCapabilities xmlns="http://www.onvif.org/ver10/device/wsdl"><Category>All</Category></GetCapabilities></s:Body></s:Envelope>`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
mediaRaw, err := parseElement(capabilities, "Media", "XAddr")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
media, err := c.normalizeService(ctx, device, mediaRaw)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
data, err := c.soap(ctx, media.String(), credential, `<?xml version="1.0"?><s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope"><s:Body><GetProfiles xmlns="http://www.onvif.org/ver10/media/wsdl"/></s:Body></s:Envelope>`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
profiles, err := parseProfiles(data)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for index := range profiles {
|
||||
body := fmt.Sprintf(`<?xml version="1.0"?><s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope"><s:Body><GetStreamUri xmlns="http://www.onvif.org/ver10/media/wsdl"><StreamSetup><Stream xmlns="http://www.onvif.org/ver10/schema">RTP-Unicast</Stream><Transport xmlns="http://www.onvif.org/ver10/schema"><Protocol>RTSP</Protocol></Transport></StreamSetup><ProfileToken>%s</ProfileToken></GetStreamUri></s:Body></s:Envelope>`, xmlEscape(profiles[index].Token))
|
||||
response, requestErr := c.soap(ctx, media.String(), credential, body)
|
||||
if requestErr != nil {
|
||||
return nil, requestErr
|
||||
}
|
||||
raw, parseErr := parseElement(response, "", "Uri")
|
||||
if parseErr != nil {
|
||||
return nil, parseErr
|
||||
}
|
||||
profiles[index].StreamURI, err = c.normalizeStream(ctx, device, raw)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return profiles, nil
|
||||
}
|
||||
|
||||
func (c *HTTPClient) normalizeService(ctx context.Context, device *url.URL, raw string) (*url.URL, error) {
|
||||
advertised, err := url.Parse(strings.TrimSpace(raw))
|
||||
if err != nil || advertised.Hostname() == "" || advertised.User != nil || (advertised.Scheme != "http" && advertised.Scheme != "https") {
|
||||
return nil, ErrAddressInvalid
|
||||
}
|
||||
if !strings.EqualFold(advertised.Hostname(), device.Hostname()) {
|
||||
advertised.Scheme = device.Scheme
|
||||
advertised.Host = device.Host
|
||||
}
|
||||
if _, _, err = c.policy.ValidateURL(ctx, advertised.String(), "http", "https"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return advertised, nil
|
||||
}
|
||||
func (c *HTTPClient) normalizeStream(ctx context.Context, device *url.URL, raw string) (string, error) {
|
||||
stream, err := url.Parse(strings.TrimSpace(raw))
|
||||
if err != nil || len(raw) > 2048 || stream.Hostname() == "" || stream.User != nil || stream.Scheme != "rtsp" {
|
||||
return "", ErrAddressInvalid
|
||||
}
|
||||
if !strings.EqualFold(stream.Hostname(), device.Hostname()) {
|
||||
port := stream.Port()
|
||||
stream.Host = device.Hostname()
|
||||
if port != "" {
|
||||
stream.Host = net.JoinHostPort(device.Hostname(), port)
|
||||
}
|
||||
}
|
||||
if _, _, err = c.policy.ValidateURL(ctx, stream.String(), "rtsp"); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return stream.String(), nil
|
||||
}
|
||||
func (c *HTTPClient) soap(ctx context.Context, endpoint string, credential Credential, body string) ([]byte, error) {
|
||||
return c.soapAttempt(ctx, endpoint, credential, body, "")
|
||||
}
|
||||
func (c *HTTPClient) soapAttempt(ctx context.Context, endpoint string, credential Credential, body, authorization string) ([]byte, error) {
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewBufferString(body))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/soap+xml; charset=utf-8")
|
||||
if authorization != "" {
|
||||
req.Header.Set("Authorization", authorization)
|
||||
} else if credential.Username != "" {
|
||||
req.SetBasicAuth(credential.Username, credential.Password)
|
||||
}
|
||||
res, err := c.client.Do(req)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("onvif request: %w", err)
|
||||
}
|
||||
defer res.Body.Close()
|
||||
data, err := io.ReadAll(io.LimitReader(res.Body, 2<<20))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if res.StatusCode >= 300 && res.StatusCode < 400 {
|
||||
return nil, ErrRedirect
|
||||
}
|
||||
if res.StatusCode == http.StatusUnauthorized {
|
||||
if authorization == "" && credential.Username != "" {
|
||||
challenge, challengeErr := parseDigestChallenge(res.Header.Values("WWW-Authenticate"))
|
||||
if challengeErr == nil {
|
||||
digest, digestErr := digestAuthorization(http.MethodPost, req.URL.RequestURI(), credential, challenge)
|
||||
if digestErr != nil {
|
||||
return nil, digestErr
|
||||
}
|
||||
return c.soapAttempt(ctx, endpoint, credential, body, digest)
|
||||
}
|
||||
}
|
||||
return nil, ErrAuthentication
|
||||
}
|
||||
if res.StatusCode < 200 || res.StatusCode >= 300 {
|
||||
return nil, fmt.Errorf("onvif http status %d", res.StatusCode)
|
||||
}
|
||||
return data, nil
|
||||
}
|
||||
|
||||
type digestChallenge struct{ realm, nonce, opaque, algorithm, qop string }
|
||||
|
||||
func parseDigestChallenge(values []string) (digestChallenge, error) {
|
||||
for _, value := range values {
|
||||
parts := strings.SplitN(strings.TrimSpace(value), " ", 2)
|
||||
if len(parts) != 2 || !strings.EqualFold(parts[0], "Digest") {
|
||||
continue
|
||||
}
|
||||
params, err := parseAuthParameters(parts[1])
|
||||
if err != nil {
|
||||
return digestChallenge{}, err
|
||||
}
|
||||
c := digestChallenge{realm: params["realm"], nonce: params["nonce"], opaque: params["opaque"], algorithm: strings.ToUpper(params["algorithm"])}
|
||||
if c.realm == "" || c.nonce == "" {
|
||||
return digestChallenge{}, ErrAuthentication
|
||||
}
|
||||
if c.algorithm == "" {
|
||||
c.algorithm = "MD5"
|
||||
}
|
||||
if c.algorithm != "MD5" && c.algorithm != "SHA-256" {
|
||||
return digestChallenge{}, ErrAuthentication
|
||||
}
|
||||
for _, q := range strings.Split(params["qop"], ",") {
|
||||
if strings.EqualFold(strings.TrimSpace(q), "auth") {
|
||||
c.qop = "auth"
|
||||
}
|
||||
}
|
||||
if params["qop"] != "" && c.qop == "" {
|
||||
return digestChallenge{}, ErrAuthentication
|
||||
}
|
||||
return c, nil
|
||||
}
|
||||
return digestChallenge{}, ErrAuthentication
|
||||
}
|
||||
func parseAuthParameters(value string) (map[string]string, error) {
|
||||
result := map[string]string{}
|
||||
for position := 0; position < len(value); {
|
||||
for position < len(value) && (value[position] == ' ' || value[position] == ',') {
|
||||
position++
|
||||
}
|
||||
start := position
|
||||
for position < len(value) && value[position] != '=' && value[position] != ',' {
|
||||
position++
|
||||
}
|
||||
if position == start || position >= len(value) || value[position] != '=' {
|
||||
return nil, ErrAuthentication
|
||||
}
|
||||
name := strings.ToLower(strings.TrimSpace(value[start:position]))
|
||||
position++
|
||||
var parameter string
|
||||
if position < len(value) && value[position] == '"' {
|
||||
position++
|
||||
var builder strings.Builder
|
||||
closed := false
|
||||
for position < len(value) {
|
||||
if value[position] == '"' {
|
||||
position++
|
||||
closed = true
|
||||
break
|
||||
}
|
||||
if value[position] == '\\' && position+1 < len(value) {
|
||||
position++
|
||||
}
|
||||
builder.WriteByte(value[position])
|
||||
position++
|
||||
}
|
||||
if !closed {
|
||||
return nil, ErrAuthentication
|
||||
}
|
||||
parameter = builder.String()
|
||||
} else {
|
||||
start = position
|
||||
for position < len(value) && value[position] != ',' {
|
||||
position++
|
||||
}
|
||||
parameter = strings.TrimSpace(value[start:position])
|
||||
}
|
||||
result[name] = parameter
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
func digestAuthorization(method, uri string, credential Credential, c digestChallenge) (string, error) {
|
||||
random := make([]byte, 16)
|
||||
if _, err := rand.Read(random); err != nil {
|
||||
return "", err
|
||||
}
|
||||
cnonce := fmt.Sprintf("%x", random)
|
||||
hash := func(value string) string {
|
||||
if c.algorithm == "SHA-256" {
|
||||
sum := sha256.Sum256([]byte(value))
|
||||
return fmt.Sprintf("%x", sum)
|
||||
}
|
||||
sum := md5.Sum([]byte(value))
|
||||
return fmt.Sprintf("%x", sum)
|
||||
}
|
||||
ha1 := hash(credential.Username + ":" + c.realm + ":" + credential.Password)
|
||||
ha2 := hash(method + ":" + uri)
|
||||
nc := "00000001"
|
||||
response := hash(ha1 + ":" + c.nonce + ":" + ha2)
|
||||
if c.qop != "" {
|
||||
response = hash(ha1 + ":" + c.nonce + ":" + nc + ":" + cnonce + ":" + c.qop + ":" + ha2)
|
||||
}
|
||||
values := []string{`username=` + strconv.Quote(credential.Username), `realm=` + strconv.Quote(c.realm), `nonce=` + strconv.Quote(c.nonce), `uri=` + strconv.Quote(uri), `response=` + strconv.Quote(response), `algorithm=` + c.algorithm}
|
||||
if c.opaque != "" {
|
||||
values = append(values, `opaque=`+strconv.Quote(c.opaque))
|
||||
}
|
||||
if c.qop != "" {
|
||||
values = append(values, `qop=`+c.qop, `nc=`+nc, `cnonce=`+strconv.Quote(cnonce))
|
||||
}
|
||||
return "Digest " + strings.Join(values, ", "), nil
|
||||
}
|
||||
func xmlEscape(value string) string {
|
||||
var b strings.Builder
|
||||
_ = xml.EscapeText(&b, []byte(value))
|
||||
return b.String()
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
package onvif
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func loopbackPolicy(t *testing.T) Policy {
|
||||
t.Helper()
|
||||
policy, err := ParsePolicy("127.0.0.0/8")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return policy
|
||||
}
|
||||
func TestProfilesSupportsDigestNormalizesAdvertisedHostsAndRejectsCredentials(t *testing.T) {
|
||||
digestSeen := false
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
body := make([]byte, r.ContentLength)
|
||||
_, _ = r.Body.Read(body)
|
||||
value := string(body)
|
||||
switch {
|
||||
case strings.Contains(value, "GetCapabilities"):
|
||||
fmt.Fprint(w, `<Envelope><Body><GetCapabilitiesResponse><Capabilities><Media><XAddr>http://unusable.invalid/onvif/media</XAddr></Media></Capabilities></GetCapabilitiesResponse></Body></Envelope>`)
|
||||
case !strings.HasPrefix(r.Header.Get("Authorization"), "Digest "):
|
||||
w.Header().Set("WWW-Authenticate", `Digest realm="camera", nonce="n", algorithm=MD5, qop="auth"`)
|
||||
w.WriteHeader(http.StatusUnauthorized)
|
||||
case strings.Contains(value, "GetProfiles"):
|
||||
digestSeen = strings.HasPrefix(r.Header.Get("Authorization"), "Digest ")
|
||||
fmt.Fprint(w, `<Envelope><Body><GetProfilesResponse><Profiles token="main"><Name>主码流</Name><VideoEncoderConfiguration><Encoding>H264</Encoding><Resolution><Width>1920</Width><Height>1080</Height></Resolution></VideoEncoderConfiguration></Profiles></GetProfilesResponse></Body></Envelope>`)
|
||||
default:
|
||||
fmt.Fprint(w, `<Envelope><Body><GetStreamUriResponse><MediaUri><Uri>rtsp://unusable.invalid:8554/live</Uri></MediaUri></GetStreamUriResponse></Body></Envelope>`)
|
||||
}
|
||||
}))
|
||||
defer server.Close()
|
||||
profiles, err := NewHTTPClient(2*time.Second, loopbackPolicy(t)).Profiles(context.Background(), server.URL+"/onvif/device", Credential{Username: "synthetic", Password: "synthetic"})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !digestSeen || len(profiles) != 1 || !strings.Contains(profiles[0].StreamURI, "127.0.0.1:8554") {
|
||||
t.Fatalf("profiles=%#v digest=%v", profiles, digestSeen)
|
||||
}
|
||||
if _, _, err = loopbackPolicy(t).ValidateURL(context.Background(), "http://user:pass@127.0.0.1/onvif", "http"); err == nil {
|
||||
t.Fatal("credential URL accepted")
|
||||
}
|
||||
if _, _, err = loopbackPolicy(t).ValidateURL(context.Background(), "http://127.0.0.1/onvif?access_token=synthetic", "http"); err == nil {
|
||||
t.Fatal("credential-like query accepted")
|
||||
}
|
||||
}
|
||||
func TestPolicyRequiresExplicitCIDRAndRejectsOutsideTarget(t *testing.T) {
|
||||
if _, err := ParsePolicy(""); err == nil {
|
||||
t.Fatal("empty policy accepted")
|
||||
}
|
||||
policy := loopbackPolicy(t)
|
||||
if _, _, err := policy.ValidateURL(context.Background(), "http://192.0.2.1/onvif", "http"); err == nil {
|
||||
t.Fatal("outside target accepted")
|
||||
}
|
||||
}
|
||||
func TestDiscoveryRequiresApprovedInterface(t *testing.T) {
|
||||
_, err := Discover(context.Background(), "", time.Millisecond, loopbackPolicy(t))
|
||||
if err != ErrDiscoveryNotConfigured {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClientRejectsRedirect(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
||||
w.Header().Set("Location", "http://127.0.0.1/other")
|
||||
w.WriteHeader(http.StatusFound)
|
||||
}))
|
||||
defer server.Close()
|
||||
_, err := NewHTTPClient(time.Second, loopbackPolicy(t)).Profiles(context.Background(), server.URL+"/onvif", Credential{})
|
||||
if err != ErrRedirect {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
package onvif
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/xml"
|
||||
"errors"
|
||||
"io"
|
||||
"net"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrDiscoveryNotConfigured = errors.New("未配置获准的发现网卡")
|
||||
ErrDiscoveryInterface = errors.New("配置的发现地址不是本机网卡")
|
||||
)
|
||||
|
||||
const discoveryProbe = `<?xml version="1.0"?><e:Envelope xmlns:e="http://www.w3.org/2003/05/soap-envelope" xmlns:w="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:d="http://schemas.xmlsoap.org/ws/2005/04/discovery" xmlns:dn="http://www.onvif.org/ver10/network/wsdl"><e:Header><w:MessageID>uuid:sense-controlled-discovery</w:MessageID><w:To e:mustUnderstand="true">urn:schemas-xmlsoap-org:ws:2005:04:discovery</w:To><w:Action e:mustUnderstand="true">http://schemas.xmlsoap.org/ws/2005/04/discovery/Probe</w:Action></e:Header><e:Body><d:Probe><d:Types>dn:NetworkVideoTransmitter</d:Types></d:Probe></e:Body></e:Envelope>`
|
||||
|
||||
func Discover(ctx context.Context, localIP string, timeout time.Duration, policy Policy) ([]string, error) {
|
||||
ip := net.ParseIP(strings.TrimSpace(localIP))
|
||||
if ip == nil {
|
||||
return nil, ErrDiscoveryNotConfigured
|
||||
}
|
||||
approved := false
|
||||
interfaces, _ := net.Interfaces()
|
||||
for _, iface := range interfaces {
|
||||
addresses, _ := iface.Addrs()
|
||||
for _, address := range addresses {
|
||||
host, _, _ := net.ParseCIDR(address.String())
|
||||
if host != nil && host.Equal(ip) {
|
||||
approved = true
|
||||
}
|
||||
}
|
||||
}
|
||||
if !approved {
|
||||
return nil, ErrDiscoveryInterface
|
||||
}
|
||||
connection, err := net.ListenUDP("udp4", &net.UDPAddr{IP: ip})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer connection.Close()
|
||||
if timeout <= 0 {
|
||||
timeout = 3 * time.Second
|
||||
}
|
||||
_ = connection.SetDeadline(time.Now().Add(timeout))
|
||||
if _, err = connection.WriteToUDP([]byte(discoveryProbe), &net.UDPAddr{IP: net.ParseIP("239.255.255.250"), Port: 3702}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
found := map[string]bool{}
|
||||
buffer := make([]byte, 65535)
|
||||
for {
|
||||
n, _, readErr := connection.ReadFromUDP(buffer)
|
||||
if readErr != nil {
|
||||
if e, ok := readErr.(net.Error); ok && e.Timeout() {
|
||||
break
|
||||
}
|
||||
return nil, readErr
|
||||
}
|
||||
for _, candidate := range extractXAddrs(string(buffer[:n])) {
|
||||
if _, _, validErr := policy.ValidateURL(ctx, candidate, "http", "https"); validErr == nil {
|
||||
found[candidate] = true
|
||||
}
|
||||
}
|
||||
}
|
||||
result := make([]string, 0, len(found))
|
||||
for value := range found {
|
||||
result = append(result, value)
|
||||
}
|
||||
sort.Strings(result)
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func extractXAddrs(value string) []string {
|
||||
decoder := xml.NewDecoder(strings.NewReader(value))
|
||||
for {
|
||||
token, err := decoder.Token()
|
||||
if errors.Is(err, io.EOF) {
|
||||
break
|
||||
}
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
start, ok := token.(xml.StartElement)
|
||||
if !ok || start.Name.Local != "XAddrs" {
|
||||
continue
|
||||
}
|
||||
var addresses string
|
||||
if decoder.DecodeElement(&addresses, &start) == nil {
|
||||
return strings.Fields(addresses)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
package onvif
|
||||
|
||||
import (
|
||||
"encoding/xml"
|
||||
"errors"
|
||||
"io"
|
||||
"strings"
|
||||
)
|
||||
|
||||
var ErrInvalidResponse = errors.New("ONVIF 返回内容无法识别")
|
||||
|
||||
type profileEnvelope struct {
|
||||
Profiles []struct {
|
||||
Token string `xml:"token,attr"`
|
||||
Name string `xml:"Name"`
|
||||
Encoder struct {
|
||||
Encoding string `xml:"Encoding"`
|
||||
Resolution struct {
|
||||
Width int `xml:"Width"`
|
||||
Height int `xml:"Height"`
|
||||
} `xml:"Resolution"`
|
||||
} `xml:"VideoEncoderConfiguration"`
|
||||
} `xml:"Body>GetProfilesResponse>Profiles"`
|
||||
}
|
||||
|
||||
func parseProfiles(data []byte) ([]Profile, error) {
|
||||
var envelope profileEnvelope
|
||||
if err := xml.Unmarshal(data, &envelope); err != nil || len(envelope.Profiles) == 0 || len(envelope.Profiles) > 128 {
|
||||
return nil, ErrInvalidResponse
|
||||
}
|
||||
result := make([]Profile, 0, len(envelope.Profiles))
|
||||
for _, p := range envelope.Profiles {
|
||||
if strings.TrimSpace(p.Token) == "" || len(p.Token) > 255 || len([]rune(p.Name)) > 255 || p.Encoder.Resolution.Width <= 0 || p.Encoder.Resolution.Width > 32768 || p.Encoder.Resolution.Height <= 0 || p.Encoder.Resolution.Height > 32768 || len(p.Encoder.Encoding) > 32 {
|
||||
continue
|
||||
}
|
||||
result = append(result, Profile{Token: p.Token, Name: p.Name, Width: p.Encoder.Resolution.Width, Height: p.Encoder.Resolution.Height, Encoding: p.Encoder.Encoding})
|
||||
}
|
||||
if len(result) == 0 {
|
||||
return nil, ErrInvalidResponse
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func parseElement(data []byte, parent, name string) (string, error) {
|
||||
decoder := xml.NewDecoder(strings.NewReader(string(data)))
|
||||
depth := 0
|
||||
for {
|
||||
token, err := decoder.Token()
|
||||
if err != nil {
|
||||
if errors.Is(err, io.EOF) {
|
||||
return "", ErrInvalidResponse
|
||||
}
|
||||
return "", ErrInvalidResponse
|
||||
}
|
||||
switch value := token.(type) {
|
||||
case xml.StartElement:
|
||||
if parent == "" || value.Name.Local == parent {
|
||||
if value.Name.Local == parent {
|
||||
depth++
|
||||
}
|
||||
}
|
||||
if (parent == "" || depth > 0) && value.Name.Local == name {
|
||||
var text string
|
||||
if err := decoder.DecodeElement(&text, &value); err != nil {
|
||||
return "", ErrInvalidResponse
|
||||
}
|
||||
return strings.TrimSpace(text), nil
|
||||
}
|
||||
case xml.EndElement:
|
||||
if value.Name.Local == parent && depth > 0 {
|
||||
depth--
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
package onvif
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"net"
|
||||
"net/url"
|
||||
"strings"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrTargetNotAllowed = errors.New("目标地址不在获准网段内")
|
||||
ErrAddressInvalid = errors.New("设备地址格式不正确")
|
||||
)
|
||||
|
||||
type Policy struct{ Networks []*net.IPNet }
|
||||
|
||||
func ParsePolicy(value string) (Policy, error) {
|
||||
var policy Policy
|
||||
for _, item := range strings.Split(value, ",") {
|
||||
item = strings.TrimSpace(item)
|
||||
if item == "" {
|
||||
continue
|
||||
}
|
||||
_, network, err := net.ParseCIDR(item)
|
||||
if err != nil {
|
||||
return Policy{}, ErrTargetNotAllowed
|
||||
}
|
||||
policy.Networks = append(policy.Networks, network)
|
||||
}
|
||||
if len(policy.Networks) == 0 {
|
||||
return Policy{}, ErrTargetNotAllowed
|
||||
}
|
||||
return policy, nil
|
||||
}
|
||||
|
||||
func (p Policy) ValidateURL(ctx context.Context, raw string, schemes ...string) (*url.URL, net.IP, error) {
|
||||
u, err := url.Parse(strings.TrimSpace(raw))
|
||||
if err != nil || u.Hostname() == "" || u.User != nil || u.Fragment != "" {
|
||||
return nil, nil, ErrAddressInvalid
|
||||
}
|
||||
for key := range u.Query() {
|
||||
lower := strings.ToLower(key)
|
||||
for _, sensitive := range []string{"user", "password", "passwd", "token", "auth", "credential", "secret", "key"} {
|
||||
if strings.Contains(lower, sensitive) {
|
||||
return nil, nil, ErrAddressInvalid
|
||||
}
|
||||
}
|
||||
}
|
||||
allowedScheme := false
|
||||
for _, scheme := range schemes {
|
||||
if strings.EqualFold(u.Scheme, scheme) {
|
||||
allowedScheme = true
|
||||
}
|
||||
}
|
||||
if !allowedScheme {
|
||||
return nil, nil, ErrAddressInvalid
|
||||
}
|
||||
addresses, err := net.DefaultResolver.LookupIP(ctx, "ip", u.Hostname())
|
||||
if err != nil || len(addresses) == 0 {
|
||||
return nil, nil, ErrTargetNotAllowed
|
||||
}
|
||||
for _, address := range addresses {
|
||||
ok := false
|
||||
for _, network := range p.Networks {
|
||||
if network.Contains(address) {
|
||||
ok = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !ok {
|
||||
return nil, nil, ErrTargetNotAllowed
|
||||
}
|
||||
}
|
||||
return u, addresses[0], nil
|
||||
}
|
||||
Reference in New Issue
Block a user