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
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
|
-- Prosody IM
-- Copyright (C) 2008-2010 Matthew Wild
-- Copyright (C) 2008-2010 Waqas Hussain
--
-- This project is MIT/X11 licensed. Please see the
-- COPYING file in the source package for more information.
--
local softreq = require"util.dependencies".softreq;
local ssl = softreq"ssl";
if not ssl then
return {
create_context = function ()
return nil, "LuaSec (required for encryption) was not found";
end;
reload_ssl_config = function () end;
}
end
local configmanager = require "core.configmanager";
local log = require "util.logger".init("certmanager");
local ssl_context = ssl.context or softreq"ssl.context";
local ssl_newcontext = ssl.newcontext;
local new_config = require"util.sslconfig".new;
local stat = require "lfs".attributes;
local x509 = require "util.x509";
local lfs = require "lfs";
local tonumber, tostring = tonumber, tostring;
local pairs = pairs;
local t_remove = table.remove;
local type = type;
local io_open = io.open;
local select = select;
local now = os.time;
local next = next;
local pcall = pcall;
local prosody = prosody;
local pathutil = require"util.paths";
local resolve_path = pathutil.resolve_relative_path;
local config_path = prosody.paths.config or ".";
local function test_option(option)
return not not ssl_newcontext({mode="server",protocol="sslv23",options={ option }});
end
local luasec_major, luasec_minor = ssl._VERSION:match("^(%d+)%.(%d+)");
local luasec_version = tonumber(luasec_major) * 100 + tonumber(luasec_minor);
local luasec_has = ssl.config or softreq"ssl.config" or {
algorithms = {
ec = luasec_version >= 5;
};
capabilities = {
curves_list = luasec_version >= 7;
};
options = {
cipher_server_preference = test_option("cipher_server_preference");
no_ticket = test_option("no_ticket");
no_compression = test_option("no_compression");
single_dh_use = test_option("single_dh_use");
single_ecdh_use = test_option("single_ecdh_use");
no_renegotiation = test_option("no_renegotiation");
};
};
local _ENV = nil;
-- luacheck: std none
-- Global SSL options if not overridden per-host
local global_ssl_config = configmanager.get("*", "ssl");
local global_certificates = configmanager.get("*", "certificates") or "certs";
local crt_try = { "", "/%s.crt", "/%s/fullchain.pem", "/%s.pem", };
local key_try = { "", "/%s.key", "/%s/privkey.pem", "/%s.pem", };
local function find_cert(user_certs, name)
local certs = resolve_path(config_path, user_certs or global_certificates);
log("debug", "Searching %s for a key and certificate for %s...", certs, name);
for i = 1, #crt_try do
local crt_path = certs .. crt_try[i]:format(name);
local key_path = certs .. key_try[i]:format(name);
if stat(crt_path, "mode") == "file" then
if crt_path == key_path then
if key_path:sub(-4) == ".crt" then
key_path = key_path:sub(1, -4) .. "key";
elseif key_path:sub(-14) == "/fullchain.pem" then
key_path = key_path:sub(1, -14) .. "privkey.pem";
end
end
if stat(key_path, "mode") == "file" then
log("debug", "Selecting certificate %s with key %s for %s", crt_path, key_path, name);
return { certificate = crt_path, key = key_path };
end
end
end
log("debug", "No certificate/key found for %s", name);
end
local function find_matching_key(cert_path)
-- FIXME we shouldn't need to guess the key filename
if cert_path:sub(-4) == ".crt" then
return cert_path:sub(1, -4) .. "key";
elseif cert_path:sub(-14) == "/fullchain.pem" then
return cert_path:sub(1, -14) .. "privkey.pem";
end
end
local function index_certs(dir, files_by_name, depth_limit)
files_by_name = files_by_name or {};
depth_limit = depth_limit or 3;
if depth_limit <= 0 then return files_by_name; end
local ok, iter, v, i = pcall(lfs.dir, dir);
if not ok then
log("error", "Error indexing certificate directory %s: %s", dir, iter);
-- Return an empty index, otherwise this just triggers a nil indexing
-- error, plus this function would get called again.
-- Reloading the config after correcting the problem calls this again so
-- that's what should be done.
return {}, iter;
end
for file in iter, v, i do
local full = pathutil.join(dir, file);
if lfs.attributes(full, "mode") == "directory" then
if file:sub(1,1) ~= "." then
index_certs(full, files_by_name, depth_limit-1);
end
-- TODO support more filename patterns?
elseif full:match("%.crt$") or full:match("/fullchain%.pem$") then
local f = io_open(full);
if f then
-- TODO look for chained certificates
local firstline = f:read();
if firstline == "-----BEGIN CERTIFICATE-----" then
f:seek("set")
local cert = ssl.loadcertificate(f:read("*a"))
-- TODO if more than one cert is found for a name, the most recently
-- issued one should be used.
-- for now, just filter out expired certs
-- TODO also check if there's a corresponding key
if cert:validat(now()) then
local names = x509.get_identities(cert);
log("debug", "Found certificate %s with identities %q", full, names);
for name, services in pairs(names) do
-- TODO check services
if files_by_name[name] then
files_by_name[name][full] = services;
else
files_by_name[name] = { [full] = services; };
end
end
end
end
f:close();
end
end
end
log("debug", "Certificate index: %q", files_by_name);
-- | hostname | filename | service |
return files_by_name;
end
local cert_index;
local function find_host_cert(host)
if not host then return nil; end
if not cert_index then
cert_index = index_certs(resolve_path(config_path, global_certificates));
end
local certs = cert_index[host];
if certs then
local cert_filename, services = next(certs);
if services["*"] then
log("debug", "Using cert %q from index", cert_filename);
return {
certificate = cert_filename,
key = find_matching_key(cert_filename),
}
end
end
return find_cert(configmanager.get(host, "certificate"), host) or find_host_cert(host:match("%.(.+)$"));
end
local function find_service_cert(service, port)
if not cert_index then
cert_index = index_certs(resolve_path(config_path, global_certificates));
end
for _, certs in pairs(cert_index) do
for cert_filename, services in pairs(certs) do
if services[service] or services["*"] then
log("debug", "Using cert %q from index", cert_filename);
return {
certificate = cert_filename,
key = find_matching_key(cert_filename),
}
end
end
end
local cert_config = configmanager.get("*", service.."_certificate");
if type(cert_config) == "table" then
cert_config = cert_config[port] or cert_config.default;
end
return find_cert(cert_config, service);
end
-- Built-in defaults
local core_defaults = {
capath = "/etc/ssl/certs";
depth = 9;
protocol = "tlsv1+";
verify = "none";
options = {
cipher_server_preference = luasec_has.options.cipher_server_preference;
no_ticket = luasec_has.options.no_ticket;
no_compression = luasec_has.options.no_compression and configmanager.get("*", "ssl_compression") ~= true;
single_dh_use = luasec_has.options.single_dh_use;
single_ecdh_use = luasec_has.options.single_ecdh_use;
no_renegotiation = luasec_has.options.no_renegotiation;
};
verifyext = {
"lsec_continue", -- Continue past certificate verification errors
"lsec_ignore_purpose", -- Validate client certificates as if they were server certificates
};
curve = luasec_has.algorithms.ec and not luasec_has.capabilities.curves_list and "secp384r1";
curveslist = {
"X25519",
"P-384",
"P-256",
"P-521",
};
ciphers = { -- Enabled ciphers in order of preference:
"HIGH+kEECDH", -- Ephemeral Elliptic curve Diffie-Hellman key exchange
"HIGH+kEDH", -- Ephemeral Diffie-Hellman key exchange, if a 'dhparam' file is set
"HIGH", -- Other "High strength" ciphers
-- Disabled cipher suites:
"!PSK", -- Pre-Shared Key - not used for XMPP
"!SRP", -- Secure Remote Password - not used for XMPP
"!3DES", -- 3DES - slow and of questionable security
"!aNULL", -- Ciphers that does not authenticate the connection
};
dane = configmanager.get("*", "use_dane");
}
local mozilla_ssl_configs = {
-- https://wiki.mozilla.org/Security/Server_Side_TLS
-- As of 2021-11-03
modern = {
protocol = "tlsv1_3";
options = { cipher_server_preference = false };
ciphers = "DEFAULT"; -- TLS 1.3 uses 'ciphersuites' rather than these
curveslist = { "X25519"; "prime256v1"; "secp384r1" };
ciphersuites = { "TLS_AES_128_GCM_SHA256"; "TLS_AES_256_GCM_SHA384"; "TLS_CHACHA20_POLY1305_SHA256" };
};
intermediate = {
protocol = "tlsv1_2+";
dhparam = nil; -- ffdhe2048.txt
options = { cipher_server_preference = false };
ciphers = {
"ECDHE-ECDSA-AES128-GCM-SHA256";
"ECDHE-RSA-AES128-GCM-SHA256";
"ECDHE-ECDSA-AES256-GCM-SHA384";
"ECDHE-RSA-AES256-GCM-SHA384";
"ECDHE-ECDSA-CHACHA20-POLY1305";
"ECDHE-RSA-CHACHA20-POLY1305";
"DHE-RSA-AES128-GCM-SHA256";
"DHE-RSA-AES256-GCM-SHA384";
};
curveslist = { "X25519"; "prime256v1"; "secp384r1" };
ciphersuites = { "TLS_AES_128_GCM_SHA256"; "TLS_AES_256_GCM_SHA384"; "TLS_CHACHA20_POLY1305_SHA256" };
};
old = {
protocol = "tlsv1+";
dhparam = nil; -- openssl dhparam 1024
options = { cipher_server_preference = true };
ciphers = {
"ECDHE-ECDSA-AES128-GCM-SHA256";
"ECDHE-RSA-AES128-GCM-SHA256";
"ECDHE-ECDSA-AES256-GCM-SHA384";
"ECDHE-RSA-AES256-GCM-SHA384";
"ECDHE-ECDSA-CHACHA20-POLY1305";
"ECDHE-RSA-CHACHA20-POLY1305";
"DHE-RSA-AES128-GCM-SHA256";
"DHE-RSA-AES256-GCM-SHA384";
"DHE-RSA-CHACHA20-POLY1305";
"ECDHE-ECDSA-AES128-SHA256";
"ECDHE-RSA-AES128-SHA256";
"ECDHE-ECDSA-AES128-SHA";
"ECDHE-RSA-AES128-SHA";
"ECDHE-ECDSA-AES256-SHA384";
"ECDHE-RSA-AES256-SHA384";
"ECDHE-ECDSA-AES256-SHA";
"ECDHE-RSA-AES256-SHA";
"DHE-RSA-AES128-SHA256";
"DHE-RSA-AES256-SHA256";
"AES128-GCM-SHA256";
"AES256-GCM-SHA384";
"AES128-SHA256";
"AES256-SHA256";
"AES128-SHA";
"AES256-SHA";
"DES-CBC3-SHA";
};
ciphersuites = { "TLS_AES_128_GCM_SHA256"; "TLS_AES_256_GCM_SHA384"; "TLS_CHACHA20_POLY1305_SHA256" };
};
};
if luasec_has.curves then
for i = #core_defaults.curveslist, 1, -1 do
if not luasec_has.curves[ core_defaults.curveslist[i] ] then
t_remove(core_defaults.curveslist, i);
end
end
else
core_defaults.curveslist = nil;
end
local path_options = { -- These we pass through resolve_path()
key = true, certificate = true, cafile = true, capath = true, dhparam = true
}
local function create_context(host, mode, ...)
local cfg = new_config();
cfg:apply(core_defaults);
local service_name, port = host:match("^(%S+) port (%d+)$");
-- port 0 is used with client-only things that normally don't need certificates, e.g. https
if service_name and port ~= "0" then
log("debug", "Automatically locating certs for service %s on port %s", service_name, port);
cfg:apply(find_service_cert(service_name, tonumber(port)));
else
log("debug", "Automatically locating certs for host %s", host);
cfg:apply(find_host_cert(host));
end
cfg:apply({
mode = mode,
-- We can't read the password interactively when daemonized
password = function() log("error", "Encrypted certificate for %s requires 'ssl' 'password' to be set in config", host); end;
});
cfg:apply(global_ssl_config);
local preset = configmanager.get("*", "ssl_preset") or "intermediate";
if preset ~= "legacy" then
cfg:apply(mozilla_ssl_configs[preset]);
end
for i = select('#', ...), 1, -1 do
cfg:apply(select(i, ...));
end
local user_ssl_config = cfg:final();
if mode == "server" then
if not user_ssl_config.certificate then
log("info", "No certificate present in SSL/TLS configuration for %s. SNI will be required.", host);
end
if user_ssl_config.certificate and not user_ssl_config.key then return nil, "No key present in SSL/TLS configuration for "..host; end
end
for option in pairs(path_options) do
if type(user_ssl_config[option]) == "string" then
user_ssl_config[option] = resolve_path(config_path, user_ssl_config[option]);
else
user_ssl_config[option] = nil;
end
end
-- LuaSec expects dhparam to be a callback that takes two arguments.
-- We ignore those because it is mostly used for having a separate
-- set of params for EXPORT ciphers, which we don't have by default.
if type(user_ssl_config.dhparam) == "string" then
local f, err = io_open(user_ssl_config.dhparam);
if not f then return nil, "Could not open DH parameters: "..err end
local dhparam = f:read("*a");
f:close();
user_ssl_config.dhparam = function() return dhparam; end
end
local ctx, err = ssl_newcontext(user_ssl_config);
-- COMPAT Older LuaSec ignores the cipher list from the config, so we have to take care
-- of it ourselves (W/A for #x)
if ctx and user_ssl_config.ciphers then
local success;
success, err = ssl_context.setcipher(ctx, user_ssl_config.ciphers);
if not success then ctx = nil; end
end
if not ctx then
err = err or "invalid ssl config"
local file = err:match("^error loading (.-) %(");
if file then
local typ;
if file == "private key" then
typ = file;
file = user_ssl_config.key or "your private key";
elseif file == "certificate" then
typ = file;
file = user_ssl_config.certificate or "your certificate file";
end
local reason = err:match("%((.+)%)$") or "some reason";
if reason == "Permission denied" then
reason = "Check that the permissions allow Prosody to read this file.";
elseif reason == "No such file or directory" then
reason = "Check that the path is correct, and the file exists.";
elseif reason == "system lib" then
reason = "Previous error (see logs), or other system error.";
elseif reason == "no start line" then
reason = "Check that the file contains a "..(typ or file);
elseif reason == "(null)" or not reason then
reason = "Check that the file exists and the permissions are correct";
else
reason = "Reason: "..tostring(reason):lower();
end
log("error", "SSL/TLS: Failed to load '%s': %s (for %s)", file, reason, host);
else
log("error", "SSL/TLS: Error initialising for %s: %s", host, err);
end
end
return ctx, err, user_ssl_config;
end
local function reload_ssl_config()
global_ssl_config = configmanager.get("*", "ssl");
global_certificates = configmanager.get("*", "certificates") or "certs";
if luasec_has.options.no_compression then
core_defaults.options.no_compression = configmanager.get("*", "ssl_compression") ~= true;
end
core_defaults.dane = configmanager.get("*", "use_dane") or false;
cert_index = index_certs(resolve_path(config_path, global_certificates));
end
prosody.events.add_handler("config-reloaded", reload_ssl_config);
return {
create_context = create_context;
reload_ssl_config = reload_ssl_config;
find_cert = find_cert;
find_host_cert = find_host_cert;
};
|