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

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

Enhanced test cases.

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
57extern  int     incontrolsock ;
58extern  int     outcontrolsock ;
59extern  int         recvcontrolto ;
60extern  int         sendcontrolto ;
61extern  RSA     *myrsa ;
62
63
64/*******************************************************************************
65** bbftpd_private_receive_connection :                                         *
66**                                                                             *
67**      This routine is called when a connection occurs in private             *
68**      authentication mode. It receives the plublic key of the client and     *
69**      gives the hand to the bbftpd_private_auth routine and then if this     *
70**      routine returns 0 to set up correctly the global parameters            *
71**                                                                             *
72**      OUPUT variable :                                                       *
73**          logmessage :  to write the error message in case of error          *
74**                                                                             *
75**      GLOBAL VARIABLE USED :                                                 *                                                                      *
76**          hisrsa              MODIFIED                                       *
77**                                                                             *
78**                                                                             *
79**      RETURN:                                                                *
80**          -1  Unrecoverable error                                            *
81**           0  OK                                                             *
82**                                                                             *
83*******************************************************************************/
84int bbftpd_private_receive_connection(int msglen) 
85{
86
87    char    *receive_buffer ;
88    char    logmessage[1024] ;
89    int     lenkey ;
90    int     lenexpo ;
91    unsigned char   *pubkey ;
92    unsigned char   *pubexponent ;
93    int     retcode ;
94    struct  mess_sec    *msg_sec ;
95   
96    sprintf(logmessage,"bbftpd version %s",VERSION) ;
97#ifndef WORDS_BIGENDIAN
98    msglen = ntohl(msglen) ;
99#endif
100    /*
101    ** First allocate the buffer
102    */
103    if ( (receive_buffer = (char *) malloc (msglen+1)) == NULL ) {
104        syslog(BBFTPD_ERR,"Error allocation memory for receive_buffer (bbftpd_private_receive_connection) ") ;
105        strcat(logmessage," : Error allocation memory for receive_buffer") ;
106        reply(MSG_BAD,logmessage) ;
107        return -1 ;
108    }
109    if ( (retcode = readmessage(incontrolsock,receive_buffer,msglen,recvcontrolto)) < 0 ) {
110        FREE(receive_buffer) ;
111        /*
112        ** Error ...
113        */
114        return(retcode) ;
115    }
116    msg_sec = (struct mess_sec *)receive_buffer ;
117    if ( msg_sec->crtype ==  CRYPT_RSA_PKCS1_OAEP_PADDING) {
118#ifndef WORDS_BIGENDIAN
119        lenkey = ntohl(msg_sec->pubkeylen) ;
120        lenexpo = ntohl(msg_sec->expolen) ;
121#else
122        lenkey = msg_sec->pubkeylen ;
123        lenexpo = msg_sec->expolen ;
124#endif
125        pubkey  = (unsigned char *)receive_buffer  + CRYPTMESSLEN ;
126        pubexponent = pubkey + lenkey ;
127        if ( (hisrsa = RSA_new()) == NULL) {
128            FREE(receive_buffer) ;
129            syslog(BBFTPD_ERR,"Error RSA_new (bbftpd_private_receive_connection) ") ;
130            strcat(logmessage," : RSA Error") ;
131            reply(MSG_BAD,logmessage) ;
132            return -1 ;
133        }
134        /*
135        ** Getting BIGNUM structures to store the key and exponent
136        */
137        if ( (hisrsa->n = BN_new()) == NULL) {
138            FREE(receive_buffer) ;
139            syslog(BBFTPD_ERR,"Error BN_new (bbftpd_private_receive_connection) ") ;
140            strcat(logmessage," : RSA Error") ;
141            reply(MSG_BAD,logmessage) ;
142            return -1 ;
143        }
144        if ( (hisrsa->e = BN_new()) == NULL) { 
145            FREE(receive_buffer) ;
146            syslog(BBFTPD_ERR,"Error BN_new (bbftpd_private_receive_connection) ") ;
147            strcat(logmessage," : RSA Error") ;
148            reply(MSG_BAD,logmessage) ;
149            return -1 ;
150        }
151        /*
152        ** Copy the key and exponent received
153        */
154        if ( BN_mpi2bn(pubkey,lenkey,hisrsa->n) == NULL ) {
155            FREE(receive_buffer) ;
156            syslog(BBFTPD_ERR,"Error BN_mpi2bn (bbftpd_private_receive_connection) ") ;
157            strcat(logmessage," : RSA Error") ;
158            reply(MSG_BAD,logmessage) ;
159            return -1 ;
160        }
161        if ( BN_mpi2bn(pubexponent,lenexpo,hisrsa->e) == NULL ) {
162            FREE(receive_buffer) ;
163            syslog(BBFTPD_ERR,"Error BN_mpi2bn (bbftpd_private_receive_connection) ") ;
164            strcat(logmessage," : RSA Error") ;
165            reply(MSG_BAD,logmessage) ;
166            return -1 ;
167        }
168    } else {
169        syslog(BBFTPD_ERR,"Unkwown encryption %d",msg_sec->crtype) ;
170        strcat(logmessage," : Unknown encryption") ;
171        reply(MSG_BAD,logmessage) ;
172        return -1 ;
173    }
174    /*
175    ** Now give hand to user routine
176    */
177
178    if ( bbftpd_private_auth(logmessage) < 0 ) {
179        syslog(BBFTPD_ERR,"bbftpd_private_auth failed : %s",logmessage) ;
180        reply(MSG_BAD,logmessage) ;
181        return -1 ;
182    }
183
184    return 0 ;
185}
186/*******************************************************************************
187** bbftpd_private_send    :                                                    *
188**                                                                             *
189**      This routine is going to crypt the buffer and to send it to the server *
190**                                                                             *
191**      OUPUT variable :                                                       *
192**          logmessage :  to write the error message in case of error          *
193**                                                                             *
194**      GLOBAL VARIABLE USED :                                                 *                                                                      *
195**                                                                             *
196**      RETURN:                                                                *
197**          -1  Unrecoverable error                                            *
198**           0  OK                                                             *
199**                                                                             *
200*******************************************************************************/
201int bbftpd_private_send(char *buffertosend, int buffertosendlength, char *logmessage)
202{
203    int     lenrsa ;
204    int     nbpackets ;
205    char    minbuffer[MINMESSLEN] ;
206    struct  message     *msg ;
207    struct  mess_private    *msg_private ;
208    char    privatebuffer[PRIVRSAMESSLEN] ;
209    char    *strtocrypt ;
210    int     lentocrypt ;
211    int     i ;
212   
213    /*
214    ** Minimum check
215    */
216    if ( buffertosendlength <=0 ) {
217        sprintf(logmessage,"buffertosendlength has to be > 0") ;
218        return -1 ;
219    } 
220    /*
221    ** First get the RSA length
222    */
223    lenrsa = RSA_size(hisrsa) ;
224    /*
225    ** Calculate the number of encrypted packets
226    ** we are going to send
227    */
228    nbpackets = buffertosendlength/(lenrsa - 42) ;
229    if (  buffertosendlength - (nbpackets*(lenrsa - 42)) != 0 ) nbpackets++ ;
230    /*
231    ** So the total length to send is nbpackets*PRIVRSAMESSLEN+MINMESSLEN
232    */
233    msg = (struct message *)minbuffer ;
234    msg->code = MSG_PRIV_DATA ;
235#ifndef WORDS_BIGENDIAN
236    msg->msglen = ntohl(nbpackets*PRIVRSAMESSLEN) ;
237#else
238    msg->msglen = nbpackets*PRIVRSAMESSLEN ;
239#endif
240    if ( writemessage(outcontrolsock,minbuffer,MINMESSLEN,recvcontrolto) < 0) {
241        sprintf(logmessage,"Error sending data") ;
242        return -1 ;
243    }
244    /*
245    ** loop on packets
246    */
247    msg_private = ( struct mess_private *) privatebuffer ;
248    strtocrypt = buffertosend ;
249    lentocrypt = lenrsa - 42 ;
250    for (i=1; i<= nbpackets ; i++ ) {
251        if ( i == nbpackets ) {
252            lentocrypt = buffertosendlength - ((nbpackets-1)*(lenrsa - 42)) ;
253        }
254        if ( (msg_private->lengthdata = RSA_public_encrypt(lentocrypt,(unsigned char *)strtocrypt,msg_private->cryptdata,hisrsa,RSA_PKCS1_OAEP_PADDING)) < 0 ) {
255            sprintf(logmessage,"Error crypting message : %s ",(char *) ERR_error_string(ERR_get_error(),NULL)) ;
256            return -1 ;
257        }
258#ifndef WORDS_BIGENDIAN
259        msg_private->lengthdata = ntohl(msg_private->lengthdata) ;
260#endif
261        if ( writemessage(outcontrolsock,privatebuffer,PRIVRSAMESSLEN,recvcontrolto) < 0) {
262            sprintf(logmessage,"Error sending encrypted data") ;
263            return -1 ;
264        }
265        strtocrypt = strtocrypt + lentocrypt ;
266    }
267    return 0 ;
268}
269/*******************************************************************************
270** bbftpd_private_recv :                                                       *
271**                                                                             *
272**      This routine is going get a message, decrypt it and fill the buffer    *
273**                                                                             *
274**      OUPUT variable :                                                       *
275**          logmessage :  to write the error message in case of error          *
276**                                                                             *
277**      GLOBAL VARIABLE USED :                                                 *                                                                      *
278**                                                                             *
279**      RETURN:                                                                *
280**          -1  Unrecoverable error                                            *
281**           >0 Number of bytes received                                       *
282**                                                                             *
283*******************************************************************************/
284int bbftpd_private_recv(char *buffertorecv, int lengthtorecv, char *logmessage)
285{
286    char    minbuffer[MINMESSLEN] ;
287    struct  message     *msg ;
288    struct  mess_private    *msg_private ;
289    char    privatebuffer[PRIVRSAMESSLEN] ;
290    char    tempbuffer[PRIVRSAMESSLEN] ;
291    int     code ;
292    int     msglen ;
293    int     expectedpackets ;
294    int      i ;
295    int     lentodecrypt ;
296    int     lendecrypted, totallendecrypted ;
297    char    *tostore ;
298
299    totallendecrypted = 0 ;
300    tostore = buffertorecv ;
301    /*
302    ** Now wait for the MSG_PRIV_DATA
303    */
304    if ( readmessage(incontrolsock,minbuffer,MINMESSLEN,recvcontrolto) < 0 ) {
305        sprintf(logmessage,"Error reading data ") ;
306        return -1 ;
307    }
308    msg = (struct message *) minbuffer ;
309    code = msg->code ;
310    if (  code != MSG_PRIV_DATA ) {
311        sprintf(logmessage,"Incorrect message header") ;
312        return -1 ;
313    } 
314#ifndef WORDS_BIGENDIAN
315    msglen = ntohl(msg->msglen) ;
316#else
317    msglen = msg->msglen ;
318#endif
319    expectedpackets = msglen/PRIVRSAMESSLEN ;
320    if ( msglen != (PRIVRSAMESSLEN * expectedpackets ) ) {
321        sprintf(logmessage,"Incorrect message length ") ;
322        return -1 ;
323    }
324    msg_private = (struct  mess_private *) privatebuffer ;
325    for ( i = 1 ; i <= expectedpackets ; i++ ) {
326        if ( readmessage(incontrolsock,privatebuffer,PRIVRSAMESSLEN,recvcontrolto) < 0 ) {
327            sprintf(logmessage,"Error reading encrypted data") ;
328            return -1 ;
329        }
330#ifndef WORDS_BIGENDIAN
331        lentodecrypt = ntohl(msg_private->lengthdata) ;
332#else
333        lentodecrypt = msg_private->lengthdata ;
334#endif
335        lendecrypted = RSA_private_decrypt(lentodecrypt,msg_private->cryptdata,(unsigned char *)tempbuffer,myrsa,RSA_PKCS1_OAEP_PADDING) ;
336        if ( totallendecrypted + lendecrypted > lengthtorecv) {
337            sprintf(logmessage,"Too much data (max=%d, receive=%d)",lengthtorecv,totallendecrypted+lendecrypted) ;
338            return -1;
339        }
340        memcpy(tostore,tempbuffer,lendecrypted) ;
341        tostore =  tostore + lendecrypted ;
342        totallendecrypted = totallendecrypted + lendecrypted ;
343    }
344    buffertorecv[totallendecrypted] = '\0' ;
345    return totallendecrypted ;
346}
347
Note: See TracBrowser for help on using the repository browser.