-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathnebman.py
executable file
·372 lines (340 loc) · 60.4 KB
/
nebman.py
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
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
#!/usr/bin/python3
##
## required imports
import os.path
import subprocess
import sqlite3
import sys
import requests
import shutil
import tarfile
import base64
# Set Constants
NEBMANDB='nebmanDB.db'
CURRENTVERSION='1.9.5'
# Set global variables
existingLighthouseID = 10
existingEndpointID = 50
existingNetwork = "notset"
existingVersion='Unknown'
# terminal colour text codes (found via a so page)
class bcolors:
GREEN = '\033[92m'
ORANGE = '\033[93m'
RED = '\033[91m'
END = '\033[0m'
vmTag = ''
# Report on the current state of key elements of the app.
def checkState():
# Ref gobal variable
global existingVersion
# Does the DB exist
if os.path.exists(NEBMANDB):
print("- Database is found: " + bcolors.GREEN + "Yes" + bcolors.END)
else:
print("- Database is found: " + bcolors.RED + "No" + bcolors.END)
# Does the Certs folder exist
if os.path.exists('./certs/'):
print("- Certs folder is found: " + bcolors.GREEN + "Yes" + bcolors.END)
else:
print("- Certs folder is found: " + bcolors.RED + "No" + bcolors.END)
# Does the CA exist
if os.path.exists('./certs/ca.crt') and os.path.exists('./certs/ca.key'):
print("- CA cert and key are found: " + bcolors.GREEN + "Yes" + bcolors.END)
else:
print("- CA cert and key are found: " + bcolors.RED + "No" + bcolors.END)
# Does nebula binary exist and if so what's the version.
if os.path.exists('nebula'):
getNewVersion="./nebula --version"
existingVersion = str(subprocess.check_output(getNewVersion, shell=True))
existingVersion = str(existingVersion[11:16])
print("- Nebula binary found, version: " + existingVersion)
else:
print("- Nebula binary note found: " + bcolors.RED + "Not found" + bcolors.END)
# initialise a new DB for nebman or load settings if existing DB and contents are located.
def initDB():
# check if database file exists, if not, create it.
if not os.path.exists(NEBMANDB):
dbConnect = sqlite3.connect(NEBMANDB)
dbCurser = dbConnect.cursor()
dbCurser.execute("CREATE TABLE nebmanClients(id, hostname, network, lighthouse, os, services, version, UNIQUE(hostname))")
dbConnect.commit()
dbConnect.close()
# confirm DB exists, in case create above failed/ did not complete.
if not os.path.exists(NEBMANDB):
sys.exit("Database does not exist, exiting")
# if database does exist set required values
else:
# Reference the global variables
global existingLighthouseID
global existingEndpointID
global existingNetwork
dbConnect = sqlite3.connect(NEBMANDB)
dbCurser = dbConnect.cursor()
dbContent = dbCurser.execute("SELECT * FROM nebmanClients")
for row in dbContent:
existingNetwork = row[2]
if row[3] == 'y':
if row[0] > existingLighthouseID:
existingLighthouseID = row[0]
else:
if row[0] > existingEndpointID:
existingEndpointID = row[0]
# Add a function to create ansible directory for inventory file
def ansibleInit():
if not os.path.exists('ansible'):
os.makedirs('ansible')
if not os.path.exists('ansible/inventory'):
os.makedirs('ansible/inventory')
if not os.path.exists('ansible/playbooks'):
os.makedirs('ansible/playbooks')
if not os.path.exists('ansible/playbooks/templates'):
os.makedirs('ansible/playbooks/templates')
if not os.path.exists('ansible/playbooks/files'):
os.makedirs('ansible/playbooks/files')
def ansibleGen():
# Generate ansile directory structure if it doesn't exist.
ansibleInit()
# Generate inventory file once database exists
if not os.path.exists(NEBMANDB):
sys.exit("Database does not exist, exiting")
elif existingNetwork == "notset":
sys.exit("Network not configured, please ensure hosts including a lighthouse are defined, exiting")
else:
# open DB connection and iterate through to find Lighthouse details
x = 0
dbConnect = sqlite3.connect(NEBMANDB)
dbCurser = dbConnect.cursor()
dbContent = dbCurser.execute("SELECT * FROM nebmanClients")
for row in dbContent:
if row[3] == 'y' and x < 1:
lighthouseHostname = row[1]
lighthouseIP = existingNetwork + "." + str(row[0])
x+=1
dbConnect.close()
# open DB connection and filestream for ansible inventory.ini file to find host details
dbConnect = sqlite3.connect(NEBMANDB)
dbCurser = dbConnect.cursor()
dbContent = dbCurser.execute("SELECT * FROM nebmanClients")
ansIventory = open("ansible/inventory/inventory.ini", "w")
ansIventory.write("[nebula]\n")
for row in dbContent:
ansIventory.write(row[1]+" cert_name="+row[1]+" lighthouse_ip="+lighthouseIP+" lighthouse_hostname="+lighthouseHostname+"\n")
# Write hostnames out to inventory file
for row in dbContent:
ansIventory.write(row[1]+" cert_name="+row[1]+"\n")
# Close DB connection and file stream
dbConnect.close()
ansIventory.close()
# Copy nebula binary to Ansible files folder.
if os.path.exists("nebula"):
shutil.copy2('./nebula', './ansible/playbooks/files/nebula')
# Copy certs to Ansible files folder.
if os.path.exists("certs"):
shutil.copytree('certs', './ansible/playbooks/files/certs', dirs_exist_ok=True)
# Write ansible playbook out to file from base64 version
# base64 of playbook to simplify storage
ansPlaybook="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"
ansPlaybookDecode = base64.b64decode(ansPlaybook)
ansPlaybookDecode = ansPlaybookDecode.decode("utf-8")
ansPlaybook = open("ansible/playbooks/nebula.yml", "w")
ansPlaybook.write(ansPlaybookDecode)
ansPlaybook.close()
# Write Linux service config template out to file from base64 version
# base64 of template to simplify storage
ansLinuxService="W1VuaXRdCkRlc2NyaXB0aW9uPU5lYnVsYSBNZXNoIFNlcnZpY2UKQWZ0ZXI9bmV0d29yay50YXJnZXQKCltTZXJ2aWNlXQpFeGVjU3RhcnQ9L3Vzci9sb2NhbC9iaW4vbmVidWxhL25lYnVsYSAtY29uZmlnIC91c3IvbG9jYWwvYmluL25lYnVsYS97eyBjZXJ0X25hbWUgfX0ueW1sClJlc3RhcnQ9YWx3YXlzCgpbSW5zdGFsbF0KV2FudGVkQnk9bXVsdGktdXNlci50YXJnZXQ="
ansLinuxServiceDecode = base64.b64decode(ansLinuxService)
ansLinuxServiceDecode = ansLinuxServiceDecode.decode("utf-8")
ansLinuxService = open("ansible/playbooks/templates/nebula.service.j2", "w")
ansLinuxService.write(ansLinuxServiceDecode)
ansLinuxService.close()
# Write Nebula Endpoint config template out to file from base64 version
# base64 of template to simplify storage
ansNebulaEndpointConfig="# This is the nebula example configuration file. You must edit, at a minimum, the static_host_map, lighthouse, and firewall sections
# Some options in this file are HUPable, including the pki section. (A HUP will reload credentials from disk without affecting existing tunnels)

# PKI defines the location of credentials for this node. Each of these can also be inlined by using the yaml ": |" syntax.
pki:
  # The CAs that are accepted by this node. Must contain one or more certificates created by 'nebula-cert ca'
  ca: /usr/local/bin/nebula/ca.crt
  cert: /usr/local/bin/nebula/{{ cert_name }}.crt
  key: /usr/local/bin/nebula/{{ cert_name }}.key
  # blocklist is a list of certificate fingerprints that we will refuse to talk to
  #blocklist:
  #  - c99d4e650533b92061b09918e838a5a0a6aaee21eed1d12fd937682865936c72
  # disconnect_invalid is a toggle to force a client to be disconnected if the certificate is expired or invalid.
  #disconnect_invalid: false

# The static host map defines a set of hosts with fixed IP addresses on the internet (or any network).
# A host can have multiple fixed IP addresses defined here, and nebula will try each when establishing a tunnel.
# The syntax is:
#   "{nebula ip}": ["{routable ip/dns name}:{routable port}"]
# Example, if your lighthouse has the nebula IP of 192.168.100.1 and has the real ip address of 100.64.22.11 and runs on port 4242:
static_host_map:
  "{{ lighthouse_ip }}": ["{{ lighthouse_hostname }}:4242"]

# The static_map config stanza can be used to configure how the static_host_map behaves.
#static_map:
  # cadence determines how frequently DNS is re-queried for updated IP addresses when a static_host_map entry contains
  # a DNS name.
  #cadence: 30s

  # network determines the type of IP addresses to ask the DNS server for. The default is "ip4" because nodes typically
  # do not know their public IPv4 address. Connecting to the Lighthouse via IPv4 allows the Lighthouse to detect the
  # public address. Other valid options are "ip6" and "ip" (returns both.)
  #network: ip4

  # lookup_timeout is the DNS query timeout.
  #lookup_timeout: 250ms

lighthouse:
  # am_lighthouse is used to enable lighthouse functionality for a node. This should ONLY be true on nodes
  # you have configured to be lighthouses in your network
  am_lighthouse: false
  # serve_dns optionally starts a dns listener that responds to various queries and can even be
  # delegated to for resolution
  #serve_dns: false
  #dns:
    # The DNS host defines the IP to bind the dns listener to. This also allows binding to the nebula node IP.
    #host: 0.0.0.0
    #port: 53
  # interval is the number of seconds between updates from this node to a lighthouse.
  # during updates, a node sends information about its current IP addresses to each node.
  interval: 60
  # hosts is a list of lighthouse hosts this node should report to and query from
  # IMPORTANT: THIS SHOULD BE EMPTY ON LIGHTHOUSE NODES
  # IMPORTANT2: THIS SHOULD BE LIGHTHOUSES' NEBULA IPs, NOT LIGHTHOUSES' REAL ROUTABLE IPs
  hosts:
    - "{{ lighthouse_ip }}"

  # remote_allow_list allows you to control ip ranges that this node will
  # consider when handshaking to another node. By default, any remote IPs are
  # allowed. You can provide CIDRs here with `true` to allow and `false` to
  # deny. The most specific CIDR rule applies to each remote. If all rules are
  # "allow", the default will be "deny", and vice-versa. If both "allow" and
  # "deny" IPv4 rules are present, then you MUST set a rule for "0.0.0.0/0" as
  # the default. Similarly if both "allow" and "deny" IPv6 rules are present,
  # then you MUST set a rule for "::/0" as the default.
  #remote_allow_list:
    # Example to block IPs from this subnet from being used for remote IPs.
    #"172.16.0.0/12": false

    # A more complicated example, allow public IPs but only private IPs from a specific subnet
    #"0.0.0.0/0": true
    #"10.0.0.0/8": false
    #"10.42.42.0/24": true

  # EXPERIMENTAL: This option may change or disappear in the future.
  # Optionally allows the definition of remote_allow_list blocks
  # specific to an inside VPN IP CIDR.
  #remote_allow_ranges:
    # This rule would only allow only private IPs for this VPN range
    #"10.42.42.0/24":
      #"192.168.0.0/16": true

  # local_allow_list allows you to filter which local IP addresses we advertise
  # to the lighthouses. This uses the same logic as `remote_allow_list`, but
  # additionally, you can specify an `interfaces` map of regular expressions
  # to match against interface names. The regexp must match the entire name.
  # All interface rules must be either true or false (and the default will be
  # the inverse). CIDR rules are matched after interface name rules.
  # Default is all local IP addresses.
  #local_allow_list:
    # Example to block tun0 and all docker interfaces.
    #interfaces:
      #tun0: false
      #'docker.*': false
    # Example to only advertise this subnet to the lighthouse.
    #"10.0.0.0/8": true

  # advertise_addrs are routable addresses that will be included along with discovered addresses to report to the
  # lighthouse, the format is "ip:port". `port` can be `0`, in which case the actual listening port will be used in its
  # place, useful if `listen.port` is set to 0.
  # This option is mainly useful when there are static ip addresses the host can be reached at that nebula can not
  # typically discover on its own. Examples being port forwarding or multiple paths to the internet.
  #advertise_addrs:
    #- "1.1.1.1:4242"
    #- "1.2.3.4:0" # port will be replaced with the real listening port

  # EXPERIMENTAL: This option may change or disappear in the future.
  # This setting allows us to "guess" what the remote might be for a host
  # while we wait for the lighthouse response.
  #calculated_remotes:
    # For any Nebula IPs in 10.0.10.0/24, this will apply the mask and add
    # the calculated IP as an initial remote (while we wait for the response
    # from the lighthouse). Both CIDRs must have the same mask size.
    # For example, Nebula IP 10.0.10.123 will have a calculated remote of
    # 192.168.1.123
    #10.0.10.0/24:
      #- mask: 192.168.1.0/24
      #  port: 4242

