Root/package/ead/src/tinysrp/t_pw.c

1/*
2 * Copyright (c) 1997-2000 The Stanford SRP Authentication Project
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be
14 * included in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
17 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
18 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
19 *
20 * IN NO EVENT SHALL STANFORD BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
21 * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
22 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF
23 * THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT
24 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
25 *
26 * In addition, the following conditions apply:
27 *
28 * 1. Any software that incorporates the SRP authentication technology
29 * must display the following acknowlegment:
30 * "This product uses the 'Secure Remote Password' cryptographic
31 * authentication system developed by Tom Wu (tjw@CS.Stanford.EDU)."
32 *
33 * 2. Any software that incorporates all or part of the SRP distribution
34 * itself must also display the following acknowledgment:
35 * "This product includes software developed by Tom Wu and Eugene
36 * Jhong for the SRP Distribution (http://srp.stanford.edu/srp/)."
37 *
38 * 3. Redistributions in source or binary form must retain an intact copy
39 * of this copyright notice and list of conditions.
40 */
41
42#include "t_defines.h"
43
44#ifdef HAVE_UNISTD_H
45#include <unistd.h>
46#endif /* HAVE_UNISTD_H */
47
48#include <stdio.h>
49#include <sys/types.h>
50#include <sys/stat.h>
51#ifdef USE_HOMEDIR
52#include <pwd.h>
53#endif
54#ifdef WIN32
55#include <io.h>
56#endif
57
58#include "t_pwd.h"
59#include "t_read.h"
60#include "t_sha.h"
61#include "t_server.h"
62
63static struct t_pw * syspw = NULL;
64static struct t_passwd tpass;
65
66_TYPE( struct t_server * )
67t_serveropen(username)
68     const char * username;
69{
70  struct t_passwd * p;
71  p = gettpnam(username);
72  if(p == NULL) {
73    return NULL;
74  } else {
75    return t_serveropenraw(&p->tp, &p->tc);
76  }
77}
78
79
80/* t_openpw(NULL) is deprecated - use settpent()/gettpnam() instead */
81
82_TYPE( struct t_pw * )
83t_openpw(fp)
84     FILE * fp;
85{
86  struct t_pw * tpw;
87  char close_flag = 0;
88
89  if(fp == NULL) { /* Deprecated */
90    if((fp = fopen(DEFAULT_PASSWD, "r")) == NULL)
91      return NULL;
92    close_flag = 1;
93  }
94  else
95    close_flag = 0;
96
97  if((tpw = malloc(sizeof(struct t_pw))) == NULL)
98    return NULL;
99  tpw->instream = fp;
100  tpw->close_on_exit = close_flag;
101  tpw->state = FILE_ONLY;
102
103  return tpw;
104}
105
106_TYPE( struct t_pw * )
107t_openpwbyname(pwname)
108     const char * pwname;
109{
110  FILE * fp;
111  struct t_pw * t;
112
113  if(pwname == NULL) /* Deprecated */
114    return t_openpw(NULL);
115
116  if((fp = fopen(pwname, "r")) == NULL)
117    return NULL;
118
119  t = t_openpw(fp);
120  t->close_on_exit = 1;
121  return t;
122}
123
124_TYPE( void )
125t_closepw(tpw)
126     struct t_pw * tpw;
127{
128  if(tpw->close_on_exit)
129    fclose(tpw->instream);
130  free(tpw);
131}
132
133_TYPE( void )
134t_rewindpw(tpw)
135     struct t_pw * tpw;
136{
137#ifdef ENABLE_YP
138  if(tpw->state == IN_NIS)
139    tpw->state = FILE_NIS;
140#endif
141  rewind(tpw->instream);
142}
143
144#ifdef ENABLE_YP
145static void
146savepwent(tpw, pwent)
147     struct t_pw * tpw;
148     struct t_pwent *pwent;
149{
150  tpw->pebuf.name = tpw->userbuf;
151  tpw->pebuf.password.data = tpw->pwbuf;
152  tpw->pebuf.salt.data = tpw->saltbuf;
153  strcpy(tpw->pebuf.name, pwent->name);
154  tpw->pebuf.password.len = pwent->password.len;
155  memcpy(tpw->pebuf.password.data, pwent->password.data, pwent->password.len);
156  tpw->pebuf.salt.len = pwent->salt.len;
157  memcpy(tpw->pebuf.salt.data, pwent->salt.data, pwent->salt.len);
158  tpw->pebuf.index = pwent->index;
159}
160#endif /* ENABLE_YP */
161
162_TYPE( struct t_pwent * )
163t_getpwbyname(tpw, user)
164     struct t_pw * tpw;
165     const char * user;
166{
167  char indexbuf[16];
168  char passbuf[MAXB64PARAMLEN];
169  char saltstr[MAXB64SALTLEN];
170  char username[MAXUSERLEN];
171#ifdef ENABLE_YP
172  struct t_passwd * nisent;
173#endif
174
175  t_rewindpw(tpw);
176
177  while(t_nextfield(tpw->instream, username, MAXUSERLEN) > 0) {
178#ifdef ENABLE_YP
179    if(tpw->state == FILE_NIS && *username == '+') {
180      if(strlen(username) == 1 || strcmp(user, username+1) == 0) {
181    nisent = _yp_gettpnam(user); /* Entry is +username or + */
182    if(nisent != NULL) {
183      savepwent(tpw, &nisent->tp);
184      return &tpw->pebuf;
185    }
186      }
187    }
188#endif
189    if(strcmp(user, username) == 0)
190      if(t_nextfield(tpw->instream, passbuf, MAXB64PARAMLEN) > 0 &&
191     (tpw->pebuf.password.len = t_fromb64(tpw->pwbuf, passbuf)) > 0 &&
192     t_nextfield(tpw->instream, saltstr, MAXB64SALTLEN) > 0 &&
193     (tpw->pebuf.salt.len = t_fromb64(tpw->saltbuf, saltstr)) > 0 &&
194     t_nextfield(tpw->instream, indexbuf, 16) > 0 &&
195     (tpw->pebuf.index = atoi(indexbuf)) > 0) {
196    strcpy(tpw->userbuf, username);
197    tpw->pebuf.name = tpw->userbuf;
198    tpw->pebuf.password.data = tpw->pwbuf;
199    tpw->pebuf.salt.data = tpw->saltbuf;
200    t_nextline(tpw->instream);
201    return &tpw->pebuf;
202      }
203    if(t_nextline(tpw->instream) < 0)
204      return NULL;
205  }
206  return NULL;
207}
208
209/* System password file accessors */
210
211static int
212pwinit()
213{
214  if(syspw == NULL) {
215    if((syspw = t_openpwbyname(DEFAULT_PASSWD)) == NULL)
216      return -1;
217    syspw->state = FILE_NIS;
218  }
219  return 0;
220}
221
222static void
223pwsetup(out, tpwd, tcnf)
224     struct t_passwd * out;
225     struct t_pwent * tpwd;
226     struct t_confent * tcnf;
227{
228  out->tp.name = tpwd->name;
229  out->tp.password.len = tpwd->password.len;
230  out->tp.password.data = tpwd->password.data;
231  out->tp.salt.len = tpwd->salt.len;
232  out->tp.salt.data = tpwd->salt.data;
233  out->tp.index = tpwd->index;
234
235  out->tc.index = tcnf->index;
236  out->tc.modulus.len = tcnf->modulus.len;
237  out->tc.modulus.data = tcnf->modulus.data;
238  out->tc.generator.len = tcnf->generator.len;
239  out->tc.generator.data = tcnf->generator.data;
240}
241
242_TYPE( struct t_passwd * )
243gettpnam
244(user)
245     const char * user;
246{
247  struct t_pwent * tpptr;
248  struct t_confent * tcptr;
249
250  if(pwinit() < 0)
251    return NULL;
252  tpptr = t_getpwbyname(syspw, user);
253  if(tpptr == NULL)
254    return NULL;
255  tcptr =
256    gettcid
257    (tpptr->index);
258  if(tcptr == NULL)
259    return NULL;
260  pwsetup(&tpass, tpptr, tcptr);
261  return &tpass;
262}
263

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive