← Back to branch summary

~hamo/ubuntu/precise/grub2/grub2.hi_res

« back to all changes in this revision

Viewing changes to grub-core/lib/libgcrypt-grub/cipher/rfc2268.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Robert Millan, Updated translations
  • Date: 2010-11-22 12:24:56 UTC
  • mfrom: (1.26.4 upstream) (17.3.36 sid)
  • mto: (17.3.43 sid)
  • mto: This revision was merged to the branch mainline in revision 89.
  • Revision ID: james.westby@ubuntu.com-20101122122456-y82z3sfb7k4zfdcc
Tags: 1.99~20101122-1
http://bugs.debian.org/550658
http://bugs.debian.org/550702
http://bugs.debian.org/591416
http://bugs.debian.org/593347
http://bugs.debian.org/551627
http://bugs.debian.org/589325
http://bugs.debian.org/543924
http://bugs.debian.org/603354
http://bugs.debian.org/604003
http://bugs.debian.org/604102
[ Colin Watson ]
* New Bazaar snapshot.  Too many changes to list in full, but some of the
  more user-visible ones are as follows:
  - GRUB script:
    + Function parameters, "break", "continue", "shift", "setparams",
      "return", and "!".
    + "export" command supports multiple variable names.
    + Multi-line quoted strings support.
    + Wildcard expansion.
  - sendkey support.
  - USB hotunplugging and USB serial support.
  - Rename CD-ROM to cd on BIOS.
  - Add new --boot-directory option to grub-install, grub-reboot, and
    grub-set-default; the old --root-directory option is still accepted
    but was often confusing.
  - Basic btrfs detection/UUID support (but no file reading yet).
  - bash-completion for utilities.
  - If a device is listed in device.map, always assume that it is
    BIOS-visible rather than using extra layers such as LVM or RAID.
  - Add grub-mknetdir script (closes: #550658).
  - Remove deprecated "root" command.
  - Handle RAID devices containing virtio components.
  - GRUB Legacy configuration file support (via grub-menulst2cfg).
  - Keyboard layout support (via grub-mklayout and grub-kbdcomp).
  - Check generated grub.cfg for syntax errors before saving.
  - Pause execution for at most ten seconds if any errors are displayed,
    so that the user has a chance to see them.
  - Support submenus.
  - Write embedding zone using Reed-Solomon, so that it's robust against
    being partially overwritten (closes: #550702, #591416, #593347).
  - GRUB_DISABLE_LINUX_RECOVERY and GRUB_DISABLE_NETBSD_RECOVERY merged
    into a single GRUB_DISABLE_RECOVERY variable.
  - Fix loader memory allocation failure (closes: #551627).
  - Don't call savedefault on recovery entries (closes: #589325).
  - Support triple-indirect blocks on ext2 (closes: #543924).
  - Recognise DDF1 fake RAID (closes: #603354).

[ Robert Millan ]
* Use dpkg architecture wildcards.

[ Updated translations ]
* Slovenian (Vanja Cvelbar).  Closes: #604003
* Dzongkha (dawa pemo via Tenzin Dendup).  Closes: #604102

Show diffs side-by-side

added added

removed removed

Lines of Context:
grub-core/lib/libgcrypt-grub/cipher/rfc2268.c
 
1
/* This file was automatically imported with 
 
2
   import_gcry.py. Please don't modify it */
 
3
/* rfc2268.c  - The cipher described in rfc2268; aka Ron's Cipher 2.
 
4
 * Copyright (C) 2003 Nikos Mavroyanopoulos
 
5
 * Copyright (C) 2004 Free Software Foundation, Inc.
 
6
 *
 
7
 * This file is part of Libgcrypt
 
8
 *
 
9
 * Libgcrypt is free software; you can redistribute it and/or modify
 
10
 * it under the terms of the GNU Lesser general Public License as
 
11
 * published by the Free Software Foundation; either version 2.1 of
 
12
 * the License, or (at your option) any later version.
 
13
 *
 
14
 * Libgcrypt is distributed in the hope that it will be useful,
 
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
 * GNU Lesser General Public License for more details.
 
18
 *
 
19
 * You should have received a copy of the GNU Lesser General Public
 
20
 * License along with this program; if not, write to the Free Software
 
21
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 
22
 */
 
23
 
 
24
/* This implementation was written by Nikos Mavroyanopoulos for GNUTLS
 
25
 * as a Libgcrypt module (gnutls/lib/x509/rc2.c) and later adapted for
 
26
 * direct use by Libgcrypt by Werner Koch.  This implementation is
 
27
 * only useful for pkcs#12 descryption.
 
28
 *
 
29
 * The implementation here is based on Peter Gutmann's RRC.2 paper.
 
30
 */
 
31
 
 
32
 
 
33
#include "g10lib.h"
 
34
#include "types.h"
 
35
#include "cipher.h"
 
36
 
 
37
#define RFC2268_BLOCKSIZE 8
 
38
 
 
39
typedef struct 
 
40
{
 
41
  u16 S[64];
 
42
} RFC2268_context;
 
43
 
 
44
static const unsigned char rfc2268_sbox[] = { 
 
45
  217, 120, 249, 196,  25, 221, 181, 237, 
 
46
   40, 233, 253, 121,  74, 160, 216, 157,
 
47
  198, 126,  55, 131,  43, 118,  83, 142, 
 
48
   98,  76, 100, 136,  68, 139, 251, 162,
 
49
   23, 154,  89, 245, 135, 179,  79,  19,
 
50
   97,  69, 109, 141,   9, 129, 125,  50,
 
51
  189, 143,  64, 235, 134, 183, 123,  11,
 
52
  240, 149,  33,  34,  92, 107,  78, 130,
 
53
   84, 214, 101, 147, 206,  96, 178,  28,
 
54
  115,  86, 192,  20, 167, 140, 241, 220,
 
55
   18, 117, 202,  31,  59, 190, 228, 209,
 
56
   66,  61, 212,  48, 163,  60, 182,  38,
 
57
  111, 191,  14, 218,  70, 105,   7,  87,
 
58
   39, 242,  29, 155, 188, 148,  67,   3,
 
59
  248,  17, 199, 246, 144, 239,  62, 231,
 
60
    6, 195, 213,  47, 200, 102,  30, 215,
 
61
    8, 232, 234, 222, 128,  82, 238, 247,
 
62
  132, 170, 114, 172,  53,  77, 106,  42,
 
63
  150,  26, 210, 113,  90,  21,  73, 116,
 
64
   75, 159, 208,  94,   4,  24, 164, 236,
 
65
  194, 224,  65, 110,  15,  81, 203, 204,
 
66
   36, 145, 175,  80, 161, 244, 112,  57,
 
67
  153, 124,  58, 133,  35, 184, 180, 122,
 
68
  252,   2,  54,  91,  37,  85, 151,  49,
 
69
   45,  93, 250, 152, 227, 138, 146, 174,
 
70
    5, 223,  41,  16, 103, 108, 186, 201,
 
71
  211,   0, 230, 207, 225, 158, 168,  44,
 
72
   99,  22,   1,  63,  88, 226, 137, 169,
 
73
   13,  56,  52,  27, 171,  51, 255, 176,
 
74
  187,  72,  12,  95, 185, 177, 205,  46,
 
75
  197, 243, 219,  71, 229, 165, 156, 119,
 
76
   10, 166,  32, 104, 254, 127, 193, 173
 
77
};
 
78
 
 
79
#define rotl16(x,n)   (((x) << ((u16)(n))) | ((x) >> (16 - (u16)(n))))
 
80
#define rotr16(x,n)   (((x) >> ((u16)(n))) | ((x) << (16 - (u16)(n))))
 
81
 
 
82
 
 
83
 
 
84
static void
 
85
do_encrypt (void *context, unsigned char *outbuf, const unsigned char *inbuf)
 
86
{
 
87
  RFC2268_context *ctx = context;
 
88
  register int i, j;
 
89
  u16 word0 = 0, word1 = 0, word2 = 0, word3 = 0;
 
90
 
 
91
  word0 = (word0 << 8) | inbuf[1];
 
92
  word0 = (word0 << 8) | inbuf[0];
 
93
  word1 = (word1 << 8) | inbuf[3];
 
94
  word1 = (word1 << 8) | inbuf[2];
 
95
  word2 = (word2 << 8) | inbuf[5];
 
96
  word2 = (word2 << 8) | inbuf[4];
 
97
  word3 = (word3 << 8) | inbuf[7];
 
98
  word3 = (word3 << 8) | inbuf[6];
 
99
 
 
100
  for (i = 0; i < 16; i++)
 
101
    {
 
102
      j = i * 4;
 
103
      /* For some reason I cannot combine those steps. */
 
104
      word0 += (word1 & ~word3) + (word2 & word3) + ctx->S[j];
 
105
      word0 = rotl16(word0, 1);
 
106
                
 
107
      word1 += (word2 & ~word0) + (word3 & word0) + ctx->S[j + 1];
 
108
      word1 = rotl16(word1, 2);
 
109
                
 
110
      word2 += (word3 & ~word1) + (word0 & word1) + ctx->S[j + 2];
 
111
      word2 = rotl16(word2, 3);
 
112
 
 
113
      word3 += (word0 & ~word2) + (word1 & word2) + ctx->S[j + 3];
 
114
      word3 = rotl16(word3, 5);
 
115
 
 
116
      if (i == 4 || i == 10)
 
117
        {
 
118
          word0 += ctx->S[word3 & 63];
 
119
          word1 += ctx->S[word0 & 63];
 
120
          word2 += ctx->S[word1 & 63];
 
121
          word3 += ctx->S[word2 & 63];
 
122
        }
 
123
 
 
124
    }
 
125
 
 
126
  outbuf[0] = word0 & 255;
 
127
  outbuf[1] = word0 >> 8;
 
128
  outbuf[2] = word1 & 255;
 
129
  outbuf[3] = word1 >> 8;
 
130
  outbuf[4] = word2 & 255;
 
131
  outbuf[5] = word2 >> 8;
 
132
  outbuf[6] = word3 & 255;
 
133
  outbuf[7] = word3 >> 8;
 
134
}
 
135
 
 
136
static void
 
137
do_decrypt (void *context, unsigned char *outbuf, const unsigned char *inbuf)
 
138
{
 
139
  RFC2268_context *ctx = context;
 
140
  register int i, j;
 
141
  u16 word0 = 0, word1 = 0, word2 = 0, word3 = 0;
 
142
 
 
143
  word0 = (word0 << 8) | inbuf[1];
 
144
  word0 = (word0 << 8) | inbuf[0];
 
145
  word1 = (word1 << 8) | inbuf[3];
 
146
  word1 = (word1 << 8) | inbuf[2];
 
147
  word2 = (word2 << 8) | inbuf[5];
 
148
  word2 = (word2 << 8) | inbuf[4];
 
149
  word3 = (word3 << 8) | inbuf[7];
 
150
  word3 = (word3 << 8) | inbuf[6];
 
151
 
 
152
  for (i = 15; i >= 0; i--) 
 
153
    {
 
154
      j = i * 4;
 
155
 
 
156
      word3 = rotr16(word3, 5);
 
157
      word3 -= (word0 & ~word2) + (word1 & word2) + ctx->S[j + 3];
 
158
 
 
159
      word2 = rotr16(word2, 3);
 
160
      word2 -= (word3 & ~word1) + (word0 & word1) + ctx->S[j + 2];
 
161
 
 
162
      word1 = rotr16(word1, 2);
 
163
      word1 -= (word2 & ~word0) + (word3 & word0) + ctx->S[j + 1];
 
164
 
 
165
      word0 = rotr16(word0, 1);
 
166
      word0 -= (word1 & ~word3) + (word2 & word3) + ctx->S[j];
 
167
 
 
168
      if (i == 5 || i == 11) 
 
169
        {
 
170
          word3 = word3 - ctx->S[word2 & 63];
 
171
          word2 = word2 - ctx->S[word1 & 63];
 
172
          word1 = word1 - ctx->S[word0 & 63];
 
173
          word0 = word0 - ctx->S[word3 & 63];
 
174
        }
 
175
 
 
176
    }
 
177
 
 
178
  outbuf[0] = word0 & 255;
 
179
  outbuf[1] = word0 >> 8;
 
180
  outbuf[2] = word1 & 255;
 
181
  outbuf[3] = word1 >> 8;
 
182
  outbuf[4] = word2 & 255;
 
183
  outbuf[5] = word2 >> 8;
 
184
  outbuf[6] = word3 & 255;
 
185
  outbuf[7] = word3 >> 8;
 
186
}
 
187
 
 
188
 
 
189
static gpg_err_code_t
 
190
setkey_core (void *context, const unsigned char *key, unsigned int keylen, int with_phase2)
 
191
{
 
192
  static int initialized;
 
193
  static const char *selftest_failed;
 
194
  RFC2268_context *ctx = context;
 
195
  unsigned int i;
 
196
  unsigned char *S, x;
 
197
  int len;
 
198
  int bits = keylen * 8;
 
199
 
 
200
  if (!initialized)
 
201
    {
 
202
      initialized = 1;
 
203
      selftest_failed = selftest ();
 
204
      if (selftest_failed)
 
205
        log_error ("RFC2268 selftest failed (%s).\n", selftest_failed);
 
206
    }
 
207
  if (selftest_failed)
 
208
    return GPG_ERR_SELFTEST_FAILED;
 
209
 
 
210
  if (keylen < 40 / 8)  /* We want at least 40 bits. */
 
211
    return GPG_ERR_INV_KEYLEN;
 
212
 
 
213
  S = (unsigned char *) ctx->S;
 
214
  
 
215
  for (i = 0; i < keylen; i++)
 
216
    S[i] = key[i];
 
217
 
 
218
  for (i = keylen; i < 128; i++)
 
219
    S[i] = rfc2268_sbox[(S[i - keylen] + S[i - 1]) & 255];
 
220
 
 
221
  S[0] = rfc2268_sbox[S[0]];
 
222
 
 
223
  /* Phase 2 - reduce effective key size to "bits". This was not
 
224
   * discussed in Gutmann's paper. I've copied that from the public
 
225
   * domain code posted in sci.crypt. */
 
226
  if (with_phase2)
 
227
    {
 
228
      len = (bits + 7) >> 3;
 
229
      i = 128 - len;
 
230
      x = rfc2268_sbox[S[i] & (255 >> (7 & -bits))];
 
231
      S[i] = x;
 
232
      
 
233
      while (i--) 
 
234
        {
 
235
          x = rfc2268_sbox[x ^ S[i + len]];
 
236
          S[i] = x;
 
237
        }
 
238
    }
 
239
 
 
240
  /* Make the expanded key, endian independent. */
 
241
  for (i = 0; i < 64; i++) 
 
242
    ctx->S[i] = ( (u16) S[i * 2] | (((u16) S[i * 2 + 1]) << 8));
 
243
 
 
244
  return 0;
 
245
}
 
246
 
 
247
static gpg_err_code_t
 
248
do_setkey (void *context, const unsigned char *key, unsigned int keylen)
 
249
{
 
250
  return setkey_core (context, key, keylen, 1);
 
251
}
 
252
 
 
253
 
 
254
 
 
255
 
 
256
static gcry_cipher_oid_spec_t oids_rfc2268_40[] =
 
257
  {
 
258
    /*{ "1.2.840.113549.3.2", GCRY_CIPHER_MODE_CBC },*/
 
259
    /* pbeWithSHAAnd40BitRC2_CBC */
 
260
    { "1.2.840.113549.1.12.1.6", GCRY_CIPHER_MODE_CBC },
 
261
    { NULL }
 
262
  };
 
263
 
 
264
gcry_cipher_spec_t _gcry_cipher_spec_rfc2268_40 = {
 
265
  "RFC2268_40", NULL, oids_rfc2268_40,
 
266
  RFC2268_BLOCKSIZE, 40, sizeof(RFC2268_context),
 
267
  do_setkey, do_encrypt, do_decrypt
 
268
};
 
269
 
 
270
 
 
271
 
 
272
GRUB_MOD_INIT(gcry_rfc2268)
 
273
{
 
274
  grub_cipher_register (&_gcry_cipher_spec_rfc2268_40);
 
275
}
 
276
 
 
277
GRUB_MOD_FINI(gcry_rfc2268)
 
278
{
 
279
  grub_cipher_unregister (&_gcry_cipher_spec_rfc2268_40);
 
280
}