|
|
@@ -12,17 +12,16 @@ import (
|
|
12
|
12
|
|
|
13
|
13
|
"github.com/9seconds/mtg/v2/ipblocklist/files"
|
|
14
|
14
|
"github.com/9seconds/mtg/v2/mtglib"
|
|
15
|
|
- "github.com/kentik/patricia"
|
|
16
|
|
- "github.com/kentik/patricia/bool_tree"
|
|
17
|
15
|
"github.com/panjf2000/ants/v2"
|
|
|
16
|
+ "github.com/yl2chen/cidranger"
|
|
18
|
17
|
)
|
|
19
|
18
|
|
|
20
|
|
-const (
|
|
21
|
|
- fireholIPv4DefaultCIDR = 32
|
|
22
|
|
- fireholIPv6DefaultCIDR = 128
|
|
23
|
|
-)
|
|
|
19
|
+var (
|
|
|
20
|
+ fireholRegexpComment = regexp.MustCompile(`\s*#.*?$`)
|
|
24
|
21
|
|
|
25
|
|
-var fireholRegexpComment = regexp.MustCompile(`\s*#.*?$`)
|
|
|
22
|
+ fireholIPv4DefaultCIDR = net.CIDRMask(32, 32) // nolint: gomnd
|
|
|
23
|
+ fireholIPv6DefaultCIDR = net.CIDRMask(128, 128) // nolint: gomnd
|
|
|
24
|
+)
|
|
26
|
25
|
|
|
27
|
26
|
// Firehol is IPBlocklist which uses lists from FireHOL:
|
|
28
|
27
|
// https://iplists.firehol.org/
|
|
|
@@ -43,11 +42,11 @@ type Firehol struct {
|
|
43
|
42
|
logger mtglib.Logger
|
|
44
|
43
|
updateMutex sync.RWMutex
|
|
45
|
44
|
|
|
|
45
|
+ ranger cidranger.Ranger
|
|
|
46
|
+
|
|
46
|
47
|
blocklists []files.File
|
|
47
|
48
|
|
|
48
|
49
|
workerPool *ants.Pool
|
|
49
|
|
- treeV4 *bool_tree.TreeV4
|
|
50
|
|
- treeV6 *bool_tree.TreeV6
|
|
51
|
50
|
}
|
|
52
|
51
|
|
|
53
|
52
|
// Shutdown stop a background update process.
|
|
|
@@ -64,11 +63,12 @@ func (f *Firehol) Contains(ip net.IP) bool {
|
|
64
|
63
|
f.updateMutex.RLock()
|
|
65
|
64
|
defer f.updateMutex.RUnlock()
|
|
66
|
65
|
|
|
67
|
|
- if ip4 := ip.To4(); ip4 != nil {
|
|
68
|
|
- return f.containsIPv4(ip4)
|
|
|
66
|
+ ok, err := f.ranger.Contains(ip)
|
|
|
67
|
+ if err != nil {
|
|
|
68
|
+ f.logger.BindStr("ip", ip.String()).DebugError("Cannot check if ip is present", err)
|
|
69
|
69
|
}
|
|
70
|
70
|
|
|
71
|
|
- return f.containsIPv6(ip.To16())
|
|
|
71
|
+ return ok && err == nil
|
|
72
|
72
|
}
|
|
73
|
73
|
|
|
74
|
74
|
// Run starts a background update process.
|
|
|
@@ -103,26 +103,6 @@ func (f *Firehol) Run(updateEach time.Duration) {
|
|
103
|
103
|
}
|
|
104
|
104
|
}
|
|
105
|
105
|
|
|
106
|
|
-func (f *Firehol) containsIPv4(addr net.IP) bool {
|
|
107
|
|
- ip := patricia.NewIPv4AddressFromBytes(addr, 32) // nolint: gomnd
|
|
108
|
|
-
|
|
109
|
|
- if ok, _ := f.treeV4.FindDeepestTag(ip); ok {
|
|
110
|
|
- return true
|
|
111
|
|
- }
|
|
112
|
|
-
|
|
113
|
|
- return false
|
|
114
|
|
-}
|
|
115
|
|
-
|
|
116
|
|
-func (f *Firehol) containsIPv6(addr net.IP) bool {
|
|
117
|
|
- ip := patricia.NewIPv6Address(addr, 128) // nolint: gomnd
|
|
118
|
|
-
|
|
119
|
|
- if ok, _ := f.treeV6.FindDeepestTag(ip); ok {
|
|
120
|
|
- return true
|
|
121
|
|
- }
|
|
122
|
|
-
|
|
123
|
|
- return false
|
|
124
|
|
-}
|
|
125
|
|
-
|
|
126
|
106
|
func (f *Firehol) update() {
|
|
127
|
107
|
ctx, cancel := context.WithCancel(f.ctx)
|
|
128
|
108
|
defer cancel()
|
|
|
@@ -131,8 +111,7 @@ func (f *Firehol) update() {
|
|
131
|
111
|
wg.Add(len(f.blocklists))
|
|
132
|
112
|
|
|
133
|
113
|
treeMutex := &sync.Mutex{}
|
|
134
|
|
- v4tree := bool_tree.NewTreeV4()
|
|
135
|
|
- v6tree := bool_tree.NewTreeV6()
|
|
|
114
|
+ ranger := cidranger.NewPCTrieRanger()
|
|
136
|
115
|
|
|
137
|
116
|
for _, v := range f.blocklists {
|
|
138
|
117
|
go func(file files.File) {
|
|
|
@@ -149,7 +128,7 @@ func (f *Firehol) update() {
|
|
149
|
128
|
|
|
150
|
129
|
defer fileContent.Close()
|
|
151
|
130
|
|
|
152
|
|
- if err := f.updateFromFile(treeMutex, v4tree, v6tree, bufio.NewScanner(fileContent)); err != nil {
|
|
|
131
|
+ if err := f.updateFromFile(treeMutex, ranger, bufio.NewScanner(fileContent)); err != nil {
|
|
153
|
132
|
logger.WarningError("update has failed", err)
|
|
154
|
133
|
}
|
|
155
|
134
|
}(v)
|
|
|
@@ -160,15 +139,13 @@ func (f *Firehol) update() {
|
|
160
|
139
|
f.updateMutex.Lock()
|
|
161
|
140
|
defer f.updateMutex.Unlock()
|
|
162
|
141
|
|
|
163
|
|
- f.treeV4 = v4tree
|
|
164
|
|
- f.treeV6 = v6tree
|
|
|
142
|
+ f.ranger = ranger
|
|
165
|
143
|
|
|
166
|
144
|
f.logger.Info("ip list was updated")
|
|
167
|
145
|
}
|
|
168
|
146
|
|
|
169
|
147
|
func (f *Firehol) updateFromFile(mutex sync.Locker,
|
|
170
|
|
- v4tree *bool_tree.TreeV4,
|
|
171
|
|
- v6tree *bool_tree.TreeV6,
|
|
|
148
|
+ ranger cidranger.Ranger,
|
|
172
|
149
|
scanner *bufio.Scanner) error {
|
|
173
|
150
|
for scanner.Scan() {
|
|
174
|
151
|
text := scanner.Text()
|
|
|
@@ -179,12 +156,18 @@ func (f *Firehol) updateFromFile(mutex sync.Locker,
|
|
179
|
156
|
continue
|
|
180
|
157
|
}
|
|
181
|
158
|
|
|
182
|
|
- ip, cidr, err := f.updateParseLine(text)
|
|
|
159
|
+ ipnet, err := f.updateParseLine(text)
|
|
183
|
160
|
if err != nil {
|
|
184
|
161
|
return fmt.Errorf("cannot parse a line: %w", err)
|
|
185
|
162
|
}
|
|
186
|
163
|
|
|
187
|
|
- f.updateAddToTrees(ip, cidr, mutex, v4tree, v6tree)
|
|
|
164
|
+ mutex.Lock()
|
|
|
165
|
+ err = ranger.Insert(cidranger.NewBasicRangerEntry(*ipnet))
|
|
|
166
|
+ mutex.Unlock()
|
|
|
167
|
+
|
|
|
168
|
+ if err != nil {
|
|
|
169
|
+ return fmt.Errorf("cannot insert %v into ranger: %w", ipnet, err)
|
|
|
170
|
+ }
|
|
188
|
171
|
}
|
|
189
|
172
|
|
|
190
|
173
|
if scanner.Err() != nil {
|
|
|
@@ -194,38 +177,26 @@ func (f *Firehol) updateFromFile(mutex sync.Locker,
|
|
194
|
177
|
return nil
|
|
195
|
178
|
}
|
|
196
|
179
|
|
|
197
|
|
-func (f *Firehol) updateParseLine(text string) (net.IP, uint, error) {
|
|
198
|
|
- _, ipnet, err := net.ParseCIDR(text)
|
|
199
|
|
- if err != nil {
|
|
200
|
|
- ipaddr := net.ParseIP(text)
|
|
201
|
|
- if ipaddr == nil {
|
|
202
|
|
- return nil, 0, fmt.Errorf("incorrect ip address %s", text)
|
|
203
|
|
- }
|
|
204
|
|
-
|
|
205
|
|
- ip4 := ipaddr.To4()
|
|
206
|
|
- if ip4 != nil {
|
|
207
|
|
- return ip4, fireholIPv4DefaultCIDR, nil
|
|
208
|
|
- }
|
|
209
|
|
-
|
|
210
|
|
- return ipaddr.To16(), fireholIPv6DefaultCIDR, nil
|
|
|
180
|
+func (f *Firehol) updateParseLine(text string) (*net.IPNet, error) {
|
|
|
181
|
+ if _, ipnet, err := net.ParseCIDR(text); err == nil {
|
|
|
182
|
+ return ipnet, nil
|
|
211
|
183
|
}
|
|
212
|
184
|
|
|
213
|
|
- ones, _ := ipnet.Mask.Size()
|
|
214
|
|
-
|
|
215
|
|
- return ipnet.IP, uint(ones), nil
|
|
216
|
|
-}
|
|
|
185
|
+ ipaddr := net.ParseIP(text)
|
|
|
186
|
+ if ipaddr == nil {
|
|
|
187
|
+ return nil, fmt.Errorf("incorrect ip address %s", text)
|
|
|
188
|
+ }
|
|
217
|
189
|
|
|
218
|
|
-func (f *Firehol) updateAddToTrees(ip net.IP, cidr uint,
|
|
219
|
|
- mutex sync.Locker,
|
|
220
|
|
- v4tree *bool_tree.TreeV4, v6tree *bool_tree.TreeV6) {
|
|
221
|
|
- mutex.Lock()
|
|
222
|
|
- defer mutex.Unlock()
|
|
|
190
|
+ mask := fireholIPv4DefaultCIDR
|
|
223
|
191
|
|
|
224
|
|
- if ip.To4() != nil {
|
|
225
|
|
- v4tree.Set(patricia.NewIPv4AddressFromBytes(ip, cidr), true)
|
|
226
|
|
- } else {
|
|
227
|
|
- v6tree.Set(patricia.NewIPv6Address(ip, cidr), true)
|
|
|
192
|
+ if ipaddr.To4() == nil {
|
|
|
193
|
+ mask = fireholIPv6DefaultCIDR
|
|
228
|
194
|
}
|
|
|
195
|
+
|
|
|
196
|
+ return &net.IPNet{
|
|
|
197
|
+ IP: ipaddr,
|
|
|
198
|
+ Mask: mask,
|
|
|
199
|
+ }, nil
|
|
229
|
200
|
}
|
|
230
|
201
|
|
|
231
|
202
|
// NewFirehol creates a new instance of FireHOL IP blocklist.
|
|
|
@@ -275,8 +246,7 @@ func NewFireholFromFiles(logger mtglib.Logger,
|
|
275
|
246
|
ctx: ctx,
|
|
276
|
247
|
ctxCancel: cancel,
|
|
277
|
248
|
logger: logger.Named("firehol"),
|
|
278
|
|
- treeV4: bool_tree.NewTreeV4(),
|
|
279
|
|
- treeV6: bool_tree.NewTreeV6(),
|
|
|
249
|
+ ranger: cidranger.NewPCTrieRanger(),
|
|
280
|
250
|
workerPool: workerPool,
|
|
281
|
251
|
blocklists: blocklists,
|
|
282
|
252
|
}, nil
|