# Port Nebula will be listening on. The default here is 4242. For a lighthouse node, the port should be defined,
# however using port 0 will dynamically assign a port and is recommended for roaming nodes.
listen:
  # To listen on both any ipv4 and ipv6 use "::"
  host: 0.0.0.0
  port: 0
  # Sets the max number of packets to pull from the kernel for each syscall (under systems that support recvmmsg)
  # default is 64, does not support reload
  #batch: 64
  # Configure socket buffers for the udp side (outside), leave unset to use the system defaults. Values will be doubled by the kernel
  # Default is net.core.rmem_default and net.core.wmem_default (/proc/sys/net/core/rmem_default and /proc/sys/net/core/rmem_default)
  # Maximum is limited by memory in the system, SO_RCVBUFFORCE and SO_SNDBUFFORCE is used to avoid having to raise the system wide
  # max, net.core.rmem_max and net.core.wmem_max
  #read_buffer: 10485760
  #write_buffer: 10485760
  # By default, Nebula replies to packets it has no tunnel for with a "recv_error" packet. This packet helps speed up reconnection
  # in the case that Nebula on either side did not shut down cleanly. This response can be abused as a way to discover if Nebula is running
  # on a host though. This option lets you configure if you want to send "recv_error" packets always, never, or only to private network remotes.
  # valid values: always, never, private
  # This setting is reloadable.
  #send_recv_error: always

# Routines is the number of thread pairs to run that consume from the tun and UDP queues.
# Currently, this defaults to 1 which means we have 1 tun queue reader and 1
# UDP queue reader. Setting this above one will set IFF_MULTI_QUEUE on the tun
# device and SO_REUSEPORT on the UDP socket to allow multiple queues.
# This option is only supported on Linux.
#routines: 1

punchy:
  # Continues to punch inbound/outbound at a regular interval to avoid expiration of firewall nat mappings
  punch: true

  # respond means that a node you are trying to reach will connect back out to you if your hole punching fails
  # this is extremely useful if one node is behind a difficult nat, such as a symmetric NAT
  # Default is false
  #respond: true

  # delays a punch response for misbehaving NATs, default is 1 second.
  #delay: 1s

  # set the delay before attempting punchy.respond. Default is 5 seconds. respond must be true to take effect.
  #respond_delay: 5s

# Cipher allows you to choose between the available ciphers for your network. Options are chachapoly or aes
# IMPORTANT: this value must be identical on ALL NODES/LIGHTHOUSES. We do not/will not support use of different ciphers simultaneously!
#cipher: aes

# Preferred ranges is used to define a hint about the local network ranges, which speeds up discovering the fastest
# path to a network adjacent nebula node.
# NOTE: the previous option "local_range" only allowed definition of a single range
# and has been deprecated for "preferred_ranges"
#preferred_ranges: ["172.16.0.0/24"]

# sshd can expose informational and administrative functions via ssh this is a
#sshd:
  # Toggles the feature
  #enabled: true
  # Host and port to listen on, port 22 is not allowed for your safety
  #listen: 127.0.0.1:2222
  # A file containing the ssh host private key to use
  # A decent way to generate one: ssh-keygen -t ed25519 -f ssh_host_ed25519_key -N "" < /dev/null
  #host_key: ./ssh_host_ed25519_key
  # A file containing a list of authorized public keys
  #authorized_users:
    #- user: steeeeve
      # keys can be an array of strings or single string
      #keys:
        #- "ssh public key string"

# EXPERIMENTAL: relay support for networks that can't establish direct connections.
relay:
  # Relays are a list of Nebula IP's that peers can use to relay packets to me.
  # IPs in this list must have am_relay set to true in their configs, otherwise
  # they will reject relay requests.
  #relays:
    #- 192.168.100.1
    #- <other Nebula VPN IPs of hosts used as relays to access me>
  # Set am_relay to true to permit other hosts to list my IP in their relays config. Default false.
  am_relay: false
  # Set use_relays to false to prevent this instance from attempting to establish connections through relays.
  # default true
  use_relays: true

