5bffc4425109495c8e27a043767f914fbeaf4a68
[reactos.git] / reactos / lib / mpr / pwcache.c
1 /*
2 * MPR Password Cache functions
3 *
4 * Copyright 1999 Ulrich Weigand
5 * Copyright 2003,2004 Mike McCormack for CodeWeavers
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include <stdarg.h>
23 #include <stdio.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winnetwk.h"
28 #include "winreg.h"
29 #include "wine/debug.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(mpr);
32
33 static const char mpr_key[] = "Software\\Wine\\Wine\\Mpr\\";
34
35 static inline BYTE hex( BYTE x )
36 {
37 if( x <= 9 )
38 return x + '0';
39 return x + 'A' - 10;
40 }
41
42 static inline CHAR ctox( CHAR x )
43 {
44 if( ( x >= '0' ) && ( x <= '9' ) )
45 return x - '0';
46 if( ( x >= 'A' ) && ( x <= 'F' ) )
47 return x - 'A' + 10;
48 if( ( x >= 'a' ) && ( x <= 'a' ) )
49 return x - 'a' + 10;
50 return -1;
51 }
52
53 static LPSTR MPR_GetValueName( LPSTR pbResource, WORD cbResource, BYTE nType )
54 {
55 LPSTR name;
56 DWORD i;
57
58 name = HeapAlloc( GetProcessHeap(), 0, 6+cbResource*2 );
59 if( name )
60 sprintf( name, "X-%02X-", nType );
61 for(i=0; i<cbResource; i++)
62 {
63 name[5+i*2]=hex((pbResource[i]&0xf0)>>4);
64 name[6+i*2]=hex(pbResource[i]&0x0f);
65 }
66 name[5+i*2]=0;
67 TRACE( "Value is %s\n", name );
68 return name;
69 }
70
71
72 /**************************************************************************
73 * WNetCachePassword [MPR.@] Saves password in cache
74 *
75 * NOTES
76 * only the parameter count is verifyed
77 *
78 * ---- everything below this line might be wrong (js) -----
79 * RETURNS
80 * Success: WN_SUCCESS
81 * Failure: WN_ACCESS_DENIED, WN_BAD_PASSWORD, WN_BADVALUE, WN_NET_ERROR,
82 * WN_NOT_SUPPORTED, WN_OUT_OF_MEMORY
83 */
84 DWORD WINAPI WNetCachePassword(
85 LPSTR pbResource, /* [in] Name of workgroup, computer, or resource */
86 WORD cbResource, /* [in] Size of name */
87 LPSTR pbPassword, /* [in] Buffer containing password */
88 WORD cbPassword, /* [in] Size of password */
89 BYTE nType, /* [in] Type of password to cache */
90 WORD x)
91
92 {
93 HKEY hkey;
94 DWORD r;
95 LPSTR valname;
96
97 WARN( "(%p(%s), %d, %p(%s), %d, %d, 0x%08x): totally insecure\n",
98 pbResource, debugstr_a(pbResource), cbResource,
99 pbPassword, debugstr_a(pbPassword), cbPassword,
100 nType, x );
101
102 r = RegCreateKeyA( HKEY_CURRENT_USER, mpr_key, &hkey );
103 if( r )
104 return WN_ACCESS_DENIED;
105
106 valname = MPR_GetValueName( pbResource, cbResource, nType );
107 if( valname )
108 {
109 r = RegSetValueExA( hkey, valname, 0, REG_BINARY,
110 pbPassword, cbPassword );
111 if( r )
112 r = WN_CANCEL;
113 else
114 r = WN_SUCCESS;
115 HeapFree( GetProcessHeap(), 0, valname );
116 }
117 else
118 r = WN_OUT_OF_MEMORY;
119
120 RegCloseKey( hkey );
121
122 return r;
123 }
124
125 /*****************************************************************
126 * WNetRemoveCachedPassword [MPR.@]
127 */
128 UINT WINAPI WNetRemoveCachedPassword(
129 LPSTR pbResource, /* [in] resource ID to delete */
130 WORD cbResource, /* [in] number of bytes in the resource ID */
131 BYTE nType ) /* [in] Type of the resource to delete */
132 {
133 HKEY hkey;
134 DWORD r;
135 LPSTR valname;
136
137 WARN( "(%p(%s), %d, %d): totally insecure\n",
138 pbResource, debugstr_a(pbResource), cbResource, nType );
139
140 r = RegCreateKeyA( HKEY_CURRENT_USER, mpr_key, &hkey );
141 if( r )
142 return WN_ACCESS_DENIED;
143
144 valname = MPR_GetValueName( pbResource, cbResource, nType );
145 if( valname )
146 {
147 r = RegDeleteValueA( hkey, valname );
148 if( r )
149 r = WN_ACCESS_DENIED;
150 else
151 r = WN_SUCCESS;
152 HeapFree( GetProcessHeap(), 0, valname );
153 }
154 else
155 r = WN_OUT_OF_MEMORY;
156
157 return r;
158 }
159
160 /*****************************************************************
161 * WNetGetCachedPassword [MPR.@] Retrieves password from cache
162 *
163 * NOTES
164 * the stub seems to be wrong:
165 * arg1: ptr 0x40xxxxxx -> (no string)
166 * arg2: len 36
167 * arg3: ptr 0x40xxxxxx -> (no string)
168 * arg4: ptr 0x40xxxxxx -> 0xc8
169 * arg5: type? 4
170 *
171 * ---- everything below this line might be wrong (js) -----
172 * RETURNS
173 * Success: WN_SUCCESS
174 * Failure: WN_ACCESS_DENIED, WN_BAD_PASSWORD, WN_BAD_VALUE,
175 * WN_NET_ERROR, WN_NOT_SUPPORTED, WN_OUT_OF_MEMORY
176 */
177 DWORD WINAPI WNetGetCachedPassword(
178 LPSTR pbResource, /* [in] Name of workgroup, computer, or resource */
179 WORD cbResource, /* [in] Size of name */
180 LPSTR pbPassword, /* [out] Buffer to receive password */
181 LPWORD pcbPassword, /* [out] Receives size of password */
182 BYTE nType) /* [in] Type of password to retrieve */
183 {
184 HKEY hkey;
185 DWORD r, type = 0, sz;
186 LPSTR valname;
187
188 WARN( "(%p(%s), %d, %p, %p, %d): totally insecure\n",
189 pbResource, debugstr_a(pbResource), cbResource,
190 pbPassword, pcbPassword, nType );
191
192 memset( pbPassword, 0, *pcbPassword);
193
194 r = RegCreateKeyA( HKEY_CURRENT_USER, mpr_key, &hkey );
195 if( r )
196 return WN_ACCESS_DENIED;
197
198 valname = MPR_GetValueName( pbResource, cbResource, nType );
199 if( valname )
200 {
201 sz = *pcbPassword;
202 r = RegQueryValueExA( hkey, valname, 0, &type, pbPassword, &sz );
203 *pcbPassword = sz;
204 if( r )
205 r = WN_CANCEL;
206 else
207 r = WN_SUCCESS;
208 HeapFree( GetProcessHeap(), 0, valname );
209 }
210 else
211 r = WN_OUT_OF_MEMORY;
212
213 return r;
214 }
215
216 /*******************************************************************
217 * WNetEnumCachedPasswords [MPR.@]
218 *
219 * NOTES
220 * the parameter count is verifyed
221 *
222 * This function is a huge security risk, as virii and such can use
223 * it to grab all the passwords in the cache. It's bad enough to
224 * store the passwords (insecurely).
225 *
226 * bpPrefix and cbPrefix are used to filter the returned passwords
227 * the first cbPrefix bytes of the password resource identifier
228 * should match the same number of bytes in bpPrefix
229 *
230 * RETURNS
231 * Success: WN_SUCCESS (even if no entries were enumerated)
232 * Failure: WN_ACCESS_DENIED, WN_BAD_PASSWORD, WN_BAD_VALUE,
233 * WN_NET_ERROR, WN_NOT_SUPPORTED, WN_OUT_OF_MEMORY
234 */
235
236 UINT WINAPI WNetEnumCachedPasswords(
237 LPSTR pbPrefix, /* [in] prefix to filter cache entries */
238 WORD cbPrefix, /* [in] number of bytes in Prefix substring */
239 BYTE nType, /* [in] match the Type ID of the entry */
240 ENUMPASSWORDPROC enumPasswordProc, /* [in] callback function */
241 DWORD param) /* [in] parameter passed to enum function */
242 {
243 HKEY hkey;
244 DWORD r, type, val_sz, data_sz, i, j, size;
245 PASSWORD_CACHE_ENTRY *entry;
246 CHAR val[256], prefix[6];
247
248 WARN( "(%s, %d, %d, %p, 0x%08lx) totally insecure\n",
249 debugstr_an(pbPrefix,cbPrefix), cbPrefix,
250 nType, enumPasswordProc, param );
251
252 r = RegCreateKeyA( HKEY_CURRENT_USER, mpr_key, &hkey );
253 if( r )
254 return WN_ACCESS_DENIED;
255
256 sprintf(prefix, "X-%02X-", nType );
257
258 i = 0;
259 for( i=0; ; i++ )
260 {
261 val_sz = sizeof val;
262 data_sz = 0;
263 type = 0;
264 val[0] = 0;
265 r = RegEnumValueA( hkey, i, val, &val_sz, NULL, &type, NULL, &data_sz );
266 if( r != ERROR_SUCCESS )
267 break;
268 if( type != REG_BINARY )
269 continue;
270
271 /* check the value is in the format we expect */
272 if( val_sz < sizeof prefix )
273 continue;
274 if( memcmp( prefix, val, 5 ) )
275 continue;
276
277 /* decode the value */
278 for(j=5; j<val_sz; j+=2 )
279 {
280 CHAR hi = ctox( val[j] ), lo = ctox( val[j+1] );
281 if( ( hi < 0 ) || ( lo < 0 ) )
282 break;
283 val[(j-5)/2] = (hi<<4) | lo;
284 }
285
286 /* find the decoded length */
287 val_sz = (j - 5)/2;
288 val[val_sz]=0;
289 if( val_sz < cbPrefix )
290 continue;
291
292 /* check the prefix matches */
293 if( memcmp(val, pbPrefix, cbPrefix) )
294 continue;
295
296 /* read the value data */
297 size = sizeof *entry - sizeof entry->abResource[0] + val_sz + data_sz;
298 entry = HeapAlloc( GetProcessHeap(), 0, sizeof *entry + val_sz + data_sz );
299 memcpy( entry->abResource, val, val_sz );
300 entry->cbEntry = size;
301 entry->cbResource = val_sz;
302 entry->cbPassword = data_sz;
303 entry->iEntry = i;
304 entry->nType = nType;
305 r = RegEnumValueA( hkey, i, NULL, &val_sz, NULL, &type,
306 &entry->abResource[val_sz], &data_sz );
307 if( r == ERROR_SUCCESS )
308 enumPasswordProc( entry, param );
309 HeapFree( GetProcessHeap(), 0, entry );
310 }
311
312 RegCloseKey( hkey );
313
314 return WN_SUCCESS;
315 }