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

« back to all changes in this revision

Viewing changes to lib/libgcrypt/cipher/blowfish.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Evan Broder, Mario Limonciello
  • Date: 2010-11-24 13:59:55 UTC
  • mfrom: (1.17.6 upstream) (17.6.15 experimental)
  • Revision ID: james.westby@ubuntu.com-20101124135955-r6ii5sepayr7jt53
Tags: 1.99~20101124-1ubuntu1
[ Colin Watson ]
* Resynchronise with Debian experimental.  Remaining changes:
  - Adjust for default Ubuntu boot options ("quiet splash").
  - Default to hiding the menu; holding down Shift at boot will show it.
  - Set a monochromatic theme for Ubuntu.
  - Apply Ubuntu GRUB Legacy changes to legacy update-grub script: title,
    recovery mode, quiet option, tweak how memtest86+ is displayed, and
    use UUIDs where appropriate.
  - Fix backslash-escaping in merge_debconf_into_conf.
  - Remove "GNU/Linux" from default distributor string.
  - Add crashkernel= options if kdump and makedumpfile are available.
  - If other operating systems are installed, then automatically unhide
    the menu.  Otherwise, if GRUB_HIDDEN_TIMEOUT is 0, then use keystatus
    if available to check whether Shift is pressed.  If it is, show the
    menu, otherwise boot immediately.  If keystatus is not available, then
    fall back to a short delay interruptible with Escape.
  - Allow Shift to interrupt 'sleep --interruptible'.
  - Don't display introductory message about line editing unless we're
    actually offering a shell prompt.  Don't clear the screen just before
    booting if we never drew the menu in the first place.
  - Remove some verbose messages printed before reading the configuration
    file.
  - Suppress progress messages as the kernel and initrd load for
    non-recovery kernel menu entries.
  - Change prepare_grub_to_access_device to handle filesystems
    loop-mounted on file images.
  - Ignore devices loop-mounted from files in 10_linux.
  - Show the boot menu if the previous boot failed, that is if it failed
    to get to the end of one of the normal runlevels.
  - Don't generate /boot/grub/device.map during grub-install or
    grub-mkconfig by default.
  - Adjust upgrade version checks for Ubuntu.
  - Don't display "GRUB loading" unless Shift is held down.
  - Adjust versions of grub-doc and grub-legacy-doc conflicts to tolerate
    our backport of the grub-doc split.
  - Fix LVM/RAID probing in the absence of /boot/grub/device.map.
  - Look for .mo files in /usr/share/locale-langpack as well, in
    preference.
  - Make sure GRUB_TIMEOUT isn't quoted unnecessarily.
  - Probe all devices in 'grub-probe --target=drive' if
    /boot/grub/device.map is missing.
  - Build-depend on qemu-kvm rather than qemu-system for grub-pc tests.
  - Use qemu rather than qemu-system-i386.
  - Program vesafb on BIOS systems rather than efifb.
  - Add a grub-rescue-efi-amd64 package containing a rescue CD-ROM image
    for EFI-AMD64.
  - On Wubi, don't ask for an install device, but just update wubildr
    using the diverted grub-install.
  - When embedding the core image in a post-MBR gap, check for and avoid
    sectors matching any of a list of known signatures.
  - Disable video_bochs and video_cirrus on PC BIOS systems, as probing
    PCI space seems to break on some systems.
* Downgrade "ACPI shutdown failed" error to a debug message, since it can
  cause spurious test failures.

[ Evan Broder ]
* Enable lua from grub-extras.
* Incorporate the bitop library into lua.
* Add enum_pci function to grub module in lua.
* Switch back to gfxpayload=keep by default, unless the video hardware
  is known to not support it.

