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
|
-- 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 st = require "prosody.util.stanza";
local usermanager = require "prosody.core.usermanager";
local nodeprep = require "prosody.util.encodings".stringprep.nodeprep;
local jid_bare, jid_node = import("prosody.util.jid", "bare", "node");
local compat = module:get_option_boolean("registration_compat", true);
local soft_delete_period = module:get_option_period("registration_delete_grace_period");
local deleted_accounts = module:open_store("accounts_cleanup");
module:add_feature("jabber:iq:register");
-- Allow us to 'freeze' a session and retrieve properties even after it is
-- destroyed
local function capture_session_properties(session)
return setmetatable({
id = session.id;
ip = session.ip;
type = session.type;
client_id = session.client_id;
}, { __index = session });
end
-- Password change and account deletion handler
local function handle_registration_stanza(event)
local session, stanza = event.origin, event.stanza;
local log = session.log or module._log;
local query = stanza.tags[1];
if stanza.attr.type == "get" then
local reply = st.reply(stanza);
reply:tag("query", {xmlns = "jabber:iq:register"})
:tag("registered"):up()
:tag("username"):text(session.username):up()
:tag("password"):up();
session.send(reply);
else -- stanza.attr.type == "set"
if query.tags[1] and query.tags[1].name == "remove" then
local username, host = session.username, session.host;
if host ~= module.host then -- Sanity check for safety
module:log("error", "Host mismatch on deletion request (a bug): %s ~= %s", host, module.host);
session.send(st.error_reply(stanza, "cancel", "internal-server-error"));
return true;
end
-- This one weird trick sends a reply to this stanza before the user is deleted
local old_session_close = session.close;
session.close = function(self, ...)
self.send(st.reply(stanza));
return old_session_close(self, ...);
end
local old_session = capture_session_properties(session);
if not soft_delete_period then
local ok, err = usermanager.delete_user(username, host);
if not ok then
log("debug", "Removing user account %s@%s failed: %s", username, host, err);
session.close = old_session_close;
session.send(st.error_reply(stanza, "cancel", "service-unavailable", err));
return true;
end
log("info", "User removed their account: %s@%s (deleted)", username, host);
module:fire_event("user-deregistered", { username = username, host = host, source = "mod_register", session = old_session });
else
local ok, err = usermanager.disable_user(username, host, {
reason = "ibr";
comment = "Deletion requested by user";
when = os.time();
});
if not ok then
log("debug", "Removing (disabling) user account %s@%s failed: %s", username, host, err);
session.close = old_session_close;
session.send(st.error_reply(stanza, "cancel", "service-unavailable", err));
return true;
end
local status = {
deleted_at = os.time();
pending_until = os.time() + soft_delete_period;
client_id = session.client_id;
};
deleted_accounts:set(username, status);
log("info", "User removed their account: %s@%s (disabled, pending deletion)", username, host);
module:fire_event("user-deregistered-pending", {
username = username;
host = host;
source = "mod_register";
session = old_session;
status = status;
});
end
else
local username = query:get_child_text("username");
local password = query:get_child_text("password");
if username and password then
username = nodeprep(username);
if username == session.username then
if usermanager.set_password(username, password, session.host, session.resource) then
session.send(st.reply(stanza));
else
-- TODO unable to write file, file may be locked, etc, what's the correct error?
session.send(st.error_reply(stanza, "wait", "internal-server-error"));
end
else
session.send(st.error_reply(stanza, "modify", "bad-request"));
end
else
session.send(st.error_reply(stanza, "modify", "bad-request"));
end
end
end
return true;
end
module:hook("iq/self/jabber:iq:register:query", handle_registration_stanza);
if compat then
module:hook("iq/host/jabber:iq:register:query", function (event)
local session, stanza = event.origin, event.stanza;
if session.type == "c2s" and jid_bare(stanza.attr.to) == session.host then
return handle_registration_stanza(event);
end
end);
end
-- This improves UX of soft-deleted accounts by informing the user that the
-- account has been deleted, rather than just disabled. They can e.g. contact
-- their admin if this was a mistake.
module:hook("authentication-failure", function (event)
if event.condition ~= "account-disabled" then return; end
local session = event.session;
local sasl_handler = session and session.sasl_handler;
if sasl_handler.username then
local status = deleted_accounts:get(sasl_handler.username);
if status then
event.text = "Account deleted";
end
end
end, -1000);
function restore_account(username)
local pending, pending_err = deleted_accounts:get(username);
if not pending then
return nil, pending_err or "Account not pending deletion";
end
local account_info, err = usermanager.get_account_info(username, module.host);
if not account_info then
return nil, "Couldn't fetch account info: "..err;
end
local forget_ok, forget_err = deleted_accounts:set(username, nil);
if not forget_ok then
return nil, "Couldn't remove account from deletion queue: "..forget_err;
end
local enable_ok, enable_err = usermanager.enable_user(username, module.host);
if not enable_ok then
return nil, "Removed account from deletion queue, but couldn't enable it: "..enable_err;
end
return true, "Account restored";
end
local cleanup_time = module:measure("cleanup", "times");
function cleanup_soft_deleted_accounts()
local cleanup_done = cleanup_time();
local success, fail, restored, pending = 0, 0, 0, 0;
for username in deleted_accounts:users() do
module:log("debug", "Processing account cleanup for '%s'", username);
local account_info, account_info_err = usermanager.get_account_info(username, module.host);
if not account_info then
module:log("warn", "Unable to process delayed deletion of user '%s': %s", username, account_info_err);
fail = fail + 1;
else
if account_info.enabled == false then
local meta = deleted_accounts:get(username);
if meta.pending_until <= os.time() then
local ok, err = usermanager.delete_user(username, module.host);
if not ok then
module:log("warn", "Unable to process delayed deletion of user '%s': %s", username, err);
fail = fail + 1;
else
success = success + 1;
deleted_accounts:set(username, nil);
module:log("debug", "Deleted account '%s' successfully", username);
module:fire_event("user-deregistered", { username = username, host = module.host, source = "mod_register" });
end
else
pending = pending + 1;
end
else
module:log("warn", "Account '%s' is not disabled, removing from deletion queue", username);
restored = restored + 1;
end
end
end
module:log("debug", "%d accounts scheduled for future deletion", pending);
if success > 0 or fail > 0 then
module:log("info", "Completed account cleanup - %d accounts deleted (%d failed, %d restored, %d pending)", success, fail, restored, pending);
end
cleanup_done();
end
module:daily("Remove deleted accounts", cleanup_soft_deleted_accounts);
--- shell command
module:add_item("shell-command", {
section = "user";
name = "restore";
desc = "Restore a user account scheduled for deletion";
args = {
{ name = "jid", type = "string" };
};
host_selector = "jid";
handler = function (self, jid) --luacheck: ignore 212/self
return restore_account(jid_node(jid));
end;
});
|