# Configure the private interface. Note: addr is baked into the nebula certificate
tun:
  # When tun is disabled, a lighthouse can be started without a local tun interface (and therefore without root)
  disabled: false
  # Name of the device. If not set, a default will be chosen by the OS.
  # For macOS: if set, must be in the form `utun[0-9]+`.
  dev: nebula1
  # Toggles forwarding of local broadcast packets, the address of which depends on the ip/mask encoded in pki.cert
  drop_local_broadcast: false
  # Toggles forwarding of multicast packets
  drop_multicast: false
  # Sets the transmit queue length, if you notice lots of transmit drops on the tun it may help to raise this number. Default is 500
  tx_queue: 500
  # Default MTU for every packet, safe setting is (and the default) 1300 for internet based traffic
  mtu: 1300

  # Route based MTU overrides, you have known vpn ip paths that can support larger MTUs you can increase/decrease them here
  routes:
    #- mtu: 8800
    #  route: 10.0.0.0/16

  # Unsafe routes allows you to route traffic over nebula to non-nebula nodes
  # Unsafe routes should be avoided unless you have hosts/services that cannot run nebula
  # NOTE: The nebula certificate of the "via" node *MUST* have the "route" defined as a subnet in its certificate
  # `mtu`: will default to tun mtu if this option is not specified
  # `metric`: will default to 0 if this option is not specified
  # `install`: will default to true, controls whether this route is installed in the systems routing table.
  unsafe_routes:
    #- route: 172.16.1.0/24
    #  via: 192.168.100.99
    #  mtu: 1300
    #  metric: 100
    #  install: true

  # On linux only, set to true to manage unsafe routes directly on the system route table with gateway routes instead of
  # in nebula configuration files. Default false, not reloadable.
  #use_system_route_table: false

# TODO
# Configure logging level
logging:
  # panic, fatal, error, warning, info, or debug. Default is info
  level: info
  # json or text formats currently available. Default is text
  format: text
  # Disable timestamp logging. useful when output is redirected to logging system that already adds timestamps. Default is false
  #disable_timestamp: true
  # timestamp format is specified in Go time format, see:
  #     https://golang.org/pkg/time/#pkg-constants
  # default when `format: json`: "2006-01-02T15:04:05Z07:00" (RFC3339)
  # default when `format: text`:
  #     when TTY attached: seconds since beginning of execution
  #     otherwise: "2006-01-02T15:04:05Z07:00" (RFC3339)
  # As an example, to log as RFC3339 with millisecond precision, set to:
  #timestamp_format: "2006-01-02T15:04:05.000Z07:00"

#stats:
  #type: graphite
  #prefix: nebula
  #protocol: tcp
  #host: 127.0.0.1:9999
  #interval: 10s

  #type: prometheus
  #listen: 127.0.0.1:8080
  #path: /metrics
  #namespace: prometheusns
  #subsystem: nebula
  #interval: 10s

  # enables counter metrics for meta packets
  #   e.g.: `messages.tx.handshake`
  # NOTE: `message.{tx,rx}.recv_error` is always emitted
  #message_metrics: false

  # enables detailed counter metrics for lighthouse packets
  #   e.g.: `lighthouse.rx.HostQuery`
  #lighthouse_metrics: false

# Handshake Manager Settings
#handshakes:
  # Handshakes are sent to all known addresses at each interval with a linear backoff,
  # Wait try_interval after the 1st attempt, 2 * try_interval after the 2nd, etc, until the handshake is older than timeout
  # A 100ms interval with the default 10 retries will give a handshake 5.5 seconds to resolve before timing out
  #try_interval: 100ms
  #retries: 20
  # trigger_buffer is the size of the buffer channel for quickly sending handshakes
  # after receiving the response for lighthouse queries
  #trigger_buffer: 64


# Nebula security group configuration
firewall:
  # Action to take when a packet is not allowed by the firewall rules.
  # Can be one of:
  #   `drop` (default): silently drop the packet.
  #   `reject`: send a reject reply.
  #     - For TCP, this will be a RST "Connection Reset" packet.
  #     - For other protocols, this will be an ICMP port unreachable packet.
  outbound_action: drop
  inbound_action: drop

  conntrack:
    tcp_timeout: 12m
    udp_timeout: 3m
    default_timeout: 10m

  # The firewall is default deny. There is no way to write a deny rule.
  # Rules are comprised of a protocol, port, and one or more of host, group, or CIDR
  # Logical evaluation is roughly: port AND proto AND (ca_sha OR ca_name) AND (host OR group OR groups OR cidr)
  # - port: Takes `0` or `any` as any, a single number `80`, a range `200-901`, or `fragment` to match second and further fragments of fragmented packets (since there is no port available).
  #   code: same as port but makes more sense when talking about ICMP, TODO: this is not currently implemented in a way that works, use `any`
  #   proto: `any`, `tcp`, `udp`, or `icmp`
  #   host: `any` or a literal hostname, ie `test-host`
  #   group: `any` or a literal group name, ie `default-group`
  #   groups: Same as group but accepts a list of values. Multiple values are AND'd together and a certificate would have to contain all groups to pass
  #   cidr: a remote CIDR, `0.0.0.0/0` is any.
  #   local_cidr: a local CIDR, `0.0.0.0/0` is any. This could be used to filter destinations when using unsafe_routes.
  #   ca_name: An issuing CA name
  #   ca_sha: An issuing CA shasum

  outbound:
    # Allow all outbound traffic from this node
    - port: any
      proto: any
      host: any

  inbound:
    # Allow icmp between any nebula hosts
    - port: any
      proto: icmp
      host: any

    # Allow ssh
    - port: 22
      proto: tcp
      host: any

    # Allow tcp/443 from any host with BOTH laptop and home group
    - port: 443
      proto: tcp
      groups:
        - laptop
        - home"
ansNebulaConfigEndpointDecode = base64.b64decode(ansNebulaEndpointConfig)
ansNebulaConfigEndpointDecode = ansNebulaConfigEndpointDecode.decode("utf-8")
ansNebulaEndpointConfig = open("ansible/playbooks/templates/nebula-endpoint.yml.j2", "w")
ansNebulaEndpointConfig.write(ansNebulaConfigEndpointDecode)
ansNebulaEndpointConfig.close()
# Write Nebula Lighthouse config template out to file from base64 version
# base64 of template to simplify storage
ansNebulaLighthouseConfig="# This is the nebula example configuration file. You must edit, at a minimum, the static_host_map, lighthouse, and firewall sections
# Some options in this file are HUPable, including the pki section. (A HUP will reload credentials from disk without affecting existing tunnels)