[ Mario Limonciello ]
* Built part_msdos and vfat into bootx64.efi (LP: #677758)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* blowfish.c  -  Blowfish encryption
2
 
 *      Copyright (C) 1998, 2001, 2002, 2003 Free Software Foundation, Inc.
3
 
 *
4
 
 * This file is part of Libgcrypt.
5
 
 *
6
 
 * Libgcrypt is free software; you can redistribute it and/or modify
7
 
 * it under the terms of the GNU Lesser general Public License as
8
 
 * published by the Free Software Foundation; either version 2.1 of
9
 
 * the License, or (at your option) any later version.
10
 
 *
11
 
 * Libgcrypt is distributed in the hope that it will be useful,
12
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 * GNU Lesser General Public License for more details.
15
 
 *
16
 
 * You should have received a copy of the GNU Lesser General Public
17
 
 * License along with this program; if not, write to the Free Software
18
 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19
 
 *
20
 
 * For a description of the algorithm, see:
21
 
 *   Bruce Schneier: Applied Cryptography. John Wiley & Sons, 1996.
22
 
 *   ISBN 0-471-11709-9. Pages 336 ff.
23
 
 */
24
 
 
25
 
/* Test values:
26
 
 * key    "abcdefghijklmnopqrstuvwxyz";
27
 
 * plain  "BLOWFISH"
28
 
 * cipher 32 4E D0 FE F4 13 A2 03
29
 
 *
30
 
 */
31
 
 
32
 
#include <config.h>
33
 
#include <stdio.h>
34
 
#include <stdlib.h>
35
 
#include <string.h>
36
 
#include "types.h"
37
 
#include "g10lib.h"
38
 
#include "cipher.h"
39
 
 
40
 
#define BLOWFISH_BLOCKSIZE 8
41
 
#define BLOWFISH_ROUNDS 16
42
 
 
43
 
typedef struct {
44
 
    u32 s0[256];
45
 
    u32 s1[256];
46
 
    u32 s2[256];
47
 
    u32 s3[256];
48
 
    u32 p[BLOWFISH_ROUNDS+2];
49
 
} BLOWFISH_context;
50
 
 
51
 
static gcry_err_code_t bf_setkey (void *c, const byte *key, unsigned keylen);
52
 
static void encrypt_block (void *bc, byte *outbuf, const byte *inbuf);
53
 
static void decrypt_block (void *bc, byte *outbuf, const byte *inbuf);
54
 
 
55
 
 
56
 
/* precomputed S boxes */
57
 
static const u32 ks0[256] = {
58
 
    0xD1310BA6,0x98DFB5AC,0x2FFD72DB,0xD01ADFB7,0xB8E1AFED,0x6A267E96,
59
 
    0xBA7C9045,0xF12C7F99,0x24A19947,0xB3916CF7,0x0801F2E2,0x858EFC16,
60
 
    0x636920D8,0x71574E69,0xA458FEA3,0xF4933D7E,0x0D95748F,0x728EB658,
61
 
    0x718BCD58,0x82154AEE,0x7B54A41D,0xC25A59B5,0x9C30D539,0x2AF26013,
62
 
    0xC5D1B023,0x286085F0,0xCA417918,0xB8DB38EF,0x8E79DCB0,0x603A180E,
63
 
    0x6C9E0E8B,0xB01E8A3E,0xD71577C1,0xBD314B27,0x78AF2FDA,0x55605C60,
64
 
    0xE65525F3,0xAA55AB94,0x57489862,0x63E81440,0x55CA396A,0x2AAB10B6,
65
 
    0xB4CC5C34,0x1141E8CE,0xA15486AF,0x7C72E993,0xB3EE1411,0x636FBC2A,
66
 
    0x2BA9C55D,0x741831F6,0xCE5C3E16,0x9B87931E,0xAFD6BA33,0x6C24CF5C,
67
 
    0x7A325381,0x28958677,0x3B8F4898,0x6B4BB9AF,0xC4BFE81B,0x66282193,
68
 
    0x61D809CC,0xFB21A991,0x487CAC60,0x5DEC8032,0xEF845D5D,0xE98575B1,
69
 
    0xDC262302,0xEB651B88,0x23893E81,0xD396ACC5,0x0F6D6FF3,0x83F44239,
70
 
    0x2E0B4482,0xA4842004,0x69C8F04A,0x9E1F9B5E,0x21C66842,0xF6E96C9A,
71
 
    0x670C9C61,0xABD388F0,0x6A51A0D2,0xD8542F68,0x960FA728,0xAB5133A3,
72
 
    0x6EEF0B6C,0x137A3BE4,0xBA3BF050,0x7EFB2A98,0xA1F1651D,0x39AF0176,
73
 
    0x66CA593E,0x82430E88,0x8CEE8619,0x456F9FB4,0x7D84A5C3,0x3B8B5EBE,
74
 
    0xE06F75D8,0x85C12073,0x401A449F,0x56C16AA6,0x4ED3AA62,0x363F7706,
75
 
    0x1BFEDF72,0x429B023D,0x37D0D724,0xD00A1248,0xDB0FEAD3,0x49F1C09B,
76
 
    0x075372C9,0x80991B7B,0x25D479D8,0xF6E8DEF7,0xE3FE501A,0xB6794C3B,
77
 
    0x976CE0BD,0x04C006BA,0xC1A94FB6,0x409F60C4,0x5E5C9EC2,0x196A2463,
78
 
    0x68FB6FAF,0x3E6C53B5,0x1339B2EB,0x3B52EC6F,0x6DFC511F,0x9B30952C,
79
 
    0xCC814544,0xAF5EBD09,0xBEE3D004,0xDE334AFD,0x660F2807,0x192E4BB3,
80
 
    0xC0CBA857,0x45C8740F,0xD20B5F39,0xB9D3FBDB,0x5579C0BD,0x1A60320A,
81
 
    0xD6A100C6,0x402C7279,0x679F25FE,0xFB1FA3CC,0x8EA5E9F8,0xDB3222F8,
82
 
    0x3C7516DF,0xFD616B15,0x2F501EC8,0xAD0552AB,0x323DB5FA,0xFD238760,
83
 
    0x53317B48,0x3E00DF82,0x9E5C57BB,0xCA6F8CA0,0x1A87562E,0xDF1769DB,
84
 
    0xD542A8F6,0x287EFFC3,0xAC6732C6,0x8C4F5573,0x695B27B0,0xBBCA58C8,
85
 
    0xE1FFA35D,0xB8F011A0,0x10FA3D98,0xFD2183B8,0x4AFCB56C,0x2DD1D35B,
86
 
    0x9A53E479,0xB6F84565,0xD28E49BC,0x4BFB9790,0xE1DDF2DA,0xA4CB7E33,
87
 
    0x62FB1341,0xCEE4C6E8,0xEF20CADA,0x36774C01,0xD07E9EFE,0x2BF11FB4,
88
 
    0x95DBDA4D,0xAE909198,0xEAAD8E71,0x6B93D5A0,0xD08ED1D0,0xAFC725E0,
89
 
    0x8E3C5B2F,0x8E7594B7,0x8FF6E2FB,0xF2122B64,0x8888B812,0x900DF01C,
90
 
    0x4FAD5EA0,0x688FC31C,0xD1CFF191,0xB3A8C1AD,0x2F2F2218,0xBE0E1777,
91
 
    0xEA752DFE,0x8B021FA1,0xE5A0CC0F,0xB56F74E8,0x18ACF3D6,0xCE89E299,
92
 
    0xB4A84FE0,0xFD13E0B7,0x7CC43B81,0xD2ADA8D9,0x165FA266,0x80957705,
93
 
    0x93CC7314,0x211A1477,0xE6AD2065,0x77B5FA86,0xC75442F5,0xFB9D35CF,
94
 
    0xEBCDAF0C,0x7B3E89A0,0xD6411BD3,0xAE1E7E49,0x00250E2D,0x2071B35E,
95
 
    0x226800BB,0x57B8E0AF,0x2464369B,0xF009B91E,0x5563911D,0x59DFA6AA,
96
 
    0x78C14389,0xD95A537F,0x207D5BA2,0x02E5B9C5,0x83260376,0x6295CFA9,
97
 
    0x11C81968,0x4E734A41,0xB3472DCA,0x7B14A94A,0x1B510052,0x9A532915,
98
 
    0xD60F573F,0xBC9BC6E4,0x2B60A476,0x81E67400,0x08BA6FB5,0x571BE91F,
99
 
    0xF296EC6B,0x2A0DD915,0xB6636521,0xE7B9F9B6,0xFF34052E,0xC5855664,
100
 
    0x53B02D5D,0xA99F8FA1,0x08BA4799,0x6E85076A };
101
 
 
102
 
static const u32 ks1[256] = {
103
 
    0x4B7A70E9,0xB5B32944,0xDB75092E,0xC4192623,0xAD6EA6B0,0x49A7DF7D,
104
 
    0x9CEE60B8,0x8FEDB266,0xECAA8C71,0x699A17FF,0x5664526C,0xC2B19EE1,
105
 
    0x193602A5,0x75094C29,0xA0591340,0xE4183A3E,0x3F54989A,0x5B429D65,
106
 
    0x6B8FE4D6,0x99F73FD6,0xA1D29C07,0xEFE830F5,0x4D2D38E6,0xF0255DC1,
107
 
    0x4CDD2086,0x8470EB26,0x6382E9C6,0x021ECC5E,0x09686B3F,0x3EBAEFC9,
108
 
    0x3C971814,0x6B6A70A1,0x687F3584,0x52A0E286,0xB79C5305,0xAA500737,
109
 
    0x3E07841C,0x7FDEAE5C,0x8E7D44EC,0x5716F2B8,0xB03ADA37,0xF0500C0D,
110
 
    0xF01C1F04,0x0200B3FF,0xAE0CF51A,0x3CB574B2,0x25837A58,0xDC0921BD,
111
 
    0xD19113F9,0x7CA92FF6,0x94324773,0x22F54701,0x3AE5E581,0x37C2DADC,
112
 
    0xC8B57634,0x9AF3DDA7,0xA9446146,0x0FD0030E,0xECC8C73E,0xA4751E41,
113
 
    0xE238CD99,0x3BEA0E2F,0x3280BBA1,0x183EB331,0x4E548B38,0x4F6DB908,
114
 
    0x6F420D03,0xF60A04BF,0x2CB81290,0x24977C79,0x5679B072,0xBCAF89AF,
115
 
    0xDE9A771F,0xD9930810,0xB38BAE12,0xDCCF3F2E,0x5512721F,0x2E6B7124,
116
 
    0x501ADDE6,0x9F84CD87,0x7A584718,0x7408DA17,0xBC9F9ABC,0xE94B7D8C,
117
 
    0xEC7AEC3A,0xDB851DFA,0x63094366,0xC464C3D2,0xEF1C1847,0x3215D908,
118
 
    0xDD433B37,0x24C2BA16,0x12A14D43,0x2A65C451,0x50940002,0x133AE4DD,
119
 
    0x71DFF89E,0x10314E55,0x81AC77D6,0x5F11199B,0x043556F1,0xD7A3C76B,
120
 
    0x3C11183B,0x5924A509,0xF28FE6ED,0x97F1FBFA,0x9EBABF2C,0x1E153C6E,
121
 
    0x86E34570,0xEAE96FB1,0x860E5E0A,0x5A3E2AB3,0x771FE71C,0x4E3D06FA,
122
 
    0x2965DCB9,0x99E71D0F,0x803E89D6,0x5266C825,0x2E4CC978,0x9C10B36A,
123
 
    0xC6150EBA,0x94E2EA78,0xA5FC3C53,0x1E0A2DF4,0xF2F74EA7,0x361D2B3D,
124
 
    0x1939260F,0x19C27960,0x5223A708,0xF71312B6,0xEBADFE6E,0xEAC31F66,
125
 
    0xE3BC4595,0xA67BC883,0xB17F37D1,0x018CFF28,0xC332DDEF,0xBE6C5AA5,
126
 
    0x65582185,0x68AB9802,0xEECEA50F,0xDB2F953B,0x2AEF7DAD,0x5B6E2F84,
127
 
    0x1521B628,0x29076170,0xECDD4775,0x619F1510,0x13CCA830,0xEB61BD96,
128
 
    0x0334FE1E,0xAA0363CF,0xB5735C90,0x4C70A239,0xD59E9E0B,0xCBAADE14,
129
 
    0xEECC86BC,0x60622CA7,0x9CAB5CAB,0xB2F3846E,0x648B1EAF,0x19BDF0CA,
130
 
    0xA02369B9,0x655ABB50,0x40685A32,0x3C2AB4B3,0x319EE9D5,0xC021B8F7,
131
 
    0x9B540B19,0x875FA099,0x95F7997E,0x623D7DA8,0xF837889A,0x97E32D77,
132
 
    0x11ED935F,0x16681281,0x0E358829,0xC7E61FD6,0x96DEDFA1,0x7858BA99,
133
 
    0x57F584A5,0x1B227263,0x9B83C3FF,0x1AC24696,0xCDB30AEB,0x532E3054,
134
 
    0x8FD948E4,0x6DBC3128,0x58EBF2EF,0x34C6FFEA,0xFE28ED61,0xEE7C3C73,
135
 
    0x5D4A14D9,0xE864B7E3,0x42105D14,0x203E13E0,0x45EEE2B6,0xA3AAABEA,
136
 
    0xDB6C4F15,0xFACB4FD0,0xC742F442,0xEF6ABBB5,0x654F3B1D,0x41CD2105,
137
 
    0xD81E799E,0x86854DC7,0xE44B476A,0x3D816250,0xCF62A1F2,0x5B8D2646,
138
 
    0xFC8883A0,0xC1C7B6A3,0x7F1524C3,0x69CB7492,0x47848A0B,0x5692B285,
139
 
    0x095BBF00,0xAD19489D,0x1462B174,0x23820E00,0x58428D2A,0x0C55F5EA,
140
 
    0x1DADF43E,0x233F7061,0x3372F092,0x8D937E41,0xD65FECF1,0x6C223BDB,
141
 
    0x7CDE3759,0xCBEE7460,0x4085F2A7,0xCE77326E,0xA6078084,0x19F8509E,
142
 
    0xE8EFD855,0x61D99735,0xA969A7AA,0xC50C06C2,0x5A04ABFC,0x800BCADC,
143
 
    0x9E447A2E,0xC3453484,0xFDD56705,0x0E1E9EC9,0xDB73DBD3,0x105588CD,
144
 
    0x675FDA79,0xE3674340,0xC5C43465,0x713E38D8,0x3D28F89E,0xF16DFF20,
145
 
    0x153E21E7,0x8FB03D4A,0xE6E39F2B,0xDB83ADF7 };
146
 
 
147
 
static const u32 ks2[256] = {
148
 
    0xE93D5A68,0x948140F7,0xF64C261C,0x94692934,0x411520F7,0x7602D4F7,
149
 
    0xBCF46B2E,0xD4A20068,0xD4082471,0x3320F46A,0x43B7D4B7,0x500061AF,
150
 
    0x1E39F62E,0x97244546,0x14214F74,0xBF8B8840,0x4D95FC1D,0x96B591AF,
151
 
    0x70F4DDD3,0x66A02F45,0xBFBC09EC,0x03BD9785,0x7FAC6DD0,0x31CB8504,
152
 
    0x96EB27B3,0x55FD3941,0xDA2547E6,0xABCA0A9A,0x28507825,0x530429F4,
153
 
    0x0A2C86DA,0xE9B66DFB,0x68DC1462,0xD7486900,0x680EC0A4,0x27A18DEE,
154
 
    0x4F3FFEA2,0xE887AD8C,0xB58CE006,0x7AF4D6B6,0xAACE1E7C,0xD3375FEC,
155
 
    0xCE78A399,0x406B2A42,0x20FE9E35,0xD9F385B9,0xEE39D7AB,0x3B124E8B,
156
 
    0x1DC9FAF7,0x4B6D1856,0x26A36631,0xEAE397B2,0x3A6EFA74,0xDD5B4332,
157
 
    0x6841E7F7,0xCA7820FB,0xFB0AF54E,0xD8FEB397,0x454056AC,0xBA489527,
158
 
    0x55533A3A,0x20838D87,0xFE6BA9B7,0xD096954B,0x55A867BC,0xA1159A58,
159
 
    0xCCA92963,0x99E1DB33,0xA62A4A56,0x3F3125F9,0x5EF47E1C,0x9029317C,
160
 
    0xFDF8E802,0x04272F70,0x80BB155C,0x05282CE3,0x95C11548,0xE4C66D22,
161
 
    0x48C1133F,0xC70F86DC,0x07F9C9EE,0x41041F0F,0x404779A4,0x5D886E17,
162
 
    0x325F51EB,0xD59BC0D1,0xF2BCC18F,0x41113564,0x257B7834,0x602A9C60,
163
 
    0xDFF8E8A3,0x1F636C1B,0x0E12B4C2,0x02E1329E,0xAF664FD1,0xCAD18115,
164
 
    0x6B2395E0,0x333E92E1,0x3B240B62,0xEEBEB922,0x85B2A20E,0xE6BA0D99,
165
 
    0xDE720C8C,0x2DA2F728,0xD0127845,0x95B794FD,0x647D0862,0xE7CCF5F0,
166
 
    0x5449A36F,0x877D48FA,0xC39DFD27,0xF33E8D1E,0x0A476341,0x992EFF74,
167
 
    0x3A6F6EAB,0xF4F8FD37,0xA812DC60,0xA1EBDDF8,0x991BE14C,0xDB6E6B0D,
168
 
    0xC67B5510,0x6D672C37,0x2765D43B,0xDCD0E804,0xF1290DC7,0xCC00FFA3,
169
 
    0xB5390F92,0x690FED0B,0x667B9FFB,0xCEDB7D9C,0xA091CF0B,0xD9155EA3,
170
 
    0xBB132F88,0x515BAD24,0x7B9479BF,0x763BD6EB,0x37392EB3,0xCC115979,
171
 
    0x8026E297,0xF42E312D,0x6842ADA7,0xC66A2B3B,0x12754CCC,0x782EF11C,
172
 
    0x6A124237,0xB79251E7,0x06A1BBE6,0x4BFB6350,0x1A6B1018,0x11CAEDFA,
173
 
    0x3D25BDD8,0xE2E1C3C9,0x44421659,0x0A121386,0xD90CEC6E,0xD5ABEA2A,
174
 
    0x64AF674E,0xDA86A85F,0xBEBFE988,0x64E4C3FE,0x9DBC8057,0xF0F7C086,
175
 
    0x60787BF8,0x6003604D,0xD1FD8346,0xF6381FB0,0x7745AE04,0xD736FCCC,
176
 
    0x83426B33,0xF01EAB71,0xB0804187,0x3C005E5F,0x77A057BE,0xBDE8AE24,
177
 
    0x55464299,0xBF582E61,0x4E58F48F,0xF2DDFDA2,0xF474EF38,0x8789BDC2,
178
 
    0x5366F9C3,0xC8B38E74,0xB475F255,0x46FCD9B9,0x7AEB2661,0x8B1DDF84,
179
 
    0x846A0E79,0x915F95E2,0x466E598E,0x20B45770,0x8CD55591,0xC902DE4C,
180
 
    0xB90BACE1,0xBB8205D0,0x11A86248,0x7574A99E,0xB77F19B6,0xE0A9DC09,
181
 
    0x662D09A1,0xC4324633,0xE85A1F02,0x09F0BE8C,0x4A99A025,0x1D6EFE10,
182
 
    0x1AB93D1D,0x0BA5A4DF,0xA186F20F,0x2868F169,0xDCB7DA83,0x573906FE,
183
 
    0xA1E2CE9B,0x4FCD7F52,0x50115E01,0xA70683FA,0xA002B5C4,0x0DE6D027,
184
 
    0x9AF88C27,0x773F8641,0xC3604C06,0x61A806B5,0xF0177A28,0xC0F586E0,
185
 
    0x006058AA,0x30DC7D62,0x11E69ED7,0x2338EA63,0x53C2DD94,0xC2C21634,
186
 
    0xBBCBEE56,0x90BCB6DE,0xEBFC7DA1,0xCE591D76,0x6F05E409,0x4B7C0188,
187
 
    0x39720A3D,0x7C927C24,0x86E3725F,0x724D9DB9,0x1AC15BB4,0xD39EB8FC,
188
 
    0xED545578,0x08FCA5B5,0xD83D7CD3,0x4DAD0FC4,0x1E50EF5E,0xB161E6F8,
189
 
    0xA28514D9,0x6C51133C,0x6FD5C7E7,0x56E14EC4,0x362ABFCE,0xDDC6C837,
190
 
    0xD79A3234,0x92638212,0x670EFA8E,0x406000E0 };
191
 
 
192
 
static const u32 ks3[256] = {
193
 
    0x3A39CE37,0xD3FAF5CF,0xABC27737,0x5AC52D1B,0x5CB0679E,0x4FA33742,
194
 
    0xD3822740,0x99BC9BBE,0xD5118E9D,0xBF0F7315,0xD62D1C7E,0xC700C47B,
195
 
    0xB78C1B6B,0x21A19045,0xB26EB1BE,0x6A366EB4,0x5748AB2F,0xBC946E79,
196
 
    0xC6A376D2,0x6549C2C8,0x530FF8EE,0x468DDE7D,0xD5730A1D,0x4CD04DC6,
197
 
    0x2939BBDB,0xA9BA4650,0xAC9526E8,0xBE5EE304,0xA1FAD5F0,0x6A2D519A,
198
 
    0x63EF8CE2,0x9A86EE22,0xC089C2B8,0x43242EF6,0xA51E03AA,0x9CF2D0A4,
199
 
    0x83C061BA,0x9BE96A4D,0x8FE51550,0xBA645BD6,0x2826A2F9,0xA73A3AE1,
200
 
    0x4BA99586,0xEF5562E9,0xC72FEFD3,0xF752F7DA,0x3F046F69,0x77FA0A59,
201
 
    0x80E4A915,0x87B08601,0x9B09E6AD,0x3B3EE593,0xE990FD5A,0x9E34D797,
202
 
    0x2CF0B7D9,0x022B8B51,0x96D5AC3A,0x017DA67D,0xD1CF3ED6,0x7C7D2D28,
203
 
    0x1F9F25CF,0xADF2B89B,0x5AD6B472,0x5A88F54C,0xE029AC71,0xE019A5E6,
204
 
    0x47B0ACFD,0xED93FA9B,0xE8D3C48D,0x283B57CC,0xF8D56629,0x79132E28,
205
 
    0x785F0191,0xED756055,0xF7960E44,0xE3D35E8C,0x15056DD4,0x88F46DBA,
206
 
    0x03A16125,0x0564F0BD,0xC3EB9E15,0x3C9057A2,0x97271AEC,0xA93A072A,
207
 
    0x1B3F6D9B,0x1E6321F5,0xF59C66FB,0x26DCF319,0x7533D928,0xB155FDF5,
208
 
    0x03563482,0x8ABA3CBB,0x28517711,0xC20AD9F8,0xABCC5167,0xCCAD925F,
209
 
    0x4DE81751,0x3830DC8E,0x379D5862,0x9320F991,0xEA7A90C2,0xFB3E7BCE,
210
 
    0x5121CE64,0x774FBE32,0xA8B6E37E,0xC3293D46,0x48DE5369,0x6413E680,
211
 
    0xA2AE0810,0xDD6DB224,0x69852DFD,0x09072166,0xB39A460A,0x6445C0DD,
212
 
    0x586CDECF,0x1C20C8AE,0x5BBEF7DD,0x1B588D40,0xCCD2017F,0x6BB4E3BB,
213
 
    0xDDA26A7E,0x3A59FF45,0x3E350A44,0xBCB4CDD5,0x72EACEA8,0xFA6484BB,
214
 
    0x8D6612AE,0xBF3C6F47,0xD29BE463,0x542F5D9E,0xAEC2771B,0xF64E6370,
215
 
    0x740E0D8D,0xE75B1357,0xF8721671,0xAF537D5D,0x4040CB08,0x4EB4E2CC,
216
 
    0x34D2466A,0x0115AF84,0xE1B00428,0x95983A1D,0x06B89FB4,0xCE6EA048,
217
 
    0x6F3F3B82,0x3520AB82,0x011A1D4B,0x277227F8,0x611560B1,0xE7933FDC,
218
 
    0xBB3A792B,0x344525BD,0xA08839E1,0x51CE794B,0x2F32C9B7,0xA01FBAC9,
219
 
    0xE01CC87E,0xBCC7D1F6,0xCF0111C3,0xA1E8AAC7,0x1A908749,0xD44FBD9A,
220
 
    0xD0DADECB,0xD50ADA38,0x0339C32A,0xC6913667,0x8DF9317C,0xE0B12B4F,
221
 
    0xF79E59B7,0x43F5BB3A,0xF2D519FF,0x27D9459C,0xBF97222C,0x15E6FC2A,
222
 
    0x0F91FC71,0x9B941525,0xFAE59361,0xCEB69CEB,0xC2A86459,0x12BAA8D1,
223
 
    0xB6C1075E,0xE3056A0C,0x10D25065,0xCB03A442,0xE0EC6E0E,0x1698DB3B,
224
 
    0x4C98A0BE,0x3278E964,0x9F1F9532,0xE0D392DF,0xD3A0342B,0x8971F21E,
225
 
    0x1B0A7441,0x4BA3348C,0xC5BE7120,0xC37632D8,0xDF359F8D,0x9B992F2E,
226
 
    0xE60B6F47,0x0FE3F11D,0xE54CDA54,0x1EDAD891,0xCE6279CF,0xCD3E7E6F,
227
 
    0x1618B166,0xFD2C1D05,0x848FD2C5,0xF6FB2299,0xF523F357,0xA6327623,
228
 
    0x93A83531,0x56CCCD02,0xACF08162,0x5A75EBB5,0x6E163697,0x88D273CC,
229
 
    0xDE966292,0x81B949D0,0x4C50901B,0x71C65614,0xE6C6C7BD,0x327A140A,
230
 
    0x45E1D006,0xC3F27B9A,0xC9AA53FD,0x62A80F00,0xBB25BFE2,0x35BDD2F6,
231
 
    0x71126905,0xB2040222,0xB6CBCF7C,0xCD769C2B,0x53113EC0,0x1640E3D3,
232
 
    0x38ABBD60,0x2547ADF0,0xBA38209C,0xF746CE76,0x77AFA1C5,0x20756060,
233
 
    0x85CBFE4E,0x8AE88DD8,0x7AAAF9B0,0x4CF9AA7E,0x1948C25C,0x02FB8A8C,
234
 
    0x01C36AE4,0xD6EBE1F9,0x90D4F869,0xA65CDEA0,0x3F09252D,0xC208E69F,
235
 
    0xB74E6132,0xCE77E25B,0x578FDFE3,0x3AC372E6 };
236
 
 
237
 
static const u32 ps[BLOWFISH_ROUNDS+2] = {
238
 
    0x243F6A88,0x85A308D3,0x13198A2E,0x03707344,0xA4093822,0x299F31D0,
239
 
    0x082EFA98,0xEC4E6C89,0x452821E6,0x38D01377,0xBE5466CF,0x34E90C6C,
240
 
    0xC0AC29B7,0xC97C50DD,0x3F84D5B5,0xB5470917,0x9216D5D9,0x8979FB1B };
241
 
 
242
 
 
243
 
 
244
 
#if BLOWFISH_ROUNDS != 16
245
 
static inline u32
246
 
function_F( BLOWFISH_context *bc, u32 x )
247
 
{
248
 
    u16 a, b, c, d;
249
 
 
250
 
#ifdef WORDS_BIGENDIAN
251
 
    a = ((byte*)&x)[0];
252
 
    b = ((byte*)&x)[1];
253
 
    c = ((byte*)&x)[2];
254
 
    d = ((byte*)&x)[3];
255
 
#else
256
 
    a = ((byte*)&x)[3];
257
 
    b = ((byte*)&x)[2];
258
 
    c = ((byte*)&x)[1];
259
 
    d = ((byte*)&x)[0];
260
 
#endif
261
 
 
262
 
    return ((bc->s0[a] + bc->s1[b]) ^ bc->s2[c] ) + bc->s3[d];
263
 
}
264
 
#endif
265
 
 
266
 
#ifdef WORDS_BIGENDIAN
267
 
#define F(x) ((( s0[((byte*)&x)[0]] + s1[((byte*)&x)[1]])        \
268
 
                   ^ s2[((byte*)&x)[2]]) + s3[((byte*)&x)[3]] )
