OLD | NEW |
1 /* crypto/camellia/camellia_cfb.c -*- mode:C; c-file-style: "eay" -*- */ | 1 /* crypto/camellia/camellia_cfb.c -*- mode:C; c-file-style: "eay" -*- */ |
2 /* ==================================================================== | 2 /* ==================================================================== |
3 * Copyright (c) 2006 The OpenSSL Project. All rights reserved. | 3 * Copyright (c) 2006 The OpenSSL Project. All rights reserved. |
4 * | 4 * |
5 * Redistribution and use in source and binary forms, with or without | 5 * Redistribution and use in source and binary forms, with or without |
6 * modification, are permitted provided that the following conditions | 6 * modification, are permitted provided that the following conditions |
7 * are met: | 7 * are met: |
8 * | 8 * |
9 * 1. Redistributions of source code must retain the above copyright | 9 * 1. Redistributions of source code must retain the above copyright |
10 * notice, this list of conditions and the following disclaimer. | 10 * notice, this list of conditions and the following disclaimer. |
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
98 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | 98 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
99 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | 99 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
100 * SUCH DAMAGE. | 100 * SUCH DAMAGE. |
101 * | 101 * |
102 * The licence and distribution terms for any publically available version or | 102 * The licence and distribution terms for any publically available version or |
103 * derivative of this code cannot be changed. i.e. this code cannot simply be | 103 * derivative of this code cannot be changed. i.e. this code cannot simply be |
104 * copied and put under another distribution licence | 104 * copied and put under another distribution licence |
105 * [including the GNU Public Licence.] | 105 * [including the GNU Public Licence.] |
106 */ | 106 */ |
107 | 107 |
108 #ifndef CAMELLIA_DEBUG | |
109 # ifndef NDEBUG | |
110 # define NDEBUG | |
111 # endif | |
112 #endif | |
113 #include <assert.h> | |
114 #include <string.h> | |
115 | |
116 #include <openssl/camellia.h> | 108 #include <openssl/camellia.h> |
117 #include "cmll_locl.h" | 109 #include <openssl/modes.h> |
118 #include "e_os.h" | |
119 | 110 |
120 | 111 |
121 /* The input and output encrypted as though 128bit cfb mode is being | 112 /* The input and output encrypted as though 128bit cfb mode is being |
122 * used. The extra state information to record how much of the | 113 * used. The extra state information to record how much of the |
123 * 128bit block we have used is contained in *num; | 114 * 128bit block we have used is contained in *num; |
124 */ | 115 */ |
125 | 116 |
126 void Camellia_cfb128_encrypt(const unsigned char *in, unsigned char *out, | 117 void Camellia_cfb128_encrypt(const unsigned char *in, unsigned char *out, |
127 » const unsigned long length, const CAMELLIA_KEY *key, | 118 » size_t length, const CAMELLIA_KEY *key, |
128 unsigned char *ivec, int *num, const int enc) | 119 unsigned char *ivec, int *num, const int enc) |
129 { | 120 { |
130 | 121 |
131 » unsigned int n; | 122 » CRYPTO_cfb128_encrypt(in,out,length,key,ivec,num,enc,(block128_f)Camelli
a_encrypt); |
132 » unsigned long l = length; | |
133 » unsigned char c; | |
134 | |
135 » assert(in && out && key && ivec && num); | |
136 | |
137 » n = *num; | |
138 | |
139 » if (enc) | |
140 » » { | |
141 » » while (l--) | |
142 » » » { | |
143 » » » if (n == 0) | |
144 » » » » { | |
145 » » » » Camellia_encrypt(ivec, ivec, key); | |
146 » » » » } | |
147 » » » ivec[n] = *(out++) = *(in++) ^ ivec[n]; | |
148 » » » n = (n+1) % CAMELLIA_BLOCK_SIZE; | |
149 » » » } | |
150 » » } | |
151 » else | |
152 » » { | |
153 » » while (l--) | |
154 » » » { | |
155 » » » if (n == 0) | |
156 » » » » { | |
157 » » » » Camellia_encrypt(ivec, ivec, key); | |
158 » » » » } | |
159 » » » c = *(in); | |
160 » » » *(out++) = *(in++) ^ ivec[n]; | |
161 » » » ivec[n] = c; | |
162 » » » n = (n+1) % CAMELLIA_BLOCK_SIZE; | |
163 » » » } | |
164 » » } | |
165 | |
166 » *num=n; | |
167 » } | |
168 | |
169 /* This expects a single block of size nbits for both in and out. Note that | |
170 it corrupts any extra bits in the last byte of out */ | |
171 void Camellia_cfbr_encrypt_block(const unsigned char *in,unsigned char *out, | |
172 » const int nbits,const CAMELLIA_KEY *key, | |
173 » unsigned char *ivec,const int enc) | |
174 » { | |
175 » int n,rem,num; | |
176 » unsigned char ovec[CAMELLIA_BLOCK_SIZE*2]; | |
177 | |
178 » if (nbits<=0 || nbits>128) return; | |
179 | |
180 » /* fill in the first half of the new IV with the current IV */ | |
181 » memcpy(ovec,ivec,CAMELLIA_BLOCK_SIZE); | |
182 » /* construct the new IV */ | |
183 » Camellia_encrypt(ivec,ivec,key); | |
184 » num = (nbits+7)/8; | |
185 » if (enc)» /* encrypt the input */ | |
186 » » for(n=0 ; n < num ; ++n) | |
187 » » » out[n] = (ovec[CAMELLIA_BLOCK_SIZE+n] = in[n] ^ ivec[n])
; | |
188 » else» » /* decrypt the input */ | |
189 » » for(n=0 ; n < num ; ++n) | |
190 » » » out[n] = (ovec[CAMELLIA_BLOCK_SIZE+n] = in[n]) ^ ivec[n]
; | |
191 » /* shift ovec left... */ | |
192 » rem = nbits%8; | |
193 » num = nbits/8; | |
194 » if(rem==0) | |
195 » » memcpy(ivec,ovec+num,CAMELLIA_BLOCK_SIZE); | |
196 » else | |
197 » » for(n=0 ; n < CAMELLIA_BLOCK_SIZE ; ++n) | |
198 » » » ivec[n] = ovec[n+num]<<rem | ovec[n+num+1]>>(8-rem); | |
199 | |
200 » /* it is not necessary to cleanse ovec, since the IV is not secret */ | |
201 } | 123 } |
202 | 124 |
203 /* N.B. This expects the input to be packed, MS bit first */ | 125 /* N.B. This expects the input to be packed, MS bit first */ |
204 void Camellia_cfb1_encrypt(const unsigned char *in, unsigned char *out, | 126 void Camellia_cfb1_encrypt(const unsigned char *in, unsigned char *out, |
205 » const unsigned long length, const CAMELLIA_KEY *key, | 127 » size_t length, const CAMELLIA_KEY *key, |
206 unsigned char *ivec, int *num, const int enc) | 128 unsigned char *ivec, int *num, const int enc) |
207 { | 129 { |
208 » unsigned int n; | 130 » CRYPTO_cfb128_1_encrypt(in,out,length,key,ivec,num,enc,(block128_f)Camel
lia_encrypt); |
209 » unsigned char c[1],d[1]; | |
210 | |
211 » assert(in && out && key && ivec && num); | |
212 » assert(*num == 0); | |
213 | |
214 » memset(out,0,(length+7)/8); | |
215 » for(n=0 ; n < length ; ++n) | |
216 » » { | |
217 » » c[0]=(in[n/8]&(1 << (7-n%8))) ? 0x80 : 0; | |
218 » » Camellia_cfbr_encrypt_block(c,d,1,key,ivec,enc); | |
219 » » out[n/8]=(out[n/8]&~(1 << (7-n%8)))|((d[0]&0x80) >> (n%8)); | |
220 » » } | |
221 } | 131 } |
222 | 132 |
223 void Camellia_cfb8_encrypt(const unsigned char *in, unsigned char *out, | 133 void Camellia_cfb8_encrypt(const unsigned char *in, unsigned char *out, |
224 » const unsigned long length, const CAMELLIA_KEY *key, | 134 » size_t length, const CAMELLIA_KEY *key, |
225 unsigned char *ivec, int *num, const int enc) | 135 unsigned char *ivec, int *num, const int enc) |
226 { | 136 { |
227 » unsigned int n; | 137 » CRYPTO_cfb128_8_encrypt(in,out,length,key,ivec,num,enc,(block128_f)Camel
lia_encrypt); |
228 | |
229 » assert(in && out && key && ivec && num); | |
230 » assert(*num == 0); | |
231 | |
232 » for(n=0 ; n < length ; ++n) | |
233 » » Camellia_cfbr_encrypt_block(&in[n],&out[n],8,key,ivec,enc); | |
234 } | 138 } |
235 | 139 |
OLD | NEW |