# PKI defines the location of credentials for this node. Each of these can also be inlined by using the yaml ": |" syntax.
pki:
  # The CAs that are accepted by this node. Must contain one or more certificates created by 'nebula-cert ca'
  ca: /usr/local/bin/nebula/ca.crt
  cert: /usr/local/bin/nebula/{{ cert_name }}.crt
  key: /usr/local/bin/nebula/{{ cert_name }}.key
  # blocklist is a list of certificate fingerprints that we will refuse to talk to
  #blocklist:
  #  - c99d4e650533b92061b09918e838a5a0a6aaee21eed1d12fd937682865936c72
  # disconnect_invalid is a toggle to force a client to be disconnected if the certificate is expired or invalid.
  #disconnect_invalid: false

# The static host map defines a set of hosts with fixed IP addresses on the internet (or any network).
# A host can have multiple fixed IP addresses defined here, and nebula will try each when establishing a tunnel.
# The syntax is:
#   "{nebula ip}": ["{routable ip/dns name}:{routable port}"]
# Example, if your lighthouse has the nebula IP of 192.168.100.1 and has the real ip address of 100.64.22.11 and runs on port 4242:
static_host_map:
  "{{ lighthouse_ip }}": ["{{ lighthouse_hostname }}:4242"]

# The static_map config stanza can be used to configure how the static_host_map behaves.
#static_map:
  # cadence determines how frequently DNS is re-queried for updated IP addresses when a static_host_map entry contains
  # a DNS name.
  #cadence: 30s

  # network determines the type of IP addresses to ask the DNS server for. The default is "ip4" because nodes typically
  # do not know their public IPv4 address. Connecting to the Lighthouse via IPv4 allows the Lighthouse to detect the
  # public address. Other valid options are "ip6" and "ip" (returns both.)
  #network: ip4

  # lookup_timeout is the DNS query timeout.
  #lookup_timeout: 250ms

lighthouse:
  # am_lighthouse is used to enable lighthouse functionality for a node. This should ONLY be true on nodes
  # you have configured to be lighthouses in your network
  am_lighthouse: true
  # serve_dns optionally starts a dns listener that responds to various queries and can even be
  # delegated to for resolution
  #serve_dns: false
  #dns:
    # The DNS host defines the IP to bind the dns listener to. This also allows binding to the nebula node IP.
    #host: 0.0.0.0
    #port: 53
  # interval is the number of seconds between updates from this node to a lighthouse.
  # during updates, a node sends information about its current IP addresses to each node.
  interval: 60
  # hosts is a list of lighthouse hosts this node should report to and query from
  # IMPORTANT: THIS SHOULD BE EMPTY ON LIGHTHOUSE NODES
  # IMPORTANT2: THIS SHOULD BE LIGHTHOUSES' NEBULA IPs, NOT LIGHTHOUSES' REAL ROUTABLE IPs
  hosts:
    - "{{ lighthouse_ip }}"

  # remote_allow_list allows you to control ip ranges that this node will
  # consider when handshaking to another node. By default, any remote IPs are
  # allowed. You can provide CIDRs here with `true` to allow and `false` to
  # deny. The most specific CIDR rule applies to each remote. If all rules are
  # "allow", the default will be "deny", and vice-versa. If both "allow" and
  # "deny" IPv4 rules are present, then you MUST set a rule for "0.0.0.0/0" as
  # the default. Similarly if both "allow" and "deny" IPv6 rules are present,
  # then you MUST set a rule for "::/0" as the default.
  #remote_allow_list:
    # Example to block IPs from this subnet from being used for remote IPs.
    #"172.16.0.0/12": false

    # A more complicated example, allow public IPs but only private IPs from a specific subnet
    #"0.0.0.0/0": true
    #"10.0.0.0/8": false
    #"10.42.42.0/24": true

  # EXPERIMENTAL: This option may change or disappear in the future.
  # Optionally allows the definition of remote_allow_list blocks
  # specific to an inside VPN IP CIDR.
  #remote_allow_ranges:
    # This rule would only allow only private IPs for this VPN range
    #"10.42.42.0/24":
      #"192.168.0.0/16": true

  # local_allow_list allows you to filter which local IP addresses we advertise
  # to the lighthouses. This uses the same logic as `remote_allow_list`, but
  # additionally, you can specify an `interfaces` map of regular expressions
  # to match against interface names. The regexp must match the entire name.
  # All interface rules must be either true or false (and the default will be
  # the inverse). CIDR rules are matched after interface name rules.
  # Default is all local IP addresses.
  #local_allow_list:
    # Example to block tun0 and all docker interfaces.
    #interfaces:
      #tun0: false
      #'docker.*': false
    # Example to only advertise this subnet to the lighthouse.
    #"10.0.0.0/8": true

  # advertise_addrs are routable addresses that will be included along with discovered addresses to report to the
  # lighthouse, the format is "ip:port". `port` can be `0`, in which case the actual listening port will be used in its
  # place, useful if `listen.port` is set to 0.
  # This option is mainly useful when there are static ip addresses the host can be reached at that nebula can not
  # typically discover on its own. Examples being port forwarding or multiple paths to the internet.
  #advertise_addrs:
    #- "1.1.1.1:4242"
    #- "1.2.3.4:0" # port will be replaced with the real listening port

  # EXPERIMENTAL: This option may change or disappear in the future.
  # This setting allows us to "guess" what the remote might be for a host
  # while we wait for the lighthouse response.
  #calculated_remotes:
    # For any Nebula IPs in 10.0.10.0/24, this will apply the mask and add
    # the calculated IP as an initial remote (while we wait for the response
    # from the lighthouse). Both CIDRs must have the same mask size.
    # For example, Nebula IP 10.0.10.123 will have a calculated remote of
    # 192.168.1.123
    #10.0.10.0/24:
      #- mask: 192.168.1.0/24
      #  port: 4242