269
 
#else
270
 
#define F(x) ((( s0[((byte*)&x)[3]] + s1[((byte*)&x)[2]])        \
271
 
                   ^ s2[((byte*)&x)[1]]) + s3[((byte*)&x)[0]] )
272
 
#endif
273
 
#define R(l,r,i)  do { l ^= p[i]; r ^= F(l); } while(0)
274
 
 
275
 
 
276
 
static void
277
 
do_encrypt ( BLOWFISH_context *bc, u32 *ret_xl, u32 *ret_xr )
278
 
{
279
 
#if BLOWFISH_ROUNDS == 16
280
 
  u32 xl, xr, *s0, *s1, *s2, *s3, *p;
281
 
 
282
 
  xl = *ret_xl;
283
 
  xr = *ret_xr;
284
 
  p = bc->p;
285
 
  s0 = bc->s0;
286
 
  s1 = bc->s1;
287
 
  s2 = bc->s2;
288
 
  s3 = bc->s3;
289
 
 
290
 
  R( xl, xr,    0);
291
 
  R( xr, xl,    1);
292
 
  R( xl, xr,    2);
293
 
  R( xr, xl,    3);
294
 
  R( xl, xr,    4);
295
 
  R( xr, xl,    5);
296
 
  R( xl, xr,    6);
297
 
  R( xr, xl,    7);
298
 
  R( xl, xr,    8);
299
 
  R( xr, xl,    9);
300
 
  R( xl, xr, 10);
301
 
  R( xr, xl, 11);
302
 
  R( xl, xr, 12);
303
 
  R( xr, xl, 13);
304
 
  R( xl, xr, 14);
305
 
  R( xr, xl, 15);
306
 
 
307
 
  xl ^= p[BLOWFISH_ROUNDS];
308
 
  xr ^= p[BLOWFISH_ROUNDS+1];
309
 
 
310
 
  *ret_xl = xr;
311
 
  *ret_xr = xl;
312
 
 
313
 
#else
314
 
  u32 xl, xr, temp, *p;
315
 
  int i;
316
 
 
317
 
  xl = *ret_xl;
318
 
  xr = *ret_xr;
319
 
  p = bc->p;
320
 
 
321
 
  for(i=0; i < BLOWFISH_ROUNDS; i++ )
322
 
    {
323
 
      xl ^= p[i];
324
 
      xr ^= function_F(bc, xl);
325
 
      temp = xl;
326
 
      xl = xr;
327
 
      xr = temp;
328
 
    }
329
 
  temp = xl;
330
 
  xl = xr;
331
 
  xr = temp;
332
 
 
333
 
  xr ^= p[BLOWFISH_ROUNDS];
334
 
  xl ^= p[BLOWFISH_ROUNDS+1];
335
 
 
336
 
  *ret_xl = xl;
337
 
  *ret_xr = xr;
338
 
#endif
339
 
}
340
 
 
341
 
 
342
 
