|
1 /* crypto/des/enc_read.c */ |
|
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) |
|
3 * All rights reserved. |
|
4 * |
|
5 * This package is an SSL implementation written |
|
6 * by Eric Young (eay@cryptsoft.com). |
|
7 * The implementation was written so as to conform with Netscapes SSL. |
|
8 * |
|
9 * This library is free for commercial and non-commercial use as long as |
|
10 * the following conditions are aheared to. The following conditions |
|
11 * apply to all code found in this distribution, be it the RC4, RSA, |
|
12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|
13 * included with this distribution is covered by the same copyright terms |
|
14 * except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|
15 * |
|
16 * Copyright remains Eric Young's, and as such any Copyright notices in |
|
17 * the code are not to be removed. |
|
18 * If this package is used in a product, Eric Young should be given attribution |
|
19 * as the author of the parts of the library used. |
|
20 * This can be in the form of a textual message at program startup or |
|
21 * in documentation (online or textual) provided with the package. |
|
22 * |
|
23 * Redistribution and use in source and binary forms, with or without |
|
24 * modification, are permitted provided that the following conditions |
|
25 * are met: |
|
26 * 1. Redistributions of source code must retain the copyright |
|
27 * notice, this list of conditions and the following disclaimer. |
|
28 * 2. Redistributions in binary form must reproduce the above copyright |
|
29 * notice, this list of conditions and the following disclaimer in the |
|
30 * documentation and/or other materials provided with the distribution. |
|
31 * 3. All advertising materials mentioning features or use of this software |
|
32 * must display the following acknowledgement: |
|
33 * "This product includes cryptographic software written by |
|
34 * Eric Young (eay@cryptsoft.com)" |
|
35 * The word 'cryptographic' can be left out if the rouines from the library |
|
36 * being used are not cryptographic related :-). |
|
37 * 4. If you include any Windows specific code (or a derivative thereof) from |
|
38 * the apps directory (application code) you must include an acknowledgement: |
|
39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|
40 * |
|
41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|
42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|
43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|
44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|
45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|
46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|
47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|
49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|
50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|
51 * SUCH DAMAGE. |
|
52 * |
|
53 * The licence and distribution terms for any publically available version or |
|
54 * derivative of this code cannot be changed. i.e. this code cannot simply be |
|
55 * copied and put under another distribution licence |
|
56 * [including the GNU Public Licence.] |
|
57 */ |
|
58 /* |
|
59 © Portions copyright (c) 2006 Nokia Corporation. All rights reserved. |
|
60 */ |
|
61 |
|
62 #include <stdio.h> |
|
63 #include <errno.h> |
|
64 #include "cryptlib.h" |
|
65 #include "des_locl.h" |
|
66 #if (defined(SYMBIAN) && (defined(__WINSCW__) || defined(__WINS__))) |
|
67 #include "libcrypto_wsd_macros.h" |
|
68 #include "libcrypto_wsd.h" |
|
69 #endif |
|
70 /* This has some uglies in it but it works - even over sockets. */ |
|
71 /*extern int errno;*/ |
|
72 #ifndef EMULATOR |
|
73 OPENSSL_IMPLEMENT_GLOBAL(int,DES_rw_mode)=DES_PCBC_MODE; |
|
74 #else |
|
75 #define DES_rw_mode libcrypto_ImpurePtr()->_shadow_DES_rw_mode |
|
76 #endif |
|
77 |
|
78 /* |
|
79 * WARNINGS: |
|
80 * |
|
81 * - The data format used by DES_enc_write() and DES_enc_read() |
|
82 * has a cryptographic weakness: When asked to write more |
|
83 * than MAXWRITE bytes, DES_enc_write will split the data |
|
84 * into several chunks that are all encrypted |
|
85 * using the same IV. So don't use these functions unless you |
|
86 * are sure you know what you do (in which case you might |
|
87 * not want to use them anyway). |
|
88 * |
|
89 * - This code cannot handle non-blocking sockets. |
|
90 * |
|
91 * - This function uses an internal state and thus cannot be |
|
92 * used on multiple files. |
|
93 */ |
|
94 |
|
95 #ifdef EMULATOR |
|
96 GET_STATIC_VAR_FROM_TLS(net,enc_read,unsigned char *) |
|
97 #define net (*GET_WSD_VAR_NAME(net,enc_read, s)()) |
|
98 |
|
99 GET_STATIC_VAR_FROM_TLS(unnet,enc_read,unsigned char *) |
|
100 #define unnet (*GET_WSD_VAR_NAME(unnet,enc_read, s)()) |
|
101 |
|
102 GET_STATIC_VAR_FROM_TLS(unnet_start,enc_read,int) |
|
103 #define unnet_start (*GET_WSD_VAR_NAME(unnet_start,enc_read, s)()) |
|
104 |
|
105 GET_STATIC_VAR_FROM_TLS(unnet_left,enc_read,int) |
|
106 #define unnet_left (*GET_WSD_VAR_NAME(unnet_left,enc_read, s)()) |
|
107 |
|
108 GET_STATIC_VAR_FROM_TLS(tmpbuf,enc_read,unsigned char *) |
|
109 #define tmpbuf (*GET_WSD_VAR_NAME(tmpbuf,enc_read, s)()) |
|
110 |
|
111 |
|
112 #endif |
|
113 |
|
114 |
|
115 EXPORT_C int DES_enc_read(int fd, void *buf, int len, DES_key_schedule *sched, |
|
116 DES_cblock *iv) |
|
117 { |
|
118 /* data to be unencrypted */ |
|
119 int net_num=0; |
|
120 #ifndef EMULATOR |
|
121 static unsigned char *net=NULL; |
|
122 |
|
123 /* extra unencrypted data |
|
124 * for when a block of 100 comes in but is des_read one byte at |
|
125 * a time. */ |
|
126 static unsigned char *unnet=NULL; |
|
127 static int unnet_start=0; |
|
128 static int unnet_left=0; |
|
129 static unsigned char *tmpbuf=NULL; |
|
130 #endif |
|
131 int i; |
|
132 long num=0,rnum; |
|
133 unsigned char *p; |
|
134 |
|
135 if (tmpbuf == NULL) |
|
136 { |
|
137 tmpbuf=OPENSSL_malloc(BSIZE); |
|
138 if (tmpbuf == NULL) return(-1); |
|
139 } |
|
140 if (net == NULL) |
|
141 { |
|
142 net=OPENSSL_malloc(BSIZE); |
|
143 if (net == NULL) return(-1); |
|
144 } |
|
145 if (unnet == NULL) |
|
146 { |
|
147 unnet=OPENSSL_malloc(BSIZE); |
|
148 if (unnet == NULL) return(-1); |
|
149 } |
|
150 /* left over data from last decrypt */ |
|
151 if (unnet_left != 0) |
|
152 { |
|
153 if (unnet_left < len) |
|
154 { |
|
155 /* we still still need more data but will return |
|
156 * with the number of bytes we have - should always |
|
157 * check the return value */ |
|
158 memcpy(buf,&(unnet[unnet_start]), |
|
159 unnet_left); |
|
160 /* eay 26/08/92 I had the next 2 lines |
|
161 * reversed :-( */ |
|
162 i=unnet_left; |
|
163 unnet_start=unnet_left=0; |
|
164 } |
|
165 else |
|
166 { |
|
167 memcpy(buf,&(unnet[unnet_start]),len); |
|
168 unnet_start+=len; |
|
169 unnet_left-=len; |
|
170 i=len; |
|
171 } |
|
172 return(i); |
|
173 } |
|
174 |
|
175 /* We need to get more data. */ |
|
176 if (len > MAXWRITE) len=MAXWRITE; |
|
177 |
|
178 /* first - get the length */ |
|
179 while (net_num < HDRSIZE) |
|
180 { |
|
181 i=read(fd,(void *)&(net[net_num]),HDRSIZE-net_num); |
|
182 #ifdef EINTR |
|
183 if ((i == -1) && (errno == EINTR)) continue; |
|
184 #endif |
|
185 if (i <= 0) return(0); |
|
186 net_num+=i; |
|
187 } |
|
188 |
|
189 /* we now have at net_num bytes in net */ |
|
190 p=net; |
|
191 /* num=0; */ |
|
192 n2l(p,num); |
|
193 /* num should be rounded up to the next group of eight |
|
194 * we make sure that we have read a multiple of 8 bytes from the net. |
|
195 */ |
|
196 if ((num > MAXWRITE) || (num < 0)) /* error */ |
|
197 return(-1); |
|
198 rnum=(num < 8)?8:((num+7)/8*8); |
|
199 |
|
200 net_num=0; |
|
201 while (net_num < rnum) |
|
202 { |
|
203 i=read(fd,(void *)&(net[net_num]),rnum-net_num); |
|
204 #ifdef EINTR |
|
205 if ((i == -1) && (errno == EINTR)) continue; |
|
206 #endif |
|
207 if (i <= 0) return(0); |
|
208 net_num+=i; |
|
209 } |
|
210 |
|
211 /* Check if there will be data left over. */ |
|
212 if (len < num) |
|
213 { |
|
214 if (DES_rw_mode & DES_PCBC_MODE) |
|
215 DES_pcbc_encrypt(net,unnet,num,sched,iv,DES_DECRYPT); |
|
216 else |
|
217 DES_cbc_encrypt(net,unnet,num,sched,iv,DES_DECRYPT); |
|
218 memcpy(buf,unnet,len); |
|
219 unnet_start=len; |
|
220 unnet_left=num-len; |
|
221 |
|
222 /* The following line is done because we return num |
|
223 * as the number of bytes read. */ |
|
224 num=len; |
|
225 } |
|
226 else |
|
227 { |
|
228 /* >output is a multiple of 8 byes, if len < rnum |
|
229 * >we must be careful. The user must be aware that this |
|
230 * >routine will write more bytes than he asked for. |
|
231 * >The length of the buffer must be correct. |
|
232 * FIXED - Should be ok now 18-9-90 - eay */ |
|
233 if (len < rnum) |
|
234 { |
|
235 |
|
236 if (DES_rw_mode & DES_PCBC_MODE) |
|
237 DES_pcbc_encrypt(net,tmpbuf,num,sched,iv, |
|
238 DES_DECRYPT); |
|
239 else |
|
240 DES_cbc_encrypt(net,tmpbuf,num,sched,iv, |
|
241 DES_DECRYPT); |
|
242 |
|
243 /* eay 26/08/92 fix a bug that returned more |
|
244 * bytes than you asked for (returned len bytes :-( */ |
|
245 memcpy(buf,tmpbuf,num); |
|
246 } |
|
247 else |
|
248 { |
|
249 if (DES_rw_mode & DES_PCBC_MODE) |
|
250 DES_pcbc_encrypt(net,buf,num,sched,iv, |
|
251 DES_DECRYPT); |
|
252 else |
|
253 DES_cbc_encrypt(net,buf,num,sched,iv, |
|
254 DES_DECRYPT); |
|
255 } |
|
256 } |
|
257 return num; |
|
258 } |
|
259 |