# Port Nebula will be listening on. The default here is 4242. For a lighthouse node, the port should be defined,
# however using port 0 will dynamically assign a port and is recommended for roaming nodes.
listen:
  # To listen on both any ipv4 and ipv6 use "::"
  host: 0.0.0.0
  port: 4242
  # Sets the max number of packets to pull from the kernel for each syscall (under systems that support recvmmsg)
  # default is 64, does not support reload
  #batch: 64
  # Configure socket buffers for the udp side (outside), leave unset to use the system defaults. Values will be doubled by the kernel
  # Default is net.core.rmem_default and net.core.wmem_default (/proc/sys/net/core/rmem_default and /proc/sys/net/core/rmem_default)
  # Maximum is limited by memory in the system, SO_RCVBUFFORCE and SO_SNDBUFFORCE is used to avoid having to raise the system wide
  # max, net.core.rmem_max and net.core.wmem_max
  #read_buffer: 10485760
  #write_buffer: 10485760
  # By default, Nebula replies to packets it has no tunnel for with a "recv_error" packet. This packet helps speed up reconnection
  # in the case that Nebula on either side did not shut down cleanly. This response can be abused as a way to discover if Nebula is running
  # on a host though. This option lets you configure if you want to send "recv_error" packets always, never, or only to private network remotes.
  # valid values: always, never, private
  # This setting is reloadable.
  #send_recv_error: always

# Routines is the number of thread pairs to run that consume from the tun and UDP queues.
# Currently, this defaults to 1 which means we have 1 tun queue reader and 1
# UDP queue reader. Setting this above one will set IFF_MULTI_QUEUE on the tun
# device and SO_REUSEPORT on the UDP socket to allow multiple queues.
# This option is only supported on Linux.
#routines: 1

punchy:
  # Continues to punch inbound/outbound at a regular interval to avoid expiration of firewall nat mappings
  punch: true

  # respond means that a node you are trying to reach will connect back out to you if your hole punching fails
  # this is extremely useful if one node is behind a difficult nat, such as a symmetric NAT
  # Default is false
  #respond: true

  # delays a punch response for misbehaving NATs, default is 1 second.
  #delay: 1s

  # set the delay before attempting punchy.respond. Default is 5 seconds. respond must be true to take effect.
  #respond_delay: 5s

# Cipher allows you to choose between the available ciphers for your network. Options are chachapoly or aes
# IMPORTANT: this value must be identical on ALL NODES/LIGHTHOUSES. We do not/will not support use of different ciphers simultaneously!
#cipher: aes

# Preferred ranges is used to define a hint about the local network ranges, which speeds up discovering the fastest
# path to a network adjacent nebula node.
# NOTE: the previous option "local_range" only allowed definition of a single range
# and has been deprecated for "preferred_ranges"
#preferred_ranges: ["172.16.0.0/24"]

# sshd can expose informational and administrative functions via ssh this is a
#sshd:
  # Toggles the feature
  #enabled: true
  # Host and port to listen on, port 22 is not allowed for your safety
  #listen: 127.0.0.1:2222
  # A file containing the ssh host private key to use
  # A decent way to generate one: ssh-keygen -t ed25519 -f ssh_host_ed25519_key -N "" < /dev/null
  #host_key: ./ssh_host_ed25519_key
  # A file containing a list of authorized public keys
  #authorized_users:
    #- user: steeeeve
      # keys can be an array of strings or single string
      #keys:
        #- "ssh public key string"

# EXPERIMENTAL: relay support for networks that can't establish direct connections.
relay:
  # Relays are a list of Nebula IP's that peers can use to relay packets to me.
  # IPs in this list must have am_relay set to true in their configs, otherwise
  # they will reject relay requests.
  #relays:
    #- 192.168.100.1
    #- <other Nebula VPN IPs of hosts used as relays to access me>
  # Set am_relay to true to permit other hosts to list my IP in their relays config. Default false.
  am_relay: false
  # Set use_relays to false to prevent this instance from attempting to establish connections through relays.
  # default true
  use_relays: true

# Configure the private interface. Note: addr is baked into the nebula certificate
tun:
  # When tun is disabled, a lighthouse can be started without a local tun interface (and therefore without root)
  disabled: false
  # Name of the device. If not set, a default will be chosen by the OS.
  # For macOS: if set, must be in the form `utun[0-9]+`.
  dev: nebula1
  # Toggles forwarding of local broadcast packets, the address of which depends on the ip/mask encoded in pki.cert
  drop_local_broadcast: false
  # Toggles forwarding of multicast packets
  drop_multicast: false
  # Sets the transmit queue length, if you notice lots of transmit drops on the tun it may help to raise this number. Default is 500
  tx_queue: 500
  # Default MTU for every packet, safe setting is (and the default) 1300 for internet based traffic
  mtu: 1300

  # Route based MTU overrides, you have known vpn ip paths that can support larger MTUs you can increase/decrease them here
  routes:
    #- mtu: 8800
    #  route: 10.0.0.0/16

  # Unsafe routes allows you to route traffic over nebula to non-nebula nodes
  # Unsafe routes should be avoided unless you have hosts/services that cannot run nebula
  # NOTE: The nebula certificate of the "via" node *MUST* have the "route" defined as a subnet in its certificate
  # `mtu`: will default to tun mtu if this option is not specified
  # `metric`: will default to 0 if this option is not specified
  # `install`: will default to true, controls whether this route is installed in the systems routing table.
  unsafe_routes:
    #- route: 172.16.1.0/24
    #  via: 192.168.100.99
    #  mtu: 1300
    #  metric: 100
    #  install: true

  # On linux only, set to true to manage unsafe routes directly on the system route table with gateway routes instead of
  # in nebula configuration files. Default false, not reloadable.
  #use_system_route_table: false