static void
343
 
decrypt ( BLOWFISH_context *bc, u32 *ret_xl, u32 *ret_xr )
344
 
{
345
 
#if BLOWFISH_ROUNDS == 16
346
 
  u32 xl, xr, *s0, *s1, *s2, *s3, *p;
347
 
 
348
 
  xl = *ret_xl;
349
 
  xr = *ret_xr;
350
 
  p = bc->p;
351
 
  s0 = bc->s0;
352
 
  s1 = bc->s1;
353
 
  s2 = bc->s2;
354
 
  s3 = bc->s3;
355
 
 
356
 
  R( xl, xr, 17);
357
 
  R( xr, xl, 16);
358
 
  R( xl, xr, 15);
359
 
  R( xr, xl, 14);
360
 
  R( xl, xr, 13);
361
 
  R( xr, xl, 12);
362
 
  R( xl, xr, 11);
363
 
  R( xr, xl, 10);
364
 
  R( xl, xr,    9);
365
 
  R( xr, xl,    8);
366
 
  R( xl, xr,    7);
367
 
  R( xr, xl,    6);
368
 
  R( xl, xr,    5);
369
 
  R( xr, xl,    4);
370
 
  R( xl, xr,    3);
371
 
  R( xr, xl,    2);
372
 
 
373
 
  xl ^= p[1];
374
 
  xr ^= p[0];
375
 
 
376
 
  *ret_xl = xr;
377
 
  *ret_xr = xl;
378
 
 
379
 
#else
380
 
  u32 xl, xr, temp, *p;
381
 
  int i;
382
 
 
383
 
  xl = *ret_xl;
384
 
  xr = *ret_xr;
385
 
  p = bc->p;
386
 
 
387
 
  for (i=BLOWFISH_ROUNDS+1; i > 1; i-- )
388
 
    {
389
 
      xl ^= p[i];
390
 
      xr ^= function_F(bc, xl);
391
 
      temp = xl;
392
 
      xl = xr;
393
 
      xr = temp;
394
 
    }
395
 
 
396
 
  temp = xl;
397
 
  xl = xr;
398
 
  xr = temp;
399
 
 
400
 
  xr ^= p[1];
401
 
  xl ^= p[0];
402
 
 
403
 
  *ret_xl = xl;
404
 
  *ret_xr = xr;
405
 
#endif
406
 
}
407
 
 
408
 
