auth/kerberos: Create common helper to get the verified PAC from GSSAPI
[samba.git] / source3 / rpc_server / dcesrv_gssapi.c
1 /*
2  *  GSSAPI Acceptor
3  *  DCERPC Server functions
4  *  Copyright (C) Simo Sorce 2010.
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 3 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20
21 #include "includes.h"
22 #include "rpc_server/dcesrv_gssapi.h"
23 #include "../librpc/gen_ndr/ndr_krb5pac.h"
24 #include "librpc/crypto/gse.h"
25 #include "auth.h"
26 #include "libcli/auth/krb5_wrap.h"
27
28 NTSTATUS gssapi_server_auth_start(TALLOC_CTX *mem_ctx,
29                                   bool do_sign,
30                                   bool do_seal,
31                                   bool is_dcerpc,
32                                   DATA_BLOB *token_in,
33                                   DATA_BLOB *token_out,
34                                   struct gse_context **ctx)
35 {
36         struct gse_context *gse_ctx = NULL;
37         uint32_t add_flags = 0;
38         NTSTATUS status;
39
40         if (is_dcerpc) {
41                 add_flags = GSS_C_DCE_STYLE;
42         }
43
44         /* Let's init the gssapi machinery for this connection */
45         /* passing a NULL server name means the server will try
46          * to accept any connection regardless of the name used as
47          * long as it can find a decryption key */
48         /* by passing NULL, the code will attempt to set a default
49          * keytab based on configuration options */
50         status = gse_init_server(mem_ctx, do_sign, do_seal,
51                                  add_flags, &gse_ctx);
52         if (!NT_STATUS_IS_OK(status)) {
53                 DEBUG(0, ("Failed to init dcerpc gssapi server (%s)\n",
54                           nt_errstr(status)));
55                 return status;
56         }
57
58         status = gse_get_server_auth_token(mem_ctx, gse_ctx,
59                                            token_in, token_out);
60         if (!NT_STATUS_IS_OK(status)) {
61                 DEBUG(0, ("Failed to parse initial client token (%s)\n",
62                           nt_errstr(status)));
63                 goto done;
64         }
65
66         *ctx = gse_ctx;
67         status = NT_STATUS_OK;
68
69 done:
70         if (!NT_STATUS_IS_OK(status)) {
71                 TALLOC_FREE(gse_ctx);
72         }
73
74         return status;
75 }
76
77 NTSTATUS gssapi_server_step(struct gse_context *gse_ctx,
78                             TALLOC_CTX *mem_ctx,
79                             DATA_BLOB *token_in,
80                             DATA_BLOB *token_out)
81 {
82         NTSTATUS status;
83
84         status = gse_get_server_auth_token(mem_ctx, gse_ctx,
85                                            token_in, token_out);
86         if (!NT_STATUS_IS_OK(status)) {
87                 return status;
88         }
89
90         if (gse_require_more_processing(gse_ctx)) {
91                 /* ask for next leg */
92                 return NT_STATUS_MORE_PROCESSING_REQUIRED;
93         }
94
95         return NT_STATUS_OK;
96 }
97
98 NTSTATUS gssapi_server_check_flags(struct gse_context *gse_ctx)
99 {
100         return gse_verify_server_auth_flags(gse_ctx);
101 }
102
103 NTSTATUS gssapi_server_get_user_info(struct gse_context *gse_ctx,
104                                      TALLOC_CTX *mem_ctx,
105                                      struct client_address *client_id,
106                                      struct auth_serversupplied_info **server_info)
107 {
108         TALLOC_CTX *tmp_ctx;
109         DATA_BLOB pac_blob;
110         struct PAC_DATA *pac_data;
111         struct PAC_LOGON_INFO *logon_info = NULL;
112         unsigned int i;
113         bool is_mapped;
114         bool is_guest;
115         char *princ_name;
116         char *ntuser;
117         char *ntdomain;
118         char *username;
119         struct passwd *pw;
120         NTSTATUS status;
121
122         tmp_ctx = talloc_new(mem_ctx);
123         if (!tmp_ctx) {
124                 return NT_STATUS_NO_MEMORY;
125         }
126
127         status = gse_get_pac_blob(gse_ctx, tmp_ctx, &pac_blob);
128         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
129                 /* TODO: Fetch user by principal name ? */
130                 status = NT_STATUS_ACCESS_DENIED;
131                 goto done;
132         }
133         if (!NT_STATUS_IS_OK(status)) {
134                 goto done;
135         }
136
137         status = kerberos_decode_pac(tmp_ctx,
138                                      pac_blob,
139                                      NULL, NULL, NULL, NULL, 0, &pac_data);
140         data_blob_free(&pac_blob);
141         if (!NT_STATUS_IS_OK(status)) {
142                 goto done;
143         }
144
145         status = gse_get_client_name(gse_ctx, tmp_ctx, &princ_name);
146         if (!NT_STATUS_IS_OK(status)) {
147                 goto done;
148         }
149
150         /* get logon name and logon info */
151         for (i = 0; i < pac_data->num_buffers; i++) {
152                 struct PAC_BUFFER *data_buf = &pac_data->buffers[i];
153
154                 switch (data_buf->type) {
155                 case PAC_TYPE_LOGON_INFO:
156                         if (!data_buf->info) {
157                                 break;
158                         }
159                         logon_info = data_buf->info->logon_info.info;
160                         break;
161                 default:
162                         break;
163                 }
164         }
165         if (!logon_info) {
166                 DEBUG(1, ("Invalid PAC data, missing logon info!\n"));
167                 status = NT_STATUS_NOT_FOUND;
168                 goto done;
169         }
170
171         status = get_user_from_kerberos_info(tmp_ctx, client_id->name,
172                                              princ_name, logon_info,
173                                              &is_mapped, &is_guest,
174                                              &ntuser, &ntdomain,
175                                              &username, &pw);
176         if (!NT_STATUS_IS_OK(status)) {
177                 DEBUG(1, ("Failed to map kerberos principal to system user "
178                           "(%s)\n", nt_errstr(status)));
179                 status = NT_STATUS_ACCESS_DENIED;
180                 goto done;
181         }
182
183         /* TODO: save PAC data in netsamlogon cache ? */
184
185         status = make_session_info_krb5(mem_ctx,
186                                         ntuser, ntdomain, username, pw,
187                                         logon_info, is_guest, is_mapped, NULL /* No session key for now */,
188                                         server_info);
189         if (!NT_STATUS_IS_OK(status)) {
190                 DEBUG(1, ("Failed to map kerberos pac to server info (%s)\n",
191                           nt_errstr(status)));
192                 status = NT_STATUS_ACCESS_DENIED;
193                 goto done;
194         }
195
196         DEBUG(5, (__location__ "OK: user: %s domain: %s client: %s\n",
197                   ntuser, ntdomain, client_id->name));
198
199         status = NT_STATUS_OK;
200
201 done:
202         TALLOC_FREE(tmp_ctx);
203         return status;
204 }