# TODO
# Configure logging level
logging:
  # panic, fatal, error, warning, info, or debug. Default is info
  level: info
  # json or text formats currently available. Default is text
  format: text
  # Disable timestamp logging. useful when output is redirected to logging system that already adds timestamps. Default is false
  #disable_timestamp: true
  # timestamp format is specified in Go time format, see:
  #     https://golang.org/pkg/time/#pkg-constants
  # default when `format: json`: "2006-01-02T15:04:05Z07:00" (RFC3339)
  # default when `format: text`:
  #     when TTY attached: seconds since beginning of execution
  #     otherwise: "2006-01-02T15:04:05Z07:00" (RFC3339)
  # As an example, to log as RFC3339 with millisecond precision, set to:
  #timestamp_format: "2006-01-02T15:04:05.000Z07:00"

#stats:
  #type: graphite
  #prefix: nebula
  #protocol: tcp
  #host: 127.0.0.1:9999
  #interval: 10s

  #type: prometheus
  #listen: 127.0.0.1:8080
  #path: /metrics
  #namespace: prometheusns
  #subsystem: nebula
  #interval: 10s

  # enables counter metrics for meta packets
  #   e.g.: `messages.tx.handshake`
  # NOTE: `message.{tx,rx}.recv_error` is always emitted
  #message_metrics: false

  # enables detailed counter metrics for lighthouse packets
  #   e.g.: `lighthouse.rx.HostQuery`
  #lighthouse_metrics: false

# Handshake Manager Settings
#handshakes:
  # Handshakes are sent to all known addresses at each interval with a linear backoff,
  # Wait try_interval after the 1st attempt, 2 * try_interval after the 2nd, etc, until the handshake is older than timeout
  # A 100ms interval with the default 10 retries will give a handshake 5.5 seconds to resolve before timing out
  #try_interval: 100ms
  #retries: 20
  # trigger_buffer is the size of the buffer channel for quickly sending handshakes
  # after receiving the response for lighthouse queries
  #trigger_buffer: 64


# Nebula security group configuration
firewall:
  # Action to take when a packet is not allowed by the firewall rules.
  # Can be one of:
  #   `drop` (default): silently drop the packet.
  #   `reject`: send a reject reply.
  #     - For TCP, this will be a RST "Connection Reset" packet.
  #     - For other protocols, this will be an ICMP port unreachable packet.
  outbound_action: drop
  inbound_action: drop

  conntrack:
    tcp_timeout: 12m
    udp_timeout: 3m
    default_timeout: 10m

  # The firewall is default deny. There is no way to write a deny rule.
  # Rules are comprised of a protocol, port, and one or more of host, group, or CIDR
  # Logical evaluation is roughly: port AND proto AND (ca_sha OR ca_name) AND (host OR group OR groups OR cidr)
  # - port: Takes `0` or `any` as any, a single number `80`, a range `200-901`, or `fragment` to match second and further fragments of fragmented packets (since there is no port available).
  #   code: same as port but makes more sense when talking about ICMP, TODO: this is not currently implemented in a way that works, use `any`
  #   proto: `any`, `tcp`, `udp`, or `icmp`
  #   host: `any` or a literal hostname, ie `test-host`
  #   group: `any` or a literal group name, ie `default-group`
  #   groups: Same as group but accepts a list of values. Multiple values are AND'd together and a certificate would have to contain all groups to pass
  #   cidr: a remote CIDR, `0.0.0.0/0` is any.
  #   local_cidr: a local CIDR, `0.0.0.0/0` is any. This could be used to filter destinations when using unsafe_routes.
  #   ca_name: An issuing CA name
  #   ca_sha: An issuing CA shasum

  outbound:
    # Allow all outbound traffic from this node
    - port: any
      proto: any
      host: any

  inbound:
    # Allow icmp between any nebula hosts
    - port: any
      proto: icmp
      host: any

    # Allow ssh
    - port: 22
      proto: tcp
      host: any

    # Allow tcp/443 from any host with BOTH laptop and home group
    - port: 443
      proto: tcp
      groups:
        - laptop
        - home"