#undef F
409
 
#undef R
410
 
 
411
 
static void
412
 
do_encrypt_block ( BLOWFISH_context *bc, byte *outbuf, const byte *inbuf )
413
 
{
414
 
  u32 d1, d2;
415
 
 
416
 
  d1 = inbuf[0] << 24 | inbuf[1] << 16 | inbuf[2] << 8 | inbuf[3];
417
 
  d2 = inbuf[4] << 24 | inbuf[5] << 16 | inbuf[6] << 8 | inbuf[7];
418
 
  do_encrypt( bc, &d1, &d2 );
419
 
  outbuf[0] = (d1 >> 24) & 0xff;
420
 
  outbuf[1] = (d1 >> 16) & 0xff;
421
 
  outbuf[2] = (d1 >>    8) & 0xff;
422
 
  outbuf[3] =  d1          & 0xff;
423
 
  outbuf[4] = (d2 >> 24) & 0xff;
424
 
  outbuf[5] = (d2 >> 16) & 0xff;
425
 
  outbuf[6] = (d2 >>    8) & 0xff;
426
 
  outbuf[7] =  d2          & 0xff;
427
 
}
428
 
 
429
 
static void
430
 
encrypt_block (void *context, byte *outbuf, const byte *inbuf)
431
 
{
432
 
  BLOWFISH_context *bc = (BLOWFISH_context *) context;
433
 
  do_encrypt_block (bc, outbuf, inbuf);
434
 
  _gcry_burn_stack (64);
435
 
}
436
 
 
437
 
 
438
 
