← Back to branch summary

~ubuntu-branches/ubuntu/maverick/samba/maverick-proposed

« back to all changes in this revision

Viewing changes to source/lib/afs_settoken.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2004-10-15 12:31:58 UTC
  • Revision ID: james.westby@ubuntu.com-20041015123158-aokykzdqkdgy6dfx
Tags: upstream-3.0.7
Import upstream version 3.0.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/lib/afs_settoken.c
 
1
/* 
 
2
 *  Unix SMB/CIFS implementation.
 
3
 *  Generate AFS tickets
 
4
 *  Copyright (C) Volker Lendecke 2004
 
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 2 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, write to the Free Software
 
18
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
19
 */
 
20
 
 
21
#include "includes.h"
 
22
 
 
23
#ifdef WITH_FAKE_KASERVER
 
24
 
 
25
#include <afs/stds.h>
 
26
#include <afs/afs.h>
 
27
#include <afs/auth.h>
 
28
#include <afs/venus.h>
 
29
#include <asm/unistd.h>
 
30
#include <openssl/des.h>
 
31
#include <sys/syscall.h>
 
32
 
 
33
int afs_syscall( int subcall,
 
34
          char * path,
 
35
          int cmd,
 
36
          char * cmarg,
 
37
          int follow)
 
38
{
 
39
        return( syscall( SYS_afs_syscall, subcall, path, cmd, cmarg, follow));
 
40
}
 
41
 
 
42
struct ClearToken {
 
43
        uint32 AuthHandle;
 
44
        char HandShakeKey[8];
 
45
        uint32 ViceId;
 
46
        uint32 BeginTimestamp;
 
47
        uint32 EndTimestamp;
 
48
};
 
49
 
 
50
static BOOL afs_decode_token(const char *string, char **cell,
 
51
                             DATA_BLOB *ticket, struct ClearToken *ct)
 
52
{
 
53
        DATA_BLOB blob;
 
54
        struct ClearToken result_ct;
 
55
 
 
56
        char *s = strdup(string);
 
57
 
 
58
        char *t;
 
59
 
 
60
        if ((t = strtok(s, "\n")) == NULL) {
 
61
                DEBUG(10, ("strtok failed\n"));
 
62
                return False;
 
63
        }
 
64
 
 
65
        *cell = strdup(t);
 
66
 
 
67
        if ((t = strtok(NULL, "\n")) == NULL) {
 
68
                DEBUG(10, ("strtok failed\n"));
 
69
                return False;
 
70
        }
 
71
 
 
72
        if (sscanf(t, "%u", &result_ct.AuthHandle) != 1) {
 
73
                DEBUG(10, ("sscanf AuthHandle failed\n"));
 
74
                return False;
 
75
        }
 
76
                
 
77
        if ((t = strtok(NULL, "\n")) == NULL) {
 
78
                DEBUG(10, ("strtok failed\n"));
 
79
                return False;
 
80
        }
 
81
 
 
82
        blob = base64_decode_data_blob(t);
 
83
 
 
84
        if ( (blob.data == NULL) ||
 
85
             (blob.length != sizeof(result_ct.HandShakeKey) )) {
 
86
                DEBUG(10, ("invalid key: %x/%d\n", (uint32)blob.data,
 
87
                           blob.length));
 
88
                return False;
 
89
        }
 
90
 
 
91
        memcpy(result_ct.HandShakeKey, blob.data, blob.length);
 
92
 
 
93
        data_blob_free(&blob);
 
94
 
 
95
        if ((t = strtok(NULL, "\n")) == NULL) {
 
96
                DEBUG(10, ("strtok failed\n"));
 
97
                return False;
 
98
        }
 
99
 
 
100
        if (sscanf(t, "%u", &result_ct.ViceId) != 1) {
 
101
                DEBUG(10, ("sscanf ViceId failed\n"));
 
102
                return False;
 
103
        }
 
104
                
 
105
        if ((t = strtok(NULL, "\n")) == NULL) {
 
106
                DEBUG(10, ("strtok failed\n"));
 
107
                return False;
 
108
        }
 
109
 
 
110
        if (sscanf(t, "%u", &result_ct.BeginTimestamp) != 1) {
 
111
                DEBUG(10, ("sscanf BeginTimestamp failed\n"));
 
112
                return False;
 
113
        }
 
114
                
 
115
        if ((t = strtok(NULL, "\n")) == NULL) {
 
116
                DEBUG(10, ("strtok failed\n"));
 
117
                return False;
 
118
        }
 
119
 
 
120
        if (sscanf(t, "%u", &result_ct.EndTimestamp) != 1) {
 
121
                DEBUG(10, ("sscanf EndTimestamp failed\n"));
 
122
                return False;
 
123
        }
 
124
                
 
125
        if ((t = strtok(NULL, "\n")) == NULL) {
 
126
                DEBUG(10, ("strtok failed\n"));
 
127
                return False;
 
128
        }
 
129
 
 
130
        blob = base64_decode_data_blob(t);
 
131
 
 
132
        if (blob.data == NULL) {
 
133
                DEBUG(10, ("Could not get ticket\n"));
 
134
                return False;
 
135
        }
 
136
 
 
137
        *ticket = blob;
 
138
        *ct = result_ct;
 
139
 
 
140
        return True;
 
141
}
 