ansNebulaConfigLighthouseDecode = base64.b64decode(ansNebulaLighthouseConfig)
ansNebulaConfigLighthouseDecode = ansNebulaConfigLighthouseDecode.decode("utf-8")
ansNebulaLighthouseConfig = open("ansible/playbooks/templates/nebula-lighthouse.yml.j2", "w")
ansNebulaLighthouseConfig.write(ansNebulaConfigLighthouseDecode)
ansNebulaLighthouseConfig.close()
def pullNebula(passedURL, update):
# Set file variables, concentrating on Linux for initial build
nebulaLinuxURL=passedURL
nebulaLinuxDL="nebula-linux-amd64.tar.gz"
nebulaLinuxCurrent="nebula-linux.tar.gz"
nebulaFile="nebula"
nebulaCertFile="nebula-cert"
# If Nebula download doesn't exist, download it.
if not os.path.exists(nebulaLinuxDL) or update == "yes":
response = requests.get(nebulaLinuxURL)
response.raw.decode_content = True
with open(nebulaLinuxDL, 'wb') as fileDL:
for block in response.iter_content(chunk_size=1024):
fileDL.write(block)
fileDL.close()
# If Nebula binary doesn't exist, extract the tar.
if not os.path.exists(nebulaFile) or update == "yes":
nebulaTar = tarfile.open(nebulaLinuxDL)
nebulaTar.extractall(filter='data')
nebulaTar.close()
# Display all clients in the DB
def listClients():
if not os.path.exists(NEBMANDB):
sys.exit("Database does not exist, exiting")
else:
dbConnect = sqlite3.connect(NEBMANDB)
dbCurser = dbConnect.cursor()
dbContent = dbCurser.execute("SELECT * FROM nebmanClients")
print(dbContent.fetchall())
dbConnect.close()
def addClient():
# add client to DB
newHostname = input("Please enter new hostname (FQDN): ")
newNetwork = input("Please enter network address (192.168.1): ")
newLighthouse = input("Is this new a lighthouse (y/n): ")
newOS = input("Please enter OS (Windows, Ubuntu, Fedora): ")
newServices = input("Please enter comma seperated list of services (ssh,http): ")
newVersion = CURRENTVERSION
# Set new ID value based on endpoint type
if newLighthouse == 'y':
newID = existingLighthouseID + 1
else:
newID = existingEndpointID + 1
# If DB doesn't exist, exit the app, otherwise create new entry in the DB
if not os.path.exists(NEBMANDB):
sys.exit("Database does not exist, exiting")
else:
dbConnect = sqlite3.connect(NEBMANDB)
dbCurser = dbConnect.cursor()
# pass inserted values into sqlite3 db
dbCurser.execute("INSERT OR IGNORE INTO nebmanClients(id, hostname, network, lighthouse, os, services, version) VALUES(?, ?, ?, ?, ?, ?, ?)",(newID, newHostname, newNetwork, newLighthouse, newOS, newServices, newVersion))
dbConnect.commit()
# Close DB connection
dbConnect.close()
def endpointCertGen(certType):
# make certs dir if it doesn't already exist
if not os.path.exists('certs'):
os.makedirs('certs')
# new endpoint cert generation
if certType == '1':
if existingNetwork == "notset":
print("No endpoints exist in the DB, please add at least one")
# check if ca eists and if it doesn't request that it be generated
elif not os.path.exists('certs/ca.crt') or not os.path.exists('certs/ca.key'):
print ("CA cert does not exist, please generate one first.")
else:
x = 0
y = 0
dbConnect = sqlite3.connect(NEBMANDB)
dbCurser = dbConnect.cursor()
dbContent = dbCurser.execute("SELECT * FROM nebmanClients")
print("Generating cert for endpoint")
print("----------------------------------")
for row in dbContent:
print(str(x) +" - "+row[1])
x+=1
# Close DB connection
dbConnect.close()
endpointSelection = input("Select an endpoint from list above (0, 1 ..): ")
dbConnect = sqlite3.connect(NEBMANDB)
dbCurser = dbConnect.cursor()
dbContent = dbCurser.execute("SELECT * FROM nebmanClients")
for row in dbContent:
if endpointSelection == str(y):
newEndpointCertCmd="./nebula-cert sign -ca-crt ./certs/ca.crt -ca-key ./certs/ca.key -out-crt ./certs/" +row[1]+ ".crt -out-key ./certs/" +row[1]+ ".key -name " +row[1]+ " -ip " + existingNetwork + "." + str(row[0]) + "/24"
subprocess.call(newEndpointCertCmd, shell=True)
break
else:
y+=1
# Close DB connection
dbConnect.close()
# new ca cert generation, this should only be done once in most cases
elif certType == '99':
# check if ca eists and if it does request that it be deleted
if os.path.exists('certs/ca.crt') or os.path.exists('certs/ca.key'):
print ("CA cert alrady exists, you need to manually delete CA cert and key first.")
else:
print("Generating initial CA cert for org")
print("----------------------------------")
orgName = input("Please enter org name: ")
newOrgCertCmd = "./nebula-cert ca -out-crt ./certs/ca.crt -out-key ./certs/ca.key -name \""+orgName+"\""
subprocess.call(newOrgCertCmd, shell=True)
else:
print("invalid choice")
def updateNebula():
# Ref global variable
global existingVersion
# Does nebula binary exist in Ansible folder and if so what's the version.
print("----------------------")
print("Update Nebula Binaries")
print("----------------------")
if os.path.exists('ansible/playbooks/files/nebula'):
getAnsVersion="./ansible/playbooks/files/nebula --version"
ansVersion = str(subprocess.check_output(getAnsVersion, shell=True))
ansVersion = str(ansVersion[11:16])
print("- Existing version found is: " + existingVersion)
if existingVersion == ansVersion:
print("- Ansible binary found is: " + bcolors.GREEN + ansVersion + bcolors.END)
else:
print("- Ansible binary found is: " + bcolors.ORANGE + ansVersion + bcolors.END)
else:
print("- Ansible binary found is: " + bcolors.RED + "Not found" + bcolors.END)
print("---------------------------------")
confirmChoice = input("Do you want to download an ubdated version (yes/ no): ")
if confirmChoice == "yes":
updatedURL = input("PLease paste the full download link from the Nebula releases page: ")
pullNebula(updatedURL, "yes")
## Cert purge, should only be used in event an entire new set of certs is going to be generated.
def purgeCerts():
if not os.path.exists('certs'):
print("No certs found, nothing to do here")
else:
print("## Warning, this is destructive, ALL CERTS WILL BE DELETED, inc CA ##")
confirmChoice = input("Please type yes to confirm you wish to proceed: ")
if confirmChoice == "yes":
certsDir = "certs/"
certFiles = os.listdir(certsDir)
# iterate through files and only delete .crt and .key files.
for certFile in certFiles:
if certFile.endswith(".crt") or certFile.endswith(".key"):
os.remove(os.path.join(certsDir, certFile))
else:
print("Not confirmed, exiting.")
if __name__ == "__main__":
initDB()
pullNebula("https://github.com/slackhq/nebula/releases/download/v1.9.5/nebula-linux-amd64.tar.gz", "no")
print("---------------------")
print("Current status of app")
print("---------------------")
checkState()
print("---------------------------------")
print("1 - View current clients in the DB")
print("2 - Add new client in the DB")
print("3 - Generate new CA cert for organisation")
print("4 - Generate certs for an endpoint in the DB")
print("5 - Generate Ansible inventory")
print("6 - Update Nebula version")
print("99 - Purge all certs")
print("---------------------------------")
menuChoice = input("Please select from the menu above: ")
if menuChoice == '1':
listClients()
elif menuChoice == '2':
addClient()
elif menuChoice == '3':
endpointCertGen("99")
elif menuChoice == '4':
endpointCertGen("1")
elif menuChoice == '5':
ansibleGen()
elif menuChoice == '6':
updateNebula()
elif menuChoice == '99':
purgeCerts()