1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
24 */
25
26 #include <sys/types.h>
27 #include <errno.h>
28 #include <synch.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <unistd.h>
32 #include <string.h>
33 #include <strings.h>
34 #include <syslog.h>
35 #include <fcntl.h>
36 #include <bsm/adt.h>
37 #include <bsm/adt_event.h>
38 #include <bsm/audit_uevents.h>
39 #include <pwd.h>
40 #include <nss_dbdefs.h>
41 #include <sys/idmap.h>
42 #include "smbd.h"
43
44
45 /*
46 * An audit session is established at user logon and terminated at user
47 * logoff.
48 *
49 * SMB audit handles are allocated when users logon (SmbSessionSetupX)
50 * and deallocted when a user logs off (SmbLogoffX). Each time an SMB
51 * audit handle is allocated it is added to a global list.
52 */
53 typedef struct smb_audit {
54 struct smb_audit *sa_next;
55 adt_session_data_t *sa_handle;
56 uid_t sa_uid;
57 gid_t sa_gid;
58 uint32_t sa_audit_sid;
59 uint32_t sa_refcnt;
60 char *sa_domain;
61 char *sa_username;
62 } smb_audit_t;
63
64 static smb_audit_t *smbd_audit_list;
65 static mutex_t smbd_audit_lock;
66
67 /*
68 * Unique identifier for audit sessions in the audit list.
69 * Used to lookup an audit session on logoff.
70 */
71 static uint32_t smbd_audit_sid;
72
73 static void smbd_audit_link(smb_audit_t *);
74 static smb_audit_t *smbd_audit_unlink(uint32_t);
75
76
77 /*
78 * Invoked at user logon due to SmbSessionSetupX. Authenticate the
79 * user, start an audit session and audit the event.
80 */
81 smb_token_t *
82 smbd_user_auth_logon(smb_logon_t *user_info)
83 {
84 smb_token_t *token;
85 smb_audit_t *entry;
86 adt_session_data_t *ah;
87 adt_event_data_t *event;
88 smb_logon_t tmp_user;
89 au_tid_addr_t termid;
90 char sidbuf[SMB_SID_STRSZ];
91 char *username;
92 char *domain;
93 uid_t uid;
94 gid_t gid;
95 char *sid;
96 int status;
97 int retval;
98
99 if (user_info->lg_username == NULL ||
100 user_info->lg_domain == NULL ||
101 user_info->lg_workstation == NULL) {
102 return (NULL);
103 }
104
105 tmp_user = *user_info;
106 if (tmp_user.lg_username[0] == '\0') {
107 tmp_user.lg_flags |= SMB_ATF_ANON;
108 tmp_user.lg_e_username = "anonymous";
109 } else {
110 tmp_user.lg_e_username = tmp_user.lg_username;
111 }
112 tmp_user.lg_e_domain = tmp_user.lg_domain;
113
114 if ((token = smb_logon(&tmp_user)) == NULL) {
115 uid = ADT_NO_ATTRIB;
116 gid = ADT_NO_ATTRIB;
117 sid = NT_NULL_SIDSTR;
118 username = tmp_user.lg_e_username;
119 domain = tmp_user.lg_e_domain;
120 status = ADT_FAILURE;
121 retval = ADT_FAIL_VALUE_AUTH;
122 } else {
123 uid = token->tkn_user.i_id;
124 gid = token->tkn_primary_grp.i_id;
125 smb_sid_tostr(token->tkn_user.i_sid, sidbuf);
126 sid = sidbuf;
127 username = token->tkn_account_name;
128 domain = token->tkn_domain_name;
129 status = ADT_SUCCESS;
130 retval = ADT_SUCCESS;
131 }
132
133 if (adt_start_session(&ah, NULL, 0)) {
134 syslog(LOG_AUTH | LOG_ALERT, "adt_start_session: %m");
135 smb_token_destroy(token);
136 return (NULL);
137 }
138
139 if ((event = adt_alloc_event(ah, ADT_smbd_session)) == NULL) {
140 syslog(LOG_AUTH | LOG_ALERT,
141 "adt_alloc_event(ADT_smbd_session): %m");
142 (void) adt_end_session(ah);
143 smb_token_destroy(token);
144 return (NULL);
145 }
146
147 (void) memset(&termid, 0, sizeof (au_tid_addr_t));
148 termid.at_port = user_info->lg_local_port;
149
150 if (user_info->lg_clnt_ipaddr.a_family == AF_INET) {
151 termid.at_addr[0] = user_info->lg_clnt_ipaddr.a_ipv4;
152 termid.at_type = AU_IPv4;
153 } else {
154 bcopy(&user_info->lg_clnt_ipaddr.a_ip, termid.at_addr,
155 sizeof (in6_addr_t));
156 termid.at_type = AU_IPv6;
157 }
158 adt_set_termid(ah, &termid);
159
160 if (adt_set_user(ah, uid, gid, uid, gid, NULL, ADT_NEW)) {
161 syslog(LOG_AUTH | LOG_ALERT, "adt_set_user: %m");
162 adt_free_event(event);
163 (void) adt_end_session(ah);
164 smb_token_destroy(token);
165 return (NULL);
166 }
167
168 event->adt_smbd_session.domain = domain;
169 event->adt_smbd_session.username = username;
170 event->adt_smbd_session.sid = sid;
171
172 if (adt_put_event(event, status, retval))
173 syslog(LOG_AUTH | LOG_ALERT, "adt_put_event: %m");
174
175 adt_free_event(event);
176
177 if (token) {
178 if ((entry = malloc(sizeof (smb_audit_t))) == NULL) {
179 syslog(LOG_ERR, "smbd_user_auth_logon: %m");
180 (void) adt_end_session(ah);
181 smb_token_destroy(token);
182 return (NULL);
183 }
184
185 entry->sa_handle = ah;
186 entry->sa_uid = uid;
187 entry->sa_gid = gid;
188 entry->sa_username = strdup(username);
189 entry->sa_domain = strdup(domain);
190
191 smb_autohome_add(token);
192 smbd_audit_link(entry);
193 token->tkn_audit_sid = entry->sa_audit_sid;
194 }
195
196 return (token);
197 }
198
199 /*
200 * Logon due to a subsequent SmbSessionSetupX on an existing session.
201 * The user was authenticated during the initial session setup.
202 */
203 void
204 smbd_user_nonauth_logon(uint32_t audit_sid)
205 {
206 smb_audit_t *entry;
207
208 (void) mutex_lock(&smbd_audit_lock);
209 entry = smbd_audit_list;
210
211 while (entry) {
212 if (entry->sa_audit_sid == audit_sid) {
213 ++entry->sa_refcnt;
214 break;
215 }
216
217 entry = entry->sa_next;
218 }
219
220 (void) mutex_unlock(&smbd_audit_lock);
221 }
222
223 /*
224 * Invoked at user logoff due to SmbLogoffX. If this is the final
225 * logoff for this user on the session, audit the event and terminate
226 * the audit session.
227 */
228 void
229 smbd_user_auth_logoff(uint32_t audit_sid)
230 {
231 smb_audit_t *entry;
232 adt_session_data_t *ah;
233 adt_event_data_t *event;
234 struct passwd pw;
235 char buf[NSS_LINELEN_PASSWD];
236
237 if ((entry = smbd_audit_unlink(audit_sid)) == NULL)
238 return;
239
240 if (IDMAP_ID_IS_EPHEMERAL(entry->sa_uid)) {
241 smb_autohome_remove(entry->sa_username);
242 } else {
243 if (getpwuid_r(entry->sa_uid, &pw, buf, sizeof (buf)) == NULL)
244 return;
245
246 smb_autohome_remove(pw.pw_name);
247 }
248
249 ah = entry->sa_handle;
250
251 if ((event = adt_alloc_event(ah, ADT_smbd_logoff)) == NULL) {
252 syslog(LOG_AUTH | LOG_ALERT,
253 "adt_alloc_event(ADT_smbd_logoff): %m");
254 } else {
255 event->adt_smbd_logoff.domain = entry->sa_domain;
256 event->adt_smbd_logoff.username = entry->sa_username;
257
258 if (adt_put_event(event, ADT_SUCCESS, ADT_SUCCESS))
259 syslog(LOG_AUTH | LOG_ALERT, "adt_put_event: %m");
260
261 adt_free_event(event);
262 }
263
264 (void) adt_end_session(ah);
265
266 free(entry->sa_username);
267 free(entry->sa_domain);
268 free(entry);
269 }
270
271 /*
272 * Allocate an id and link an audit handle onto the global list.
273 */
274 static void
275 smbd_audit_link(smb_audit_t *entry)
276 {
277 (void) mutex_lock(&smbd_audit_lock);
278
279 do {
280 ++smbd_audit_sid;
281 } while ((smbd_audit_sid == 0) || (smbd_audit_sid == (uint32_t)-1));
282
283 entry->sa_audit_sid = smbd_audit_sid;
284 entry->sa_refcnt = 1;
285 entry->sa_next = smbd_audit_list;
286 smbd_audit_list = entry;
287
288 (void) mutex_unlock(&smbd_audit_lock);
289 }
290
291 /*
292 * Unlink an audit handle. If the reference count reaches 0, the entry
293 * is removed from the list and returned. Otherwise the entry remains
294 * on the list and a null pointer is returned.
295 */
296 static smb_audit_t *
297 smbd_audit_unlink(uint32_t audit_sid)
298 {
299 smb_audit_t *entry;
300 smb_audit_t **ppe;
301
302 (void) mutex_lock(&smbd_audit_lock);
303 ppe = &smbd_audit_list;
304
305 while (*ppe) {
306 entry = *ppe;
307
308 if (entry->sa_audit_sid == audit_sid) {
309 if (entry->sa_refcnt == 0)
310 break;
311
312 if ((--entry->sa_refcnt) != 0)
313 break;
314
315 *ppe = entry->sa_next;
316 (void) mutex_unlock(&smbd_audit_lock);
317 return (entry);
318 }
319
320 ppe = &(*ppe)->sa_next;
321 }
322
323 (void) mutex_unlock(&smbd_audit_lock);
324 return (NULL);
325 }