source: TI05-delivery/trunk/src/bbftp-server-3.2.0/bbftpd/bbftpd_private.c @ 975

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI05-delivery/trunk/src/bbftp-server-3.2.0/bbftpd/bbftpd_private.c@975
Revision 975, 15.5 KB checked in by spascoe, 13 years ago (diff)

Got bbftpd_private_finalise working by setting a SIGTERM signal handler.
This is confirmed by running the test suite and examining /var/log/messages.

Line 
1/*
2 * bbftpd/bbftpd_private.c
3 * Copyright (C) 1999, 2000, 2001, 2002 IN2P3, CNRS
4 * bbftp@in2p3.fr
5 * http://doc.in2p3.fr/bbftp
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or any later version.
11 *
12 * This program 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
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
20 */ 
21
22/****************************************************************************
23
24 
25 
26 bbftpd_private.c   v 2.1.0 2001/05/21  - Routines creation
27
28*****************************************************************************/
29#include <errno.h>
30#include <netinet/in.h>
31#include <stdio.h>
32#include <syslog.h>
33#include <sys/socket.h>
34#if TIME_WITH_SYS_TIME
35# include <sys/time.h>
36# include <time.h>
37#else
38# if HAVE_SYS_TIME_H
39#  include <sys/time.h>
40# else
41#  include <time.h>
42# endif
43#endif
44#include <utime.h>
45
46#include <openssl/rsa.h>
47
48#include <bbftpd.h>
49#include <bbftpd_private.h>
50#include <config.h>
51#include <common.h>
52#include <daemon_proto.h>
53#include <daemon.h>
54#include <structures.h>
55#include <version.h>
56
57#ifdef NDG_AUTH
58#include <signal.h>
59#endif // NDG_AUTH
60
61extern  int     incontrolsock ;
62extern  int     outcontrolsock ;
63extern  int         recvcontrolto ;
64extern  int         sendcontrolto ;
65extern  RSA     *myrsa ;
66
67
68/*******************************************************************************
69** bbftpd_private_receive_connection :                                         *
70**                                                                             *
71**      This routine is called when a connection occurs in private             *
72**      authentication mode. It receives the plublic key of the client and     *
73**      gives the hand to the bbftpd_private_auth routine and then if this     *
74**      routine returns 0 to set up correctly the global parameters            *
75**                                                                             *
76**      OUPUT variable :                                                       *
77**          logmessage :  to write the error message in case of error          *
78**                                                                             *
79**      GLOBAL VARIABLE USED :                                                 *                                                                      *
80**          hisrsa              MODIFIED                                       *
81**                                                                             *
82**                                                                             *
83**      RETURN:                                                                *
84**          -1  Unrecoverable error                                            *
85**           0  OK                                                             *
86**                                                                             *
87*******************************************************************************/
88int bbftpd_private_receive_connection(int msglen) 
89{
90
91    char    *receive_buffer ;
92    char    logmessage[1024] ;
93    int     lenkey ;
94    int     lenexpo ;
95    unsigned char   *pubkey ;
96    unsigned char   *pubexponent ;
97    int     retcode ;
98    struct  mess_sec    *msg_sec ;
99   
100    sprintf(logmessage,"bbftpd version %s",VERSION) ;
101#ifndef WORDS_BIGENDIAN
102    msglen = ntohl(msglen) ;
103#endif
104    /*
105    ** First allocate the buffer
106    */
107    if ( (receive_buffer = (char *) malloc (msglen+1)) == NULL ) {
108        syslog(BBFTPD_ERR,"Error allocation memory for receive_buffer (bbftpd_private_receive_connection) ") ;
109        strcat(logmessage," : Error allocation memory for receive_buffer") ;
110        reply(MSG_BAD,logmessage) ;
111        return -1 ;
112    }
113    if ( (retcode = readmessage(incontrolsock,receive_buffer,msglen,recvcontrolto)) < 0 ) {
114        FREE(receive_buffer) ;
115        /*
116        ** Error ...
117        */
118        return(retcode) ;
119    }
120    msg_sec = (struct mess_sec *)receive_buffer ;
121    if ( msg_sec->crtype ==  CRYPT_RSA_PKCS1_OAEP_PADDING) {
122#ifndef WORDS_BIGENDIAN
123        lenkey = ntohl(msg_sec->pubkeylen) ;
124        lenexpo = ntohl(msg_sec->expolen) ;
125#else
126        lenkey = msg_sec->pubkeylen ;
127        lenexpo = msg_sec->expolen ;
128#endif
129        pubkey  = (unsigned char *)receive_buffer  + CRYPTMESSLEN ;
130        pubexponent = pubkey + lenkey ;
131        if ( (hisrsa = RSA_new()) == NULL) {
132            FREE(receive_buffer) ;
133            syslog(BBFTPD_ERR,"Error RSA_new (bbftpd_private_receive_connection) ") ;
134            strcat(logmessage," : RSA Error") ;
135            reply(MSG_BAD,logmessage) ;
136            return -1 ;
137        }
138        /*
139        ** Getting BIGNUM structures to store the key and exponent
140        */
141        if ( (hisrsa->n = BN_new()) == NULL) {
142            FREE(receive_buffer) ;
143            syslog(BBFTPD_ERR,"Error BN_new (bbftpd_private_receive_connection) ") ;
144            strcat(logmessage," : RSA Error") ;
145            reply(MSG_BAD,logmessage) ;
146            return -1 ;
147        }
148        if ( (hisrsa->e = BN_new()) == NULL) { 
149            FREE(receive_buffer) ;
150            syslog(BBFTPD_ERR,"Error BN_new (bbftpd_private_receive_connection) ") ;
151            strcat(logmessage," : RSA Error") ;
152            reply(MSG_BAD,logmessage) ;
153            return -1 ;
154        }
155        /*
156        ** Copy the key and exponent received
157        */
158        if ( BN_mpi2bn(pubkey,lenkey,hisrsa->n) == NULL ) {
159            FREE(receive_buffer) ;
160            syslog(BBFTPD_ERR,"Error BN_mpi2bn (bbftpd_private_receive_connection) ") ;
161            strcat(logmessage," : RSA Error") ;
162            reply(MSG_BAD,logmessage) ;
163            return -1 ;
164        }
165        if ( BN_mpi2bn(pubexponent,lenexpo,hisrsa->e) == NULL ) {
166            FREE(receive_buffer) ;
167            syslog(BBFTPD_ERR,"Error BN_mpi2bn (bbftpd_private_receive_connection) ") ;
168            strcat(logmessage," : RSA Error") ;
169            reply(MSG_BAD,logmessage) ;
170            return -1 ;
171        }
172    } else {
173        syslog(BBFTPD_ERR,"Unkwown encryption %d",msg_sec->crtype) ;
174        strcat(logmessage," : Unknown encryption") ;
175        reply(MSG_BAD,logmessage) ;
176        return -1 ;
177    }
178    /*
179    ** Now give hand to user routine
180    */
181    if ( bbftpd_private_auth(logmessage) < 0 ) {
182        syslog(BBFTPD_ERR,"bbftpd_private_auth failed : %s",logmessage) ;
183        reply(MSG_BAD,logmessage) ;
184        return -1 ;
185    }
186#ifdef NDG_AUTH
187    ndg_atexit_status = NDG_INCHILD;
188#endif // NDG_AUTH
189
190    return 0 ;
191}
192/*******************************************************************************
193** bbftpd_private_send    :                                                    *
194**                                                                             *
195**      This routine is going to crypt the buffer and to send it to the server *
196**                                                                             *
197**      OUPUT variable :                                                       *
198**          logmessage :  to write the error message in case of error          *
199**                                                                             *
200**      GLOBAL VARIABLE USED :                                                 *                                                                      *
201**                                                                             *
202**      RETURN:                                                                *
203**          -1  Unrecoverable error                                            *
204**           0  OK                                                             *
205**                                                                             *
206*******************************************************************************/
207int bbftpd_private_send(char *buffertosend, int buffertosendlength, char *logmessage)
208{
209    int     lenrsa ;
210    int     nbpackets ;
211    char    minbuffer[MINMESSLEN] ;
212    struct  message     *msg ;
213    struct  mess_private    *msg_private ;
214    char    privatebuffer[PRIVRSAMESSLEN] ;
215    char    *strtocrypt ;
216    int     lentocrypt ;
217    int     i ;
218   
219    /*
220    ** Minimum check
221    */
222    if ( buffertosendlength <=0 ) {
223        sprintf(logmessage,"buffertosendlength has to be > 0") ;
224        return -1 ;
225    } 
226    /*
227    ** First get the RSA length
228    */
229    lenrsa = RSA_size(hisrsa) ;
230    /*
231    ** Calculate the number of encrypted packets
232    ** we are going to send
233    */
234    nbpackets = buffertosendlength/(lenrsa - 42) ;
235    if (  buffertosendlength - (nbpackets*(lenrsa - 42)) != 0 ) nbpackets++ ;
236    /*
237    ** So the total length to send is nbpackets*PRIVRSAMESSLEN+MINMESSLEN
238    */
239    msg = (struct message *)minbuffer ;
240    msg->code = MSG_PRIV_DATA ;
241#ifndef WORDS_BIGENDIAN
242    msg->msglen = ntohl(nbpackets*PRIVRSAMESSLEN) ;
243#else
244    msg->msglen = nbpackets*PRIVRSAMESSLEN ;
245#endif
246    if ( writemessage(outcontrolsock,minbuffer,MINMESSLEN,recvcontrolto) < 0) {
247        sprintf(logmessage,"Error sending data") ;
248        return -1 ;
249    }
250    /*
251    ** loop on packets
252    */
253    msg_private = ( struct mess_private *) privatebuffer ;
254    strtocrypt = buffertosend ;
255    lentocrypt = lenrsa - 42 ;
256    for (i=1; i<= nbpackets ; i++ ) {
257        if ( i == nbpackets ) {
258            lentocrypt = buffertosendlength - ((nbpackets-1)*(lenrsa - 42)) ;
259        }
260        if ( (msg_private->lengthdata = RSA_public_encrypt(lentocrypt,(unsigned char *)strtocrypt,msg_private->cryptdata,hisrsa,RSA_PKCS1_OAEP_PADDING)) < 0 ) {
261            sprintf(logmessage,"Error crypting message : %s ",(char *) ERR_error_string(ERR_get_error(),NULL)) ;
262            return -1 ;
263        }
264#ifndef WORDS_BIGENDIAN
265        msg_private->lengthdata = ntohl(msg_private->lengthdata) ;
266#endif
267        if ( writemessage(outcontrolsock,privatebuffer,PRIVRSAMESSLEN,recvcontrolto) < 0) {
268            sprintf(logmessage,"Error sending encrypted data") ;
269            return -1 ;
270        }
271        strtocrypt = strtocrypt + lentocrypt ;
272    }
273    return 0 ;
274}
275/*******************************************************************************
276** bbftpd_private_recv :                                                       *
277**                                                                             *
278**      This routine is going get a message, decrypt it and fill the buffer    *
279**                                                                             *
280**      OUPUT variable :                                                       *
281**          logmessage :  to write the error message in case of error          *
282**                                                                             *
283**      GLOBAL VARIABLE USED :                                                 *                                                                      *
284**                                                                             *
285**      RETURN:                                                                *
286**          -1  Unrecoverable error                                            *
287**           >0 Number of bytes received                                       *
288**                                                                             *
289*******************************************************************************/
290int bbftpd_private_recv(char *buffertorecv, int lengthtorecv, char *logmessage)
291{
292    char    minbuffer[MINMESSLEN] ;
293    struct  message     *msg ;
294    struct  mess_private    *msg_private ;
295    char    privatebuffer[PRIVRSAMESSLEN] ;
296    char    tempbuffer[PRIVRSAMESSLEN] ;
297    int     code ;
298    int     msglen ;
299    int     expectedpackets ;
300    int      i ;
301    int     lentodecrypt ;
302    int     lendecrypted, totallendecrypted ;
303    char    *tostore ;
304
305    totallendecrypted = 0 ;
306    tostore = buffertorecv ;
307    /*
308    ** Now wait for the MSG_PRIV_DATA
309    */
310    if ( readmessage(incontrolsock,minbuffer,MINMESSLEN,recvcontrolto) < 0 ) {
311        sprintf(logmessage,"Error reading data ") ;
312        return -1 ;
313    }
314    msg = (struct message *) minbuffer ;
315    code = msg->code ;
316    if (  code != MSG_PRIV_DATA ) {
317        sprintf(logmessage,"Incorrect message header") ;
318        return -1 ;
319    } 
320#ifndef WORDS_BIGENDIAN
321    msglen = ntohl(msg->msglen) ;
322#else
323    msglen = msg->msglen ;
324#endif
325    expectedpackets = msglen/PRIVRSAMESSLEN ;
326    if ( msglen != (PRIVRSAMESSLEN * expectedpackets ) ) {
327        sprintf(logmessage,"Incorrect message length ") ;
328        return -1 ;
329    }
330    msg_private = (struct  mess_private *) privatebuffer ;
331    for ( i = 1 ; i <= expectedpackets ; i++ ) {
332        if ( readmessage(incontrolsock,privatebuffer,PRIVRSAMESSLEN,recvcontrolto) < 0 ) {
333            sprintf(logmessage,"Error reading encrypted data") ;
334            return -1 ;
335        }
336#ifndef WORDS_BIGENDIAN
337        lentodecrypt = ntohl(msg_private->lengthdata) ;
338#else
339        lentodecrypt = msg_private->lengthdata ;
340#endif
341        lendecrypted = RSA_private_decrypt(lentodecrypt,msg_private->cryptdata,(unsigned char *)tempbuffer,myrsa,RSA_PKCS1_OAEP_PADDING) ;
342        if ( totallendecrypted + lendecrypted > lengthtorecv) {
343            sprintf(logmessage,"Too much data (max=%d, receive=%d)",lengthtorecv,totallendecrypted+lendecrypted) ;
344            return -1;
345        }
346        memcpy(tostore,tempbuffer,lendecrypted) ;
347        tostore =  tostore + lendecrypted ;
348        totallendecrypted = totallendecrypted + lendecrypted ;
349    }
350    buffertorecv[totallendecrypted] = '\0' ;
351    return totallendecrypted ;
352}
353
354
355#ifdef NDG_AUTH
356/*
357** bbftpd_private_initialise :
358**
359**      Routine to initialise the private authentication infrastructure.
360**      This function is mainly a wrapper around bbftpd_private_init(),
361**      except that it also sets up an atexit function.
362*/
363int bbftpd_private_initialise(char *logmessage) {
364  struct sigaction sga;
365
366  /* Set signal handlers for the daemon.
367   */
368  sga.sa_handler = bbftpd_private_sigaction ;
369  sigemptyset(&(sga.sa_mask));
370  sga.sa_flags = 0  ;
371  if ( sigaction(SIGTERM,&sga,0) < 0 ) {
372    syslog(BBFTPD_ERR,"Error sigaction SIGCTERM : %s",strerror(errno)) ;
373    return -1;
374  }
375
376
377  if (atexit(bbftpd_private_atexit) != 0) {
378    sprintf(logmessage, "atexit failure");
379    return -1;
380  }
381  ndg_atexit_status = NDG_INFATHER;
382  return bbftpd_private_init(logmessage);
383}
384
385/*
386** bbftpd_private_sigaction(int sig)
387**
388**      Routine to exit gracefully if SIGTERM is sent.  The daemon process
389**      will not call any atexit() functions on receipt of SIGTERM by default.
390**      This function is a signal handler to change this behaviour.
391*/
392void bbftpd_private_sigaction(int sig)
393{
394  // Hopefully calling atexit() handlers.
395  exit(0);
396}
397
398
399/*
400** bbftpd_private_atexit :
401**
402**      Routine to be registered with atexit() for cleaning up the private authentication
403**      infrastructure.  This function must know whether the server is in a connected or
404**      unconnected state, therefore the global variable ndg_atexit_status is used.
405*/
406void bbftpd_private_atexit(void)
407{
408  if (ndg_atexit_status == NDG_INFATHER) {
409    bbftpd_private_finalise();
410  }
411  else if (ndg_atexit_status == NDG_INCHILD) {
412    bbftpd_private_auth_finalise();
413  }
414  else {
415    syslog(BBFTPD_ERR, "ndg_atexit_status unrecognised: %d", ndg_atexit_status);
416    fprintf(stderr, "ndg_atexit_status unrecognised: %d", ndg_atexit_status);
417  }
418}
419#endif // NDG_AUTH
Note: See TracBrowser for help on using the repository browser.