static void
439
 
do_decrypt_block (BLOWFISH_context *bc, byte *outbuf, const byte *inbuf)
440
 
{
441
 
  u32 d1, d2;
442
 
 
443
 
  d1 = inbuf[0] << 24 | inbuf[1] << 16 | inbuf[2] << 8 | inbuf[3];
444
 
  d2 = inbuf[4] << 24 | inbuf[5] << 16 | inbuf[6] << 8 | inbuf[7];
445
 
  decrypt( bc, &d1, &d2 );
446
 
  outbuf[0] = (d1 >> 24) & 0xff;
447
 
  outbuf[1] = (d1 >> 16) & 0xff;
448
 
  outbuf[2] = (d1 >>    8) & 0xff;
449
 
  outbuf[3] =  d1          & 0xff;
450
 
  outbuf[4] = (d2 >> 24) & 0xff;
451
 
  outbuf[5] = (d2 >> 16) & 0xff;
452
 
  outbuf[6] = (d2 >>    8) & 0xff;
453
 
  outbuf[7] =  d2          & 0xff;
454
 
}
455
 
 
456
 
static void
457
 
decrypt_block (void *context, byte *outbuf, const byte *inbuf)
458
 
{
459
 
  BLOWFISH_context *bc = (BLOWFISH_context *) context;
460
 
  do_decrypt_block (bc, outbuf, inbuf);
461
 
  _gcry_burn_stack (64);
462
 
}
463
 
 
464
 
 
465
 
