d70aab5b70db5235b17a9bd75d8587a062f4435c
[ossec-hids.git] / keys.c
1 /* @(#) $Id$ */
2
3 /* Copyright (C) 2009 Trend Micro Inc.
4  * All rights reserved.
5  *
6  * This program is a free software; you can redistribute it
7  * and/or modify it under the terms of the GNU General Public
8  * License (version 2) as published by the FSF - Free Software
9  * Foundation.
10  *
11  * License details at the LICENSE file included with OSSEC or 
12  * online at: http://www.ossec.net/en/licensing.html
13  */
14
15
16
17 #include "headers/shared.h"
18 #include "headers/sec.h"
19
20 #include "os_zlib/os_zlib.h"
21 #include "os_crypto/md5/md5_op.h"
22 #include "os_crypto/blowfish/bf_op.h"
23
24
25
26 /* __memclear: Clears keys entries. 
27  */
28 void __memclear(char *id, char *name, char *ip, char *key, int size)
29 {
30         memset(id,'\0', size);
31         memset(name,'\0', size);
32         memset(key,'\0', size);
33         memset(ip,'\0', size);
34 }
35
36
37 /* __chash: Creates the final key.
38  */
39 void __chash(keystore *keys, char *id, char *name, char *ip, char *key)
40 {
41         os_md5 filesum1;
42         os_md5 filesum2;
43    
44     char *tmp_str; 
45         char _finalstr[KEYSIZE];
46     
47
48     /* Allocating for the whole structure */
49     keys->keyentries =(keyentry **)realloc(keys->keyentries,
50                                          (keys->keysize+2)*sizeof(keyentry *));
51     if(!keys->keyentries)
52     {
53         ErrorExit(MEM_ERROR, __local_name);
54     }
55     os_calloc(1, sizeof(keyentry), keys->keyentries[keys->keysize]);
56    
57     
58     /* Setting configured values for id */
59     os_strdup(id, keys->keyentries[keys->keysize]->id);
60     OSHash_Add(keys->keyhash_id, 
61                keys->keyentries[keys->keysize]->id, 
62                keys->keyentries[keys->keysize]);
63     
64     
65     /* agent ip */
66     os_calloc(1, sizeof(os_ip), keys->keyentries[keys->keysize]->ip);
67     if(OS_IsValidIP(ip, keys->keyentries[keys->keysize]->ip) == 0)
68     {
69         ErrorExit(INVALID_IP, __local_name, ip);
70     }
71     
72     /* We need to remove the "/" from the cidr */
73         if((tmp_str = strchr(keys->keyentries[keys->keysize]->ip->ip, '/')) != NULL)
74     {
75         *tmp_str = '\0';
76     }
77     OSHash_Add(keys->keyhash_ip, 
78                keys->keyentries[keys->keysize]->ip->ip, 
79                keys->keyentries[keys->keysize]);
80
81     
82     /* agent name */
83     os_strdup(name, keys->keyentries[keys->keysize]->name);
84
85     /* Initializing the variables */
86     keys->keyentries[keys->keysize]->rcvd = 0;
87     keys->keyentries[keys->keysize]->local = 0;
88     keys->keyentries[keys->keysize]->keyid = keys->keysize;
89     keys->keyentries[keys->keysize]->global = 0;
90     keys->keyentries[keys->keysize]->fp = NULL;
91
92         
93     
94         /** Generating final symmetric key **/
95     
96         /* MD5 from name, id and key */
97         OS_MD5_Str(name, filesum1);     
98         OS_MD5_Str(id,  filesum2);
99
100
101         /* Generating new filesum1 */ 
102         snprintf(_finalstr, sizeof(_finalstr)-1, "%s%s", filesum1, filesum2);
103
104         
105     /* Using just half of the first md5 (name/id) */
106     OS_MD5_Str(_finalstr, filesum1);
107     filesum1[15] = '\0';        
108     filesum1[16] = '\0';
109
110
111     /* Second md is just the key */
112     OS_MD5_Str(key, filesum2);  
113         
114     
115         /* Generating final key */
116         memset(_finalstr,'\0', sizeof(_finalstr));
117         snprintf(_finalstr, 49, "%s%s", filesum2, filesum1);
118
119
120     /* Final key is 48 * 4 = 192bits */
121     os_strdup(_finalstr, keys->keyentries[keys->keysize]->key);
122
123
124         /* Cleaning final string from memory */
125         memset(_finalstr,'\0', sizeof(_finalstr));
126
127
128         /* ready for next */
129         keys->keysize++;        
130     
131     
132         return;
133 }
134
135
136 /* int OS_CheckKeys(): 
137  * Checks if the authentication key file is present 
138  */
139 int OS_CheckKeys()
140 {
141     FILE *fp;
142
143     if(File_DateofChange(KEYSFILE_PATH) < 0)
144     {
145         merror(NO_AUTHFILE, __local_name, KEYSFILE_PATH);
146         merror(NO_REM_CONN, __local_name);
147         return(0);
148     }
149
150     fp = fopen(KEYSFILE_PATH, "r");
151     if(!fp)
152     {
153         /* We can leave from here */
154         merror(FOPEN_ERROR, __local_name, KEYSFILE_PATH);
155         merror(NO_AUTHFILE, __local_name, KEYSFILE_PATH);
156         merror(NO_REM_CONN, __local_name);
157         return(0);
158     }
159
160     fclose(fp);
161
162
163     /* Authentication keys are present */
164     return(1);
165 }
166
167
168 /* void OS_ReadKeys(keystore *keys)
169  * Read the authentication keys.
170  */
171 void OS_ReadKeys(keystore *keys)
172 {
173     FILE *fp;
174     
175     char buffer[OS_BUFFER_SIZE +1];
176     
177     char name[KEYSIZE +1];
178     char ip[KEYSIZE +1];
179     char id[KEYSIZE +1];
180     char key[KEYSIZE +1];
181     
182     
183     /* Checking if the keys file is present and we can read it. */
184     if((keys->file_change = File_DateofChange(KEYS_FILE)) < 0)
185     {
186         merror(NO_AUTHFILE, __local_name, KEYS_FILE);
187         ErrorExit(NO_REM_CONN, __local_name);
188     }
189     fp = fopen(KEYS_FILE,"r");
190     if(!fp)
191     {
192         /* We can leave from here */
193         merror(FOPEN_ERROR, __local_name, KEYS_FILE);
194         ErrorExit(NO_REM_CONN, __local_name);
195     }
196
197
198     /* Initilizing hashes */
199     keys->keyhash_id = OSHash_Create();
200     keys->keyhash_ip = OSHash_Create();
201     if(!keys->keyhash_id || !keys->keyhash_ip)
202     {
203         ErrorExit(MEM_ERROR, __local_name);
204     }
205
206
207     /* Initializing structure */
208     keys->keyentries = NULL;
209     keys->keysize = 0;
210
211
212     /* Zeroing the buffers */
213     __memclear(id, name, ip, key, KEYSIZE +1);
214     memset(buffer, '\0', OS_BUFFER_SIZE +1);
215
216
217     /* Reading each line.
218      * lines are divided as "id name ip key"
219      */
220     while(fgets(buffer, OS_BUFFER_SIZE, fp) != NULL)
221     {
222         char *tmp_str;
223         char *valid_str;
224         
225         if((buffer[0] == '#') || (buffer[0] == ' '))
226             continue;
227
228
229         /* Getting ID */
230         valid_str = buffer;
231         tmp_str = strchr(buffer, ' ');
232         if(!tmp_str)
233         {
234             merror(INVALID_KEY, __local_name, buffer);
235             continue;
236         }
237
238         *tmp_str = '\0';
239         tmp_str++;
240         strncpy(id, valid_str, KEYSIZE -1);
241
242         /* Removed entry. */
243         if(*tmp_str == '#')
244         {
245             continue;
246         }
247         
248         /* Getting name */
249         valid_str = tmp_str;
250         tmp_str = strchr(tmp_str, ' ');
251         if(!tmp_str)
252         {
253             merror(INVALID_KEY, __local_name, buffer);
254         }
255
256         *tmp_str = '\0';
257         tmp_str++;
258         strncpy(name, valid_str, KEYSIZE -1);
259
260          
261         /* Getting ip address */
262         valid_str = tmp_str;
263         tmp_str = strchr(tmp_str, ' ');
264         if(!tmp_str)
265         {
266             merror(INVALID_KEY, __local_name, buffer);
267         }
268
269         *tmp_str = '\0';
270         tmp_str++;
271         strncpy(ip, valid_str, KEYSIZE -1);
272
273         
274         /* Getting key */
275         valid_str = tmp_str;
276         tmp_str = strchr(tmp_str, '\n');
277         if(tmp_str)
278         {
279             *tmp_str = '\0';
280         }
281
282         strncpy(key, valid_str, KEYSIZE -1);
283
284
285         /* Generating the key hash */
286         __chash(keys, id, name, ip, key);
287
288
289         /* Clearing the memory */
290         __memclear(id, name, ip, key, KEYSIZE +1); 
291         
292
293         /* Checking for maximum agent size */
294         if(keys->keysize >= (MAX_AGENTS -2))
295         {
296             merror(AG_MAX_ERROR, __local_name, MAX_AGENTS -2);
297             ErrorExit(CONFIG_ERROR, __local_name, KEYS_FILE);
298         }
299         
300         continue;
301     }
302     
303     
304     /* Closing key file. */
305     fclose(fp);
306
307
308     /* clear one last time before leaving */
309     __memclear(id, name, ip, key, KEYSIZE +1);          
310
311
312     /* Checking if there is any agent available */
313     if(keys->keysize == 0)
314     {
315         ErrorExit(NO_REM_CONN, __local_name);
316     }
317
318
319     /* Adding additional entry for sender == keysize */
320     os_calloc(1, sizeof(keyentry), keys->keyentries[keys->keysize]);
321
322
323     return;
324 }
325
326
327 /* void __keysfree()
328  * Frees the auth keys.
329  */
330 void OS_FreeKeys(keystore *keys)
331 {
332     int i = 0;
333     int _keysize = 0;
334     void *hashid;
335     void *haship;
336
337     _keysize = keys->keysize;
338     hashid = keys->keyhash_id;
339     haship = keys->keyhash_ip;
340
341
342     /* Zeroing the entries. */
343     keys->keysize = 0;
344     keys->keyhash_id =NULL;
345     keys->keyhash_ip = NULL;
346     
347     
348     /* Sleeping to give time to other threads to stop using them. */
349     sleep(1);
350     
351     
352     /* Freeing the hashes */
353     OSHash_Free(hashid);
354     OSHash_Free(haship);
355
356
357     for(i = 0; i<= _keysize; i++)
358     {
359         if(keys->keyentries[i])
360         {
361             if(keys->keyentries[i]->ip)
362             {
363                 free(keys->keyentries[i]->ip->ip);
364                 free(keys->keyentries[i]->ip);
365             }
366             
367             if(keys->keyentries[i]->id)    
368                 free(keys->keyentries[i]->id);
369             
370             if(keys->keyentries[i]->key)
371                 free(keys->keyentries[i]->key);
372
373             if(keys->keyentries[i]->name)
374                 free(keys->keyentries[i]->name);
375                 
376             /* Closing counter */
377             if(keys->keyentries[i]->fp)
378                 fclose(keys->keyentries[i]->fp);
379
380             free(keys->keyentries[i]);
381             keys->keyentries[i] = NULL;
382         }
383     }
384     
385     /* Freeing structure */
386     free(keys->keyentries);
387     keys->keyentries = NULL;
388     keys->keysize = 0;
389 }
390
391
392 /* int OS_CheckUpdateKeys(keystore *keys)
393  * Checks if key changed.
394  */
395 int OS_CheckUpdateKeys(keystore *keys)
396 {
397     if(keys->file_change !=  File_DateofChange(KEYS_FILE))
398     {
399         return(1);
400     }
401     return(0);
402 }
403
404
405 /* OS_UpdateKeys(keystore *keys)
406  * Update the keys if changed.
407  */
408 int OS_UpdateKeys(keystore *keys)
409 {
410     if(keys->file_change !=  File_DateofChange(KEYS_FILE))
411     {
412         merror(ENCFILE_CHANGED, __local_name);
413         debug1("%s: DEBUG: Freekeys", __local_name);
414         
415         OS_FreeKeys(keys);
416         debug1("%s: DEBUG: OS_ReadKeys", __local_name);
417         
418         /* Reading keys */
419         verbose(ENC_READ, __local_name);
420
421             
422         OS_ReadKeys(keys);
423         debug1("%s: DEBUG: OS_StartCounter", __local_name);
424         
425         OS_StartCounter(keys);
426         debug1("%s: DEBUG: OS_UpdateKeys completed", __local_name);
427         
428         return(1);
429     }
430     return(0);
431 }
432
433
434 /* OS_IsAllowedIP()
435  * Checks if an IP address is allowed to connect. 
436  */
437 int OS_IsAllowedIP(keystore *keys, char *srcip)
438 {
439     keyentry *entry;
440
441     if(srcip == NULL)
442         return(-1);
443    
444     entry = OSHash_Get(keys->keyhash_ip, srcip);
445     if(entry)
446     {
447         return(entry->keyid);
448     }
449
450     return(-1);
451 }
452
453
454 /* int OS_IsAllowedName
455  * Checks if the agent name is valid.
456  */
457 int OS_IsAllowedName(keystore *keys, char *name)
458 {
459     int i = 0;
460
461     for(i = 0; i < keys->keysize; i++)
462     {
463         if(strcmp(keys->keyentries[i]->name, name) == 0)
464             return(i);
465     }
466
467     return(-1);
468 }
469
470
471 /* OS_IsAllowedID
472  */
473 int OS_IsAllowedID(keystore *keys, char *id)
474 {
475     keyentry *entry;
476
477     if(id == NULL)
478         return(-1);
479    
480     entry = OSHash_Get(keys->keyhash_id, id);
481     if(entry)
482     {
483         return(entry->keyid);
484     }
485     return(-1);
486 }
487
488
489 /* int OS_IsAllowedDynamicID -- Used for dynamic ip addresses.
490  */
491 int OS_IsAllowedDynamicID(keystore *keys, char *id, char *srcip)
492 {
493     keyentry *entry;
494     
495     if(id == NULL)
496         return(-1);
497     
498     entry = OSHash_Get(keys->keyhash_id, id);
499     if(entry)
500     {
501         if(OS_IPFound(srcip, entry->ip))
502         {
503             return(entry->keyid);
504         }
505     }
506
507     return(-1);
508 }
509
510
511 /* EOF */