142
 
 
143
/*
 
144
  Put an AFS token into the Kernel so that it can authenticate against
 
145
  the AFS server. This assumes correct local uid settings.
 
146
 
 
147
  This is currently highly Linux and OpenAFS-specific. The correct API
 
148
  call for this would be ktc_SetToken. But to do that we would have to
 
149
  import a REALLY big bunch of libraries which I would currently like
 
150
  to avoid. 
 
151
*/
 
152
 
 
153
static BOOL afs_settoken(const char *cell,
 
154
                         const struct ClearToken *ctok,
 
155
                         DATA_BLOB ticket)
 
156
{
 
157
        int ret;
 
158
        struct {
 
159
                char *in, *out;
 
160
                uint16 in_size, out_size;
 
161
        } iob;
 
162
 
 
163
        char buf[1024];
 
164
        char *p = buf;
 
165
        int tmp;
 
166
 
 
167
        memcpy(p, &ticket.length, sizeof(uint32));
 
168
        p += sizeof(uint32);
 
169
        memcpy(p, ticket.data, ticket.length);
 
170
        p += ticket.length;
 
171
 
 
172
        tmp = sizeof(struct ClearToken);
 
173
        memcpy(p, &tmp, sizeof(uint32));
 
174
        p += sizeof(uint32);
 
175
        memcpy(p, ctok, tmp);
 
176
        p += tmp;
 
177
 
 
178
        tmp = 0;
 
179
 
 
180
        memcpy(p, &tmp, sizeof(uint32));
 
181
        p += sizeof(uint32);
 
182
 
 
183
        tmp = strlen(cell);
 
184
        if (tmp >= MAXKTCREALMLEN) {
 
185
                DEBUG(1, ("Realm too long\n"));
 
186
                return False;
 
187
        }
 
188
 
 
189
        strncpy(p, cell, tmp);
 
190
        p += tmp;
 
191
        *p = 0;
 
192
        p +=1;
 
193
 
 
194
        iob.in = buf;
 
195
        iob.in_size = PTR_DIFF(p,buf);
 
196
        iob.out = buf;
 
197
        iob.out_size = sizeof(buf);
 
198
 
 
199
#if 0
 
200
        file_save("/tmp/ioctlbuf", iob.in, iob.in_size);
 
201
#endif
 
202
 
 
203
        ret = afs_syscall(AFSCALL_PIOCTL, 0, VIOCSETTOK, (char *)&iob, 0);
 
204
 
 
205
        DEBUG(10, ("afs VIOCSETTOK returned %d\n", ret));
 
206
        return (ret == 0);
 
207
}
 
208
 
 
209
BOOL afs_settoken_str(const char *token_string)
 
210
{
 
211
        DATA_BLOB ticket;
 
212
        struct ClearToken ct;
 
213
        BOOL result;
 
214
        char *cell;
 
215
 
 
216
        if (!afs_decode_token(token_string, &cell, &ticket, &ct))
 
217
                return False;
 
218
 
 
219
        if (geteuid() != 0)
 
220
                ct.ViceId = getuid();
 
221
 
 
222
        result = afs_settoken(cell, &ct, ticket);
 
223
 
 
224
        SAFE_FREE(cell);
 
225
        data_blob_free(&ticket);
 
226
 
 
227
        return result;
 
228
}
 
229
 
 
230
#else
 
231
 
 
232
BOOL afs_settoken_str(const char *token_string)
 
233
{
 
234
        return False;
 
235
}
 
236
 
 
237
#endif