chiark - git - mdw - catacomb/blob - symm/rc2.c

   1 /* -*-c-*-
   2  *
   3  * The RC2 block cipher
   4  *
   5  * (c) 2000 Straylight/Edgeware
   6  */
   7
   8 /*----- Licensing notice --------------------------------------------------*
   9  *
  10  * This file is part of Catacomb.
  11  *
  12  * Catacomb is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU Library General Public License as
  14  * published by the Free Software Foundation; either version 2 of the
  15  * License, or (at your option) any later version.
  16  *
  17  * Catacomb is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU Library General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Library General Public
  23  * License along with Catacomb; if not, write to the Free
  24  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  25  * MA 02111-1307, USA.
  26  */
  27
  28 /*----- Header files ------------------------------------------------------*/
  29
  30 #include <assert.h>
  31 #include <stdio.h>
  32
  33 #include <mLib/bits.h>
  34
  35 #include "blkc.h"
  36 #include "gcipher.h"
  37 #include "paranoia.h"
  38 #include "rc2.h"
  39
  40 /*----- Global variables --------------------------------------------------*/
  41
  42 const octet rc2_keysz[] = { KSZ_RANGE, RC2_KEYSZ, 1, 128, 1 };
  43
  44 /*----- Important tables --------------------------------------------------*/
  45
  46 extern const octet rc2_pi[256];
  47
  48 /*----- Main code ---------------------------------------------------------*/
  49
  50 /* --- @rc2_braindamage@ --- *
  51  *
  52  * Arguments:   @rc2_ctx *k@ = pointer to context to initialize
  53  *              @const void *buf@ = pointer to key material
  54  *              @size_t sz@ = size of key material in bytes
  55  *              @unsigned eb@ = desired effective key size, in bits
  56  *
  57  * Returns:     ---
  58  *
  59  * Use:         Initializes an RC2 expanded key, and braindamages it to the
  60  *              requested effective key size.  This is here for compatibility
  61  *              reasons.  You should be using @rc2_init@ in normal code,
  62  *              which doesn't actually apply braindamage.
  63  */
  64
  65 void rc2_braindamage(rc2_ctx *k, const void *buf, size_t sz, unsigned eb)
  66 {
  67   unsigned t8;
  68   uint16 tm;
  69   unsigned i;
  70   uint16 *kk;
  71   octet l[128];
  72
  73   KSZ_ASSERT(rc2, sz);
  74
  75   /* --- Compute the braindamage parameters --- */
  76
  77   t8 = (eb + 7) / 8;
  78   tm = 0xff & ((1 << (8 + eb - 8 * t8)) - 1);
  79
  80   /* --- Copy and expand the initial key --- */
  81
  82   if (sz > sizeof(l))
  83     sz = sizeof(l);
  84   memcpy(l, buf, sz);
  85
  86   for (i = sz; i < sizeof(l); i++)
  87     l[i] = rc2_pi[U8(l[i - 1] + l[i - sz])];
  88
  89   /* --- Braindamage the key --- */
  90
  91   i = sizeof(l) - t8;
  92   l[i] = rc2_pi[l[i] & tm];
  93   while (i) {
  94     i--;
  95     l[i] = rc2_pi[U8(l[i + 1] ^ l[i + t8])];
  96   }
  97
  98   /* --- Write it to the key block --- */
  99
 100   kk = k->k;
 101   for (i = 0; i < sizeof(l); i += 2)
 102     *kk++ = LOAD16_L(l + i);
 103   BURN(l);
 104 }
 105
 106 /* --- @rc2_init@ --- *
 107  *
 108  * Arguments:   @rc2_ctx *k@ = pointer to context to initialize
 109  *              @const void *buf@ = pointer to key material
 110  *              @size_t sz@ = size of key material in bytes
 111  *
 112  * Returns:     ---
 113  *
 114  * Use:         Initializes an RC2 expanded key.  The effective key size is
 115  *              set to be equal to the real key size, in bits.
 116  */
 117
 118 void rc2_init(rc2_ctx *k, const void *buf, size_t sz)
 119 {
 120   rc2_braindamage(k, buf, sz, sz * 8);
 121 }
 122
 123 /*----- Encryption and decryption -----------------------------------------*/
 124
 125 #define MIX(a, b, c, d, r, kk) do {                                     \
 126   a += *kk++ + (d & c) + (~d & b);                                      \
 127   a = ROL16(a, r);                                                      \
 128 } while (0)
 129
 130 #define MASH(a, d, k) do {                                              \
 131   a += k[d & 63];                                                       \
 132 } while (0)
 133
 134 #define UNMIX(a, b, c, d, r, kk) do {                                   \
 135   a = ROR16(a, r);                                                      \
 136   a -= *--kk + (d & c) + (~d & b);                                      \
 137 } while (0)
 138
 139 #define UNMASH(a, d, k) do {                                            \
 140   a -= k[d & 63];                                                       \
 141 } while (0)
 142
 143 /* --- @rc2_eblk@, @rc2_dblk@ --- *
 144  *
 145  * Arguments:   @const rc2_ctx *k@ = pointer to RC2 context
 146  *              @const uint32 s[2]@ = pointer to source block
 147  *              @const uint32 d[2]@ = pointer to destination block
 148  *
 149  * Returns:     ---
 150  *
 151  * Use:         Low-level block encryption and decryption.
 152  */
 153
 154 void rc2_eblk(const rc2_ctx *k, const uint32 *s, uint32 *dst)
 155 {
 156   uint16 a = U16(s[0] >>  0), b = U16(s[0] >> 16);
 157   uint16 c = U16(s[1] >>  0), d = U16(s[1] >> 16);
 158   const uint16 *kk = k->k;
 159
 160   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 161   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 162   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 163   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 164   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 165   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 166   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 167   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 168   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 169   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 170   MASH(a, d, k->k); MASH(b, a, k->k);
 171   MASH(c, b, k->k); MASH(d, c, k->k);
 172   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 173   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 174   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 175   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 176   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 177   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 178   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 179   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 180   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 181   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 182   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 183   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 184   MASH(a, d, k->k); MASH(b, a, k->k);
 185   MASH(c, b, k->k); MASH(d, c, k->k);
 186   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 187   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 188   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 189   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 190   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 191   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 192   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 193   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 194   MIX(a, b, c, d, 1, kk); MIX(b, c, d, a, 2, kk);
 195   MIX(c, d, a, b, 3, kk); MIX(d, a, b, c, 5, kk);
 196
 197   dst[0] = a | (b << 16); dst[1] = c | (d << 16);
 198 }
 199
 200 void rc2_dblk(const rc2_ctx *k, const uint32 *s, uint32 *dst)
 201 {
 202   uint16 a = U16(s[0] >>  0), b = U16(s[0] >> 16);
 203   uint16 c = U16(s[1] >>  0), d = U16(s[1] >> 16);
 204   const uint16 *kk = k->k + 64;
 205
 206   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 207   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 208   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 209   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 210   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 211   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 212   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 213   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 214   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 215   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 216   UNMASH(d, c, k->k); UNMASH(c, b, k->k);
 217   UNMASH(b, a, k->k); UNMASH(a, d, k->k);
 218   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 219   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 220   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 221   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 222   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 223   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 224   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 225   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 226   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 227   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 228   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 229   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 230   UNMASH(d, c, k->k); UNMASH(c, b, k->k);
 231   UNMASH(b, a, k->k); UNMASH(a, d, k->k);
 232   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 233   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 234   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 235   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 236   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 237   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 238   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 239   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 240   UNMIX(d, a, b, c, 5, kk); UNMIX(c, d, a, b, 3, kk);
 241   UNMIX(b, c, d, a, 2, kk); UNMIX(a, b, c, d, 1, kk);
 242
 243   dst[0] = a | (b << 16); dst[1] = c | (d << 16);
 244 }
 245
 246 /*----- Custom test rig ---------------------------------------------------*
 247  *
 248  * I need to test the braindamage feature.
 249  */
 250
 251 #ifdef TEST_RIG
 252
 253 #include <mLib/macros.h>
 254 #include <mLib/quis.h>
 255 #include <mLib/testrig.h>
 256
 257 static int verify(dstr *v)
 258 {
 259   rc2_ctx k;
 260   uint32 p[RC2_BLKSZ / 4];
 261   uint32 c[RC2_BLKSZ / 4];
 262   uint32 d[RC2_BLKSZ / 4];
 263   dstr b = DSTR_INIT;
 264   unsigned bd = *(unsigned *)v[1].buf;
 265   int ok = 1;
 266
 267   /* --- Initialize the key buffer --- */
 268
 269   dstr_ensure(&b, RC2_BLKSZ);
 270   b.len = RC2_BLKSZ;
 271   rc2_braindamage(&k, v[0].buf, v[0].len, bd);
 272   BLKC_LOAD(RC2, p, v[2].buf);
 273   BLKC_LOAD(RC2, c, v[3].buf);
 274
 275   /* --- Test encryption --- */
 276
 277   BLKC_MOVE(RC2, d, p);
 278   rc2_eblk(&k, d, d);
 279   BLKC_STORE(RC2, b.buf, d);
 280   if (MEMCMP(b.buf, !=, v[3].buf, RC2_BLKSZ)) {
 281     ok = 0;
 282     printf("\nfail encryption:"
 283            "\n\tkey        = ");
 284     type_hex.dump(&v[0], stdout);
 285     printf("\n\tbraindamage= %u", bd);
 286     printf("\n\tplaintext  = "); type_hex.dump(&v[2], stdout);
 287     printf("\n\texpected   = "); type_hex.dump(&v[3], stdout);
 288     printf("\n\tcalculated = "); type_hex.dump(&b, stdout);
 289     putchar('\n');
 290   }
 291
 292   /* --- Test decryption --- */
 293
 294   BLKC_MOVE(RC2, d, c);
 295   rc2_dblk(&k, d, d);
 296   BLKC_STORE(RC2, b.buf, d);
 297   if (MEMCMP(b.buf, !=, v[2].buf, RC2_BLKSZ)) {
 298     ok = 0;
 299     printf("\nfail decryption:"
 300            "\n\tkey        = ");
 301     type_hex.dump(&v[0], stdout);
 302     printf("\n\tbraindamage= %u", bd);
 303     printf("\n\tciphertext = "); type_hex.dump(&v[3], stdout);
 304     printf("\n\texpected   = "); type_hex.dump(&v[2], stdout);
 305     printf("\n\tcalculated = "); type_hex.dump(&b, stdout);
 306     putchar('\n');
 307   }
 308
 309   /* --- Return --- */
 310
 311   return (ok);
 312 }
 313
 314 static test_chunk defs[] = {
 315   { "rc2", verify, { &type_hex, &type_int, &type_hex, &type_hex, 0 } },
 316   { 0, 0, { 0 } }
 317 };
 318
 319 int main(int argc, char *argv[])
 320 {
 321   test_run(argc, argv, defs, SRCDIR"/t/rc2");
 322   return (0);
 323 }
 324
 325 #endif
 326
 327 /*----- That's all, folks -------------------------------------------------*/