forked from prometheus/blackbox_exporter
-
Notifications
You must be signed in to change notification settings - Fork 0
/
tcp.go
194 lines (177 loc) · 6.74 KB
/
tcp.go
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
// Copyright 2016 The Prometheus Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package prober
import (
"bufio"
"context"
"crypto/tls"
"fmt"
"net"
"regexp"
"github.com/go-kit/kit/log"
"github.com/go-kit/kit/log/level"
"github.com/prometheus/client_golang/prometheus"
pconfig "github.com/prometheus/common/config"
"github.com/prometheus/blackbox_exporter/config"
)
func dialTCP(ctx context.Context, target string, module config.Module, registry *prometheus.Registry, logger log.Logger) (net.Conn, error) {
var dialProtocol, dialTarget string
dialer := &net.Dialer{}
targetAddress, port, err := net.SplitHostPort(target)
if err != nil {
level.Error(logger).Log("msg", "Error splitting target address and port", "err", err)
return nil, err
}
ip, _, err := chooseProtocol(module.TCP.PreferredIPProtocol, targetAddress, registry, logger)
if err != nil {
level.Error(logger).Log("msg", "Error resolving address", "err", err)
return nil, err
}
if ip.IP.To4() == nil {
dialProtocol = "tcp6"
} else {
dialProtocol = "tcp4"
}
if len(module.TCP.SourceIPAddress) > 0 {
srcIP := net.ParseIP(module.TCP.SourceIPAddress)
if srcIP == nil {
level.Error(logger).Log("msg", "Error parsing source ip address", "srcIP", module.TCP.SourceIPAddress)
return nil, fmt.Errorf("Error parsing source ip address: %s", module.TCP.SourceIPAddress)
}
level.Info(logger).Log("msg", "Using local address", "srcIP", srcIP)
dialer.LocalAddr = &net.TCPAddr{IP: srcIP}
}
dialTarget = net.JoinHostPort(ip.String(), port)
if !module.TCP.TLS {
level.Info(logger).Log("msg", "Dialing TCP without TLS")
return dialer.DialContext(ctx, dialProtocol, dialTarget)
}
tlsConfig, err := pconfig.NewTLSConfig(&module.TCP.TLSConfig)
if err != nil {
level.Error(logger).Log("msg", "Error creating TLS configuration", "err", err)
return nil, err
}
if len(tlsConfig.ServerName) == 0 {
// If there is no `server_name` in tls_config, use
// targetAddress as TLS-servername. Normally tls.DialWithDialer
// would do this for us, but we pre-resolved the name by
// `chooseProtocol` and pass the IP-address for dialing (prevents
// resolving twice).
// For this reason we need to specify the original targetAddress
// via tlsConfig to enable hostname verification.
tlsConfig.ServerName = targetAddress
}
timeoutDeadline, _ := ctx.Deadline()
dialer.Deadline = timeoutDeadline
level.Info(logger).Log("msg", "Dialing TCP with TLS")
return tls.DialWithDialer(dialer, dialProtocol, dialTarget, tlsConfig)
}
func ProbeTCP(ctx context.Context, target string, module config.Module, registry *prometheus.Registry, logger log.Logger) bool {
probeSSLEarliestCertExpiry := prometheus.NewGauge(prometheus.GaugeOpts{
Name: "probe_ssl_earliest_cert_expiry",
Help: "Returns earliest SSL cert expiry date",
})
probeFailedDueToRegex := prometheus.NewGauge(prometheus.GaugeOpts{
Name: "probe_failed_due_to_regex",
Help: "Indicates if probe failed due to regex",
})
registry.MustRegister(probeFailedDueToRegex)
deadline, _ := ctx.Deadline()
conn, err := dialTCP(ctx, target, module, registry, logger)
if err != nil {
level.Error(logger).Log("msg", "Error dialing TCP", "err", err)
return false
}
defer conn.Close()
level.Info(logger).Log("msg", "Successfully dialed")
// Set a deadline to prevent the following code from blocking forever.
// If a deadline cannot be set, better fail the probe by returning an error
// now rather than blocking forever.
if err := conn.SetDeadline(deadline); err != nil {
level.Error(logger).Log("msg", "Error setting deadline", "err", err)
return false
}
if module.TCP.TLS {
state := conn.(*tls.Conn).ConnectionState()
registry.MustRegister(probeSSLEarliestCertExpiry)
probeSSLEarliestCertExpiry.Set(float64(getEarliestCertExpiry(&state).Unix()))
}
scanner := bufio.NewScanner(conn)
for i, qr := range module.TCP.QueryResponse {
level.Info(logger).Log("msg", "Processing query response entry", "entry_number", i)
send := qr.Send
if qr.Expect != "" {
re, err := regexp.Compile(qr.Expect)
if err != nil {
level.Error(logger).Log("msg", "Could not compile into regular expression", "regexp", qr.Expect, "err", err)
return false
}
var match []int
// Read lines until one of them matches the configured regexp.
for scanner.Scan() {
level.Debug(logger).Log("msg", "Read line", "line", scanner.Text())
match = re.FindSubmatchIndex(scanner.Bytes())
if match != nil {
level.Info(logger).Log("msg", "Regexp matched", "regexp", re, "line", scanner.Text())
break
}
}
if scanner.Err() != nil {
level.Error(logger).Log("msg", "Error reading from connection", "err", scanner.Err().Error())
return false
}
if match == nil {
probeFailedDueToRegex.Set(1)
level.Error(logger).Log("msg", "Regexp did not match", "regexp", re, "line", scanner.Text())
return false
}
probeFailedDueToRegex.Set(0)
send = string(re.Expand(nil, []byte(send), scanner.Bytes(), match))
}
if send != "" {
level.Debug(logger).Log("msg", "Sending line", "line", send)
if _, err := fmt.Fprintf(conn, "%s\n", send); err != nil {
level.Error(logger).Log("msg", "Failed to send", "err", err)
return false
}
}
if qr.StartTLS {
// Upgrade TCP connection to TLS.
tlsConfig, err := pconfig.NewTLSConfig(&module.TCP.TLSConfig)
if err != nil {
level.Error(logger).Log("msg", "Failed to create TLS configuration", "err", err)
return false
}
if tlsConfig.ServerName == "" {
// Use target-hostname as default for TLS-servername.
targetAddress, _, _ := net.SplitHostPort(target) // Had succeeded in dialTCP already.
tlsConfig.ServerName = targetAddress
}
tlsConn := tls.Client(conn, tlsConfig)
defer tlsConn.Close()
// Initiate TLS handshake (required here to get TLS state).
if err := tlsConn.Handshake(); err != nil {
level.Error(logger).Log("msg", "TLS Handshake (client) failed", "err", err)
return false
}
level.Info(logger).Log("msg", "TLS Handshake (client) succeeded.")
conn = net.Conn(tlsConn)
scanner = bufio.NewScanner(conn)
// Get certificate expiry.
state := tlsConn.ConnectionState()
registry.MustRegister(probeSSLEarliestCertExpiry)
probeSSLEarliestCertExpiry.Set(float64(getEarliestCertExpiry(&state).Unix()))
}
}
return true
}