← Back to branch summary

~ubuntu-branches/ubuntu/vivid/nettle/vivid-proposed

« back to all changes in this revision

Viewing changes to camellia-set-encrypt-key.c

  • Committer: Package Import Robot
  • Author(s): Magnus Holmgren
  • Date: 2013-05-04 19:50:28 UTC
  • mfrom: (1.4.6) (3.1.11 experimental)
  • mto: This revision was merged to the branch mainline in revision 14.
  • Revision ID: package-import@ubuntu.com-20130504195028-fp6c9fw1tsm5scwa
Tags: 2.7-1
http://bugs.debian.org/706081
* New upstream release (Closes: #706081).
* Include watch file improvements from Bart Martens <bartm@debian.org>
  via the QA system.

Show diffs side-by-side

added added

removed removed

Lines of Context:
camellia-set-encrypt-key.c
6
6
 * Copyright (C) 2006,2007
7
7
 * NTT (Nippon Telegraph and Telephone Corporation).
8
8
 *
9
 
 * Copyright (C) 2010 Niels M�ller
 
9
 * Copyright (C) 2010 Niels Möller
10
10
 *
11
11
 * This library is free software; you can redistribute it and/or
12
12
 * modify it under the terms of the GNU Lesser General Public
70
70
      ^ CAMELLIA_SP3033((__i >> 40) & 0xff)     \
71
71
      ^ CAMELLIA_SP4404((__i >> 32) & 0xff);    \
72
72
    __yl ^= __yr;                               \
73
 
    __yr = ROL32(24, __yr);                     \
 
73
    __yr = ROTL32(24, __yr);                    \
74
74
    __yr ^= __yl;                               \
75
75
    (y) = ((uint64_t) __yl << 32) | __yr;       \
76
76
  } while (0)
80
80
    uint32_t __t, __w;                         \
81
81
    __t = (x) >> 32;                           \
82
82
    __w = __t ^(x);                            \
83
 
    __w = ROL32(8, __w);                       \
 
83
    __w = ROTL32(8, __w);                       \
84
84
    (x) = ((uint64_t) __w << 32) | (__t ^ __w);        \
85
85
  } while (0)
86
86
#endif
107
107
       * generate KL dependent subkeys
108
108
       */
109
109
      subkey[0] = k0; subkey[1] = k1;
110
 
      ROL128(15, k0, k1);
 
110
      ROTL128(15, k0, k1);
111
111
      subkey[4] = k0; subkey[5] = k1;
112
 
      ROL128(30, k0, k1);
 
112
      ROTL128(30, k0, k1);
113
113
      subkey[10] = k0; subkey[11] = k1;
114
 
      ROL128(15, k0, k1);
 
114
      ROTL128(15, k0, k1);
115
115
      subkey[13] = k1;
116
 
      ROL128(17, k0, k1);
 
116
      ROTL128(17, k0, k1);
117
117
      subkey[16] = k0; subkey[17] = k1;
118
 
      ROL128(17, k0, k1);
 
118
      ROTL128(17, k0, k1);
119
119
      subkey[18] = k0; subkey[19] = k1;
120
 
      ROL128(17, k0, k1);
 
120
      ROTL128(17, k0, k1);
121
121
      subkey[22] = k0; subkey[23] = k1;
122
122
 
123
123
      /* generate KA. D1 is k0, d2 is k1. */
144
144
 
145
145
      /* generate KA dependent subkeys */
146
146
      subkey[2] = k0; subkey[3] = k1;
147
 
      ROL128(15, k0, k1);
 
147
      ROTL128(15, k0, k1);
148
148
      subkey[6] = k0; subkey[7] = k1;
149
 
      ROL128(15, k0, k1);
 
149
      ROTL128(15, k0, k1);
150
150
      subkey[8] = k0; subkey[9] = k1;
151
 
      ROL128(15, k0, k1);
 
151
      ROTL128(15, k0, k1);
152
152
      subkey[12] = k0;
153
 
      ROL128(15, k0, k1);
 
153
      ROTL128(15, k0, k1);
154
154
      subkey[14] = k0; subkey[15] = k1;
155
 
      ROL128(34, k0, k1);
 
155
      ROTL128(34, k0, k1);
156
156
      subkey[20] = k0; subkey[21] = k1;
157
 
      ROL128(17, k0, k1);
 
157
      ROTL128(17, k0, k1);
158
158
      subkey[24] = k0; subkey[25] = k1;
159
159
    }
160
160
  else
173
173
        }
174
174
      /* generate KL dependent subkeys */
175
175
      subkey[0] = k0; subkey[1] = k1;
176
 
      ROL128(45, k0, k1);
 
176
      ROTL128(45, k0, k1);
177
177
      subkey[12] = k0; subkey[13] = k1;
178
 
      ROL128(15, k0, k1);
 
178
      ROTL128(15, k0, k1);
