set UserEventSizeLimit to 90K

liuxiaolong

2022-06-28 37714b1093c04061e636e5b1d27179652e671c0a

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
package dns
 
import (
    "crypto/sha1"
    "encoding/hex"
    "strings"
)
 
// HashName hashes a string (label) according to RFC 5155. It returns the hashed string in uppercase.
func HashName(label string, ha uint8, iter uint16, salt string) string {
    if ha != SHA1 {
        return ""
    }
 
    wireSalt := make([]byte, hex.DecodedLen(len(salt)))
    n, err := packStringHex(salt, wireSalt, 0)
    if err != nil {
        return ""
    }
    wireSalt = wireSalt[:n]
 
    name := make([]byte, 255)
    off, err := PackDomainName(strings.ToLower(label), name, 0, nil, false)
    if err != nil {
        return ""
    }
    name = name[:off]
 
    s := sha1.New()
    // k = 0
    s.Write(name)
    s.Write(wireSalt)
    nsec3 := s.Sum(nil)
 
    // k > 0
    for k := uint16(0); k < iter; k++ {
        s.Reset()
        s.Write(nsec3)
        s.Write(wireSalt)
        nsec3 = s.Sum(nsec3[:0])
    }
 
    return toBase32(nsec3)
}
 
// Cover returns true if a name is covered by the NSEC3 record
func (rr *NSEC3) Cover(name string) bool {
    nameHash := HashName(name, rr.Hash, rr.Iterations, rr.Salt)
    owner := strings.ToUpper(rr.Hdr.Name)
    labelIndices := Split(owner)
    if len(labelIndices) < 2 {
        return false
    }
    ownerHash := owner[:labelIndices[1]-1]
    ownerZone := owner[labelIndices[1]:]
    if !IsSubDomain(ownerZone, strings.ToUpper(name)) { // name is outside owner zone
        return false
    }
 
    nextHash := rr.NextDomain
 
    // if empty interval found, try cover wildcard hashes so nameHash shouldn't match with ownerHash
    if ownerHash == nextHash && nameHash != ownerHash { // empty interval
        return true
    }
    if ownerHash > nextHash { // end of zone
        if nameHash > ownerHash { // covered since there is nothing after ownerHash
            return true
        }
        return nameHash < nextHash // if nameHash is before beginning of zone it is covered
    }
    if nameHash < ownerHash { // nameHash is before ownerHash, not covered
        return false
    }
    return nameHash < nextHash // if nameHash is before nextHash is it covered (between ownerHash and nextHash)
}
 
// Match returns true if a name matches the NSEC3 record
func (rr *NSEC3) Match(name string) bool {
    nameHash := HashName(name, rr.Hash, rr.Iterations, rr.Salt)
    owner := strings.ToUpper(rr.Hdr.Name)
    labelIndices := Split(owner)
    if len(labelIndices) < 2 {
        return false
    }
    ownerHash := owner[:labelIndices[1]-1]
    ownerZone := owner[labelIndices[1]:]
    if !IsSubDomain(ownerZone, strings.ToUpper(name)) { // name is outside owner zone
        return false
    }
    if ownerHash == nameHash {
        return true
    }
    return false
}