static const char*
466
 
selftest(void)
467
 
{
468
 
  BLOWFISH_context c;
469
 
  byte plain[] = "BLOWFISH";
470
 
  byte buffer[8];
471
 
  byte plain3[] = { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
472
 
  byte key3[] = { 0x41, 0x79, 0x6E, 0xA0, 0x52, 0x61, 0x6E, 0xE4 };
473
 
  byte cipher3[] = { 0xE1, 0x13, 0xF4, 0x10, 0x2C, 0xFC, 0xCE, 0x43 };
474
 
 
475
 
  bf_setkey( (void *) &c,
476
 
             (const unsigned char*)"abcdefghijklmnopqrstuvwxyz", 26 );
477
 
  encrypt_block( (void *) &c, buffer, plain );
478
 
  if( memcmp( buffer, "\x32\x4E\xD0\xFE\xF4\x13\xA2\x03", 8 ) )
479
 
    return "Blowfish selftest failed (1).";
480
 
  decrypt_block( (void *) &c, buffer, buffer );
481
 
  if( memcmp( buffer, plain, 8 ) )
482
 
    return "Blowfish selftest failed (2).";
483
 
 
484
 
  bf_setkey( (void *) &c, key3, 8 );
485
 
  encrypt_block( (void *) &c, buffer, plain3 );
486
 
  if( memcmp( buffer, cipher3, 8 ) )
487
 
    return "Blowfish selftest failed (3).";
488
 
  decrypt_block( (void *) &c, buffer, buffer );
489
 
  if( memcmp( buffer, plain3, 8 ) )
490
 
    return "Blowfish selftest failed (4).";
491
 
  return NULL;
492
 
}
493
 
 
494
 
 
495
 
 
496
 
static gcry_err_code_t
497
 
do_bf_setkey (BLOWFISH_context *c, const byte *key, unsigned keylen)
498
 
{
499
 
  int i, j;
500
 
  u32 data, datal, datar;
501
 
  static int initialized;
502
 
  static const char *selftest_failed;
503
 
 
504
 
  if( !initialized ) 
505
 
    {
506
 
      initialized = 1;
507
 
      selftest_failed = selftest();
508
 
      if( selftest_failed )
509
 
        log_error ("%s\n", selftest_failed );
510
 
    }
511
 
  if( selftest_failed )
512
 
    return GPG_ERR_SELFTEST_FAILED;
513
 
 
514
 
  for(i=0; i < BLOWFISH_ROUNDS+2; i++ )
515
 
    c->p[i] = ps[i];
516
 
  for(i=0; i < 256; i++ ) 
517
 
    {
518
 
      c->s0[i] = ks0[i];
519
 
      c->s1[i] = ks1[i];
520
 
      c->s2[i] = ks2[i];
521
 
      c->s3[i] = ks3[i];
522
 
    }
523
 
 
524
 
  for(i=j=0; i < BLOWFISH_ROUNDS+2; i++ ) 
525
 
    {
526
 
#ifdef WORDS_BIGENDIAN
527
 
      ((byte*)&data)[0] = key[j];
528
 
      ((byte*)&data)[1] = key[(j+1)%keylen];
529
 
      ((byte*)&data)[2] = key[(j+2)%keylen];
530
 
      ((byte*)&data)[3] = key[(j+3)%keylen];
531
 
#else
532
 
      ((byte*)&data)[3] = key[j];
533
 
      ((byte*)&data)[2] = key[(j+1)%keylen];
534
 
      ((byte*)&data)[1] = key[(j+2)%keylen];
535
 
      ((byte*)&data)[0] = key[(j+3)%keylen];
536
 
#endif
537
 
      c->p[i] ^= data;
538
 
      j = (j+4) % keylen;
539
 
    }
540
 
 
541
 
  datal = datar = 0;
542
 
  for(i=0; i < BLOWFISH_ROUNDS+2; i += 2 )
543
 
    {
544
 
      do_encrypt( c, &datal, &datar );
545
 
      c->p[i]   = datal;
546
 
      c->p[i+1] = datar;
547
 
    }
548
 
  for(i=0; i < 256; i += 2 )    
549
 
    {
550
 
      do_encrypt( c, &datal, &datar );
551
 
      c->s0[i]   = datal;
552
 
      c->s0[i+1] = datar;
553
 
    }
554
 
  for(i=0; i < 256; i += 2 )
555
 
    {
556
 
      do_encrypt( c, &datal, &datar );
557
 
      c->s1[i]   = datal;
558
 
      c->s1[i+1] = datar;
559
 
    }
560
 
  for(i=0; i < 256; i += 2 )
561
 
    {
562
 
      do_encrypt( c, &datal, &datar );
563
 
      c->s2[i]   = datal;
564
 
      c->s2[i+1] = datar;
565
 
    }
566
 
  for(i=0; i < 256; i += 2 )
567
 
    {
568
 
      do_encrypt( c, &datal, &datar );
569
 
      c->s3[i]   = datal;
570
 
      c->s3[i+1] = datar;
571
 
    }
572
 
 
573
 
 
574
 
  /* Check for weak key.  A weak key is a key in which a value in
575
 
     the P-array (here c) occurs more than once per table.  */
576
 
  for(i=0; i < 255; i++ )
577
 
    {
578
 
      for( j=i+1; j < 256; j++)
579
 
        {
580
 
          if( (c->s0[i] == c->s0[j]) || (c->s1[i] == c->s1[j]) ||
581
 
              (c->s2[i] == c->s2[j]) || (c->s3[i] == c->s3[j]) )
582
 
            return GPG_ERR_WEAK_KEY;
583
 
        }
584
 
    }
585
 
 
586
 
  return GPG_ERR_NO_ERROR;
587
 
}
588
 
 
589
 
 
590
 
static gcry_err_code_t
591
 
bf_setkey (void *context, const byte *key, unsigned keylen)
592
 
{
593
 
  BLOWFISH_context *c = (BLOWFISH_context *) context;
594
 
  gcry_err_code_t rc = do_bf_setkey (c, key, keylen);
595
 
  _gcry_burn_stack (64);
596
 
  return rc;
597
 
}
598
 
 
599
 
 
600
 
gcry_cipher_spec_t _gcry_cipher_spec_blowfish =
601
 
  {
602
 
    "BLOWFISH", NULL, NULL, BLOWFISH_BLOCKSIZE, 128,
603
 
    sizeof (BLOWFISH_context),
604
 
    bf_setkey, encrypt_block, decrypt_block
605
 
  };