← Back to branch summary

~andersk/ubuntu/oneiric/openssl/spurious-reboot

« back to all changes in this revision

Viewing changes to crypto/camellia/cmll_cfb.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson
  • Date: 2011-05-01 23:51:53 UTC
  • mfrom: (11.1.20 sid)
  • Revision ID: james.westby@ubuntu.com-20110501235153-bjcxitndquaezb68
Tags: 1.0.0d-2ubuntu1
https://launchpad.net/bugs/675566
* Resynchronise with Debian (LP: #675566).  Remaining changes:
  - debian/libssl1.0.0.postinst:
    + Display a system restart required notification bubble on libssl1.0.0
      upgrade.
    + Use a different priority for libssl1.0.0/restart-services depending
      on whether a desktop, or server dist-upgrade is being performed.
  - debian/{libssl1.0.0-udeb.dirs, control, rules}: Create
    libssl1.0.0-udeb, for the benefit of wget-udeb (no wget-udeb package
    in Debian).
  - debian/{libcrypto1.0.0-udeb.dirs, libssl1.0.0.dirs, libssl1.0.0.files,
    rules}: Move runtime libraries to /lib, for the benefit of
    wpasupplicant.
  - debian/patches/aesni.patch: Backport Intel AES-NI support, now from
    http://rt.openssl.org/Ticket/Display.html?id=2065 rather than the
    0.9.8 variant.
  - debian/patches/Bsymbolic-functions.patch: Link using
    -Bsymbolic-functions.
  - debian/patches/perlpath-quilt.patch: Don't change perl #! paths under
    .pc.
  - debian/rules:
    + Don't run 'make test' when cross-building.
    + Use host compiler when cross-building.  Patch from Neil Williams.
    + Don't build for processors no longer supported: i486, i586 (on
      i386), v8 (on sparc).
    + Fix Makefile to properly clean up libs/ dirs in clean target.
    + Replace duplicate files in the doc directory with symlinks.
* Update architectures affected by Bsymbolic-functions.patch.
* Drop debian/patches/no-sslv2.patch; Debian now adds the 'no-ssl2'
  configure option, which compiles out SSLv2 support entirely, so this is
  no longer needed.
* Drop openssl-doc in favour of the libssl-doc package introduced by
  Debian.  Add Conflicts/Replaces until the next LTS release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
crypto/camellia/cmll_cfb.c
105
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
108
#include <openssl/camellia.h>
117
 
#include "cmll_locl.h"
118
 
#include "e_os.h"
 
109
#include <openssl/modes.h>
119
110
 
120
111
 
121
112
/* The input and output encrypted as though 128bit cfb mode is being
124
115
 */
125
116
 
126
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
119
        unsigned char *ivec, int *num, const int enc)
129
120
        {
130
121
 
131
 
        unsigned int n;
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 */
 
122
        CRYPTO_cfb128_encrypt(in,out,length,key,ivec,num,enc,(block128_f)Camellia_encrypt);
201
123
        }
202
124
 
203
125
/* N.B. This expects the input to be packed, MS bit first */
204
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
128
        unsigned char *ivec, int *num, const int enc)
207
129
        {
208
 
        unsigned int n;
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
 
                }
 
130
        CRYPTO_cfb128_1_encrypt(in,out,length,key,ivec,num,enc,(block128_f)Camellia_encrypt);
221
131
        }
222
132
 
223
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
135
        unsigned char *ivec, int *num, const int enc)
226
136
        {
227
 
        unsigned int n;
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);
 
137
        CRYPTO_cfb128_8_encrypt(in,out,length,key,ivec,num,enc,(block128_f)Camellia_encrypt);
234
138
        }
235
139