179
179
      subkey[16] = k0; subkey[17] = k1;
180
 
      ROL128(17, k0, k1);
 
180
      ROTL128(17, k0, k1);
181
181
      subkey[22] = k0; subkey[23] = k1;
182
 
      ROL128(34, k0, k1);
 
182
      ROTL128(34, k0, k1);
183
183
      subkey[30] = k0; subkey[31] = k1;
184
184
 
185
185
      /* generate KR dependent subkeys */
186
 
      ROL128(15, k2, k3);
 
186
      ROTL128(15, k2, k3);
187
187
      subkey[4] = k2; subkey[5] = k3;
188
 
      ROL128(15, k2, k3);
 
188
      ROTL128(15, k2, k3);
189
189
      subkey[8] = k2; subkey[9] = k3;
190
 
      ROL128(30, k2, k3);
 
190
      ROTL128(30, k2, k3);
191
191
      subkey[18] = k2; subkey[19] = k3;
192
 
      ROL128(34, k2, k3);
 
192
      ROTL128(34, k2, k3);
193
193
      subkey[26] = k2; subkey[27] = k3;
194
 
      ROL128(34, k2, k3);
 
194
      ROTL128(34, k2, k3);
195
195
 
196
196
      /* generate KA */
197
197
      /* The construction of KA is done as
230
230
      k2 ^= w;
231
231
 
232
232
      /* generate KA dependent subkeys */
233
 
      ROL128(15, k0, k1);
 
233
      ROTL128(15, k0, k1);
234
234
      subkey[6] = k0; subkey[7] = k1;
235
 
      ROL128(30, k0, k1);
 
235
      ROTL128(30, k0, k1);
236
236
      subkey[14] = k0; subkey[15] = k1;
237
 
      ROL128(32, k0, k1);
 
237
      ROTL128(32, k0, k1);
238
238
      subkey[24] = k0; subkey[25] = k1;
239
 
      ROL128(17, k0, k1);
 
239
      ROTL128(17, k0, k1);
240
240
      subkey[28] = k0; subkey[29] = k1;
241
241
 
242
242
      /* generate KB dependent subkeys */
243
243
      subkey[2] = k2; subkey[3] = k3;
244
 
      ROL128(30, k2, k3);
 
244
      ROTL128(30, k2, k3);
245
245
      subkey[10] = k2; subkey[11] = k3;
246
 
      ROL128(30, k2, k3);
 
246
      ROTL128(30, k2, k3);
247
247
      subkey[20] = k2; subkey[21] = k3;
248
 
      ROL128(51, k2, k3);
 
248
      ROTL128(51, k2, k3);
249
249
      subkey[32] = k2; subkey[33] = k3;
250
250
    }
251
251
 
264
264
         and xor the result into the 32 high bits, but it still generates
265
265
         worse code than for explicit 32-bit operations. */
266
266
      kw2 ^= (kw2 & ~subkey[i+1]) << 32;
267
 
      dw = (kw2 & subkey[i+1]) >> 32; kw2 ^= ROL32(1, dw); 
 
267
      dw = (kw2 & subkey[i+1]) >> 32; kw2 ^= ROTL32(1, dw); 
268
268
 
269
269
      subkey[i+3] ^= kw2;
270
270
      subkey[i+5] ^= kw2;
281
281
      subkey[i+4] ^= kw4;
282
282
      subkey[i+2] ^= kw4;
283
283
      kw4 ^= (kw4 & ~subkey[i]) << 32;
284
 
      dw = (kw4 & subkey[i]) >> 32; kw4 ^= ROL32(1, dw);      
 
284
      dw = (kw4 & subkey[i]) >> 32; kw4 ^= ROTL32(1, dw);      
285
285
    }
286
286
 
287
287
  subkey[6] ^= kw4;
302
302
    {
303
303
      tl = (subkey[i+2] >> 32) ^ (subkey[i+2] & ~subkey[i]);
304
304
      dw = tl & (subkey[i] >> 32);
305
 
      tr = subkey[i+2] ^ ROL32(1, dw);
 
305
      tr = subkey[i+2] ^ ROTL32(1, dw);
306
306
      ctx->keys[i-2] = subkey[i-2] ^ ( ((uint64_t) tl << 32) | tr);
307
307
 
308
308
      ctx->keys[i-1] = subkey[i];
310
310
 
311
311
      tl = (subkey[i-1] >> 32) ^ (subkey[i-1] & ~subkey[i+1]);
312
312
      dw = tl & (subkey[i+1] >> 32);
313
 
      tr = subkey[i-1] ^ ROL32(1, dw);
 
313
      tr = subkey[i-1] ^ ROTL32(1, dw);
314
314
      ctx->keys[i+1] = subkey[i+3] ^ ( ((uint64_t) tl << 32) | tr);
315
315
 
316
316
      ctx->keys[i+2] = subkey[i+2] ^ subkey[i+4];