← Back to branch summary

~ubuntu-branches/debian/sid/botan/sid

« back to all changes in this revision

Viewing changes to src/rc2.cpp

  • Committer: Package Import Robot
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2018-03-01 22:23:25 UTC
  • mfrom: (1.2.2)
  • Revision ID: package-import@ubuntu.com-20180301222325-7p7vc45gu3hta34d
Tags: 2.4.0-2
* Don't remove .doctrees from the manual if it doesn't exist.
* Don't specify parallel to debhelper.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/rc2.cpp
1
 
/*************************************************
2
 
* RC2 Source File                                *
3
 
* (C) 1999-2007 The Botan Project                *
4
 
*************************************************/
5
 
 
6
 
#include <botan/rc2.h>
7
 
#include <botan/bit_ops.h>
8
 
 
9
 
namespace Botan {
10
 
 
11
 
/*************************************************
12
 
* RC2 Encryption                                 *
13
 
*************************************************/
14
 
void RC2::enc(const byte in[], byte out[]) const
15
 
   {
16
 
   u16bit R0 = make_u16bit(in[1], in[0]), R1 = make_u16bit(in[3], in[2]),
17
 
          R2 = make_u16bit(in[5], in[4]), R3 = make_u16bit(in[7], in[6]);
18
 
   mix(R0, R1, R2, R3, 0); mix(R0, R1, R2, R3, 1); mix(R0, R1, R2, R3, 2);
19
 
   mix(R0, R1, R2, R3, 3); mix(R0, R1, R2, R3, 4); mash(R0, R1, R2, R3);
20
 
   mix(R0, R1, R2, R3, 5); mix(R0, R1, R2, R3, 6); mix(R0, R1, R2, R3, 7);
21
 
   mix(R0, R1, R2, R3, 8); mix(R0, R1, R2, R3, 9); mix(R0, R1, R2, R3,10);
22
 
   mash(R0, R1, R2, R3);   mix(R0, R1, R2, R3,11); mix(R0, R1, R2, R3,12);
23
 
   mix(R0, R1, R2, R3,13); mix(R0, R1, R2, R3,14); mix(R0, R1, R2, R3,15);
24
 
   out[0] = get_byte(1, R0); out[1] = get_byte(0, R0);
25
 
   out[2] = get_byte(1, R1); out[3] = get_byte(0, R1);
26
 
   out[4] = get_byte(1, R2); out[5] = get_byte(0, R2);
27
 
   out[6] = get_byte(1, R3); out[7] = get_byte(0, R3);
28
 
   }
29
 
 
30
 
/*************************************************
31
 
* RC2 Decryption                                 *
32
 
*************************************************/
33
 
void RC2::dec(const byte in[], byte out[]) const
34
 
   {
35
 
   u16bit R0 = make_u16bit(in[1], in[0]), R1 = make_u16bit(in[3], in[2]),
36
 
          R2 = make_u16bit(in[5], in[4]), R3 = make_u16bit(in[7], in[6]);
37
 
   rmix(R0, R1, R2, R3,15); rmix(R0, R1, R2, R3,14); rmix(R0, R1, R2, R3,13);
38
 
   rmix(R0, R1, R2, R3,12); rmix(R0, R1, R2, R3,11); rmash(R0, R1, R2, R3);
39
 
   rmix(R0, R1, R2, R3,10); rmix(R0, R1, R2, R3, 9); rmix(R0, R1, R2, R3, 8);
40
 
   rmix(R0, R1, R2, R3, 7); rmix(R0, R1, R2, R3, 6); rmix(R0, R1, R2, R3, 5);
41
 
   rmash(R0, R1, R2, R3);   rmix(R0, R1, R2, R3, 4); rmix(R0, R1, R2, R3, 3);
42
 
   rmix(R0, R1, R2, R3, 2); rmix(R0, R1, R2, R3, 1); rmix(R0, R1, R2, R3, 0);
43
 
   out[0] = get_byte(1, R0); out[1] = get_byte(0, R0);
44
 
   out[2] = get_byte(1, R1); out[3] = get_byte(0, R1);
45
 
   out[4] = get_byte(1, R2); out[5] = get_byte(0, R2);
46
 
   out[6] = get_byte(1, R3); out[7] = get_byte(0, R3);
47
 
   }
48
 
 
49
 
/*************************************************
50
 
* RC2 Mix Function                               *
51
 
*************************************************/
52
 
void RC2::mix(u16bit& R0, u16bit& R1, u16bit& R2,
53
 
              u16bit& R3, u32bit round) const
54
 
   {
55
 
   R0 += (R1 & ~R3) + (R2 & R3) + K[4*round    ]; R0 = rotate_left(R0, 1);
56
 
   R1 += (R2 & ~R0) + (R3 & R0) + K[4*round + 1]; R1 = rotate_left(R1, 2);
57
 
   R2 += (R3 & ~R1) + (R0 & R1) + K[4*round + 2]; R2 = rotate_left(R2, 3);
58
 
   R3 += (R0 & ~R2) + (R1 & R2) + K[4*round + 3]; R3 = rotate_left(R3, 5);
59
 
   }
60
 
 
61
 
/*************************************************
62
 
* RC2 R-Mix Function                             *
63
 
*************************************************/
64
 
void RC2::rmix(u16bit& R0, u16bit& R1, u16bit& R2,
65
 
               u16bit& R3, u32bit round) const
66
 
   {
67
 
   R3 = rotate_right(R3, 5); R3 -= (R0 & ~R2) + (R1 & R2) + K[4*round + 3];
68
 
   R2 = rotate_right(R2, 3); R2 -= (R3 & ~R1) + (R0 & R1) + K[4*round + 2];
69
 
   R1 = rotate_right(R1, 2); R1 -= (R2 & ~R0) + (R3 & R0) + K[4*round + 1];
70
 
   R0 = rotate_right(R0, 1); R0 -= (R1 & ~R3) + (R2 & R3) + K[4*round + 0];
71
 
   }
72
 
 
73
 
/*************************************************
74
 
* RC2 Mash Function                              *
75
 
*************************************************/
76
 
void RC2::mash(u16bit& R0, u16bit& R1, u16bit& R2, u16bit& R3) const
77
 
   {
78
 
   R0 += K[R3 % 64]; R1 += K[R0 % 64]; R2 += K[R1 % 64]; R3 += K[R2 % 64];
79
 
   }
80
 
 
81
 
/*************************************************
82
 
* RC2 R-Mash Function                            *
83
 
*************************************************/
84
 
void RC2::rmash(u16bit& R0, u16bit& R1, u16bit& R2, u16bit& R3) const
85
 
   {
86
 
   R3 -= K[R2 % 64]; R2 -= K[R1 % 64]; R1 -= K[R0 % 64]; R0 -= K[R3 % 64];
87
 
   }
88
 
 
89
 
/*************************************************
90
 
* RC2 Key Schedule                               *
91
 
*************************************************/
92
 
void RC2::key(const byte key[], u32bit length)
93
 
   {
94
 
   static const byte TABLE[256] = {
95
 
      0xD9, 0x78, 0xF9, 0xC4, 0x19, 0xDD, 0xB5, 0xED, 0x28, 0xE9, 0xFD, 0x79,
96
 
      0x4A, 0xA0, 0xD8, 0x9D, 0xC6, 0x7E, 0x37, 0x83, 0x2B, 0x76, 0x53, 0x8E,
97
 
      0x62, 0x4C, 0x64, 0x88, 0x44, 0x8B, 0xFB, 0xA2, 0x17, 0x9A, 0x59, 0xF5,
98
 
      0x87, 0xB3, 0x4F, 0x13, 0x61, 0x45, 0x6D, 0x8D, 0x09, 0x81, 0x7D, 0x32,
99
 
      0xBD, 0x8F, 0x40, 0xEB, 0x86, 0xB7, 0x7B, 0x0B, 0xF0, 0x95, 0x21, 0x22,
100
 
      0x5C, 0x6B, 0x4E, 0x82, 0x54, 0xD6, 0x65, 0x93, 0xCE, 0x60, 0xB2, 0x1C,
101
 
      0x73, 0x56, 0xC0, 0x14, 0xA7, 0x8C, 0xF1, 0xDC, 0x12, 0x75, 0xCA, 0x1F,
102
 
      0x3B, 0xBE, 0xE4, 0xD1, 0x42, 0x3D, 0xD4, 0x30, 0xA3, 0x3C, 0xB6, 0x26,
103
 
      0x6F, 0xBF, 0x0E, 0xDA, 0x46, 0x69, 0x07, 0x57, 0x27, 0xF2, 0x1D, 0x9B,
104
 
      0xBC, 0x94, 0x43, 0x03, 0xF8, 0x11, 0xC7, 0xF6, 0x90, 0xEF, 0x3E, 0xE7,
105
 
      0x06, 0xC3, 0xD5, 0x2F, 0xC8, 0x66, 0x1E, 0xD7, 0x08, 0xE8, 0xEA, 0xDE,
106
 
      0x80, 0x52, 0xEE, 0xF7, 0x84, 0xAA, 0x72, 0xAC, 0x35, 0x4D, 0x6A, 0x2A,
107
 
      0x96, 0x1A, 0xD2, 0x71, 0x5A, 0x15, 0x49, 0x74, 0x4B, 0x9F, 0xD0, 0x5E,
108
 
      0x04, 0x18, 0xA4, 0xEC, 0xC2, 0xE0, 0x41, 0x6E, 0x0F, 0x51, 0xCB, 0xCC,
109
 
      0x24, 0x91, 0xAF, 0x50, 0xA1, 0xF4, 0x70, 0x39, 0x99, 0x7C, 0x3A, 0x85,
110
 
      0x23, 0xB8, 0xB4, 0x7A, 0xFC, 0x02, 0x36, 0x5B, 0x25, 0x55, 0x97, 0x31,
111
 
      0x2D, 0x5D, 0xFA, 0x98, 0xE3, 0x8A, 0x92, 0xAE, 0x05, 0xDF, 0x29, 0x10,
112
 
      0x67, 0x6C, 0xBA, 0xC9, 0xD3, 0x00, 0xE6, 0xCF, 0xE1, 0x9E, 0xA8, 0x2C,
113
 
      0x63, 0x16, 0x01, 0x3F, 0x58, 0xE2, 0x89, 0xA9, 0x0D, 0x38, 0x34, 0x1B,
114
 
      0xAB, 0x33, 0xFF, 0xB0, 0xBB, 0x48, 0x0C, 0x5F, 0xB9, 0xB1, 0xCD, 0x2E,
115
 
      0xC5, 0xF3, 0xDB, 0x47, 0xE5, 0xA5, 0x9C, 0x77, 0x0A, 0xA6, 0x20, 0x68,
116
 
      0xFE, 0x7F, 0xC1, 0xAD };
117
 
 
118
 
   SecureBuffer<byte, 128> L;
119
 
   L.copy(key, length);
120
 
 
121
 
   for(u32bit j = length; j != 128; ++j)
122
 
      L[j] = TABLE[(L[j-1] + L[j-length]) % 256];
123
 
   L[128-length] = TABLE[L[128-length]];
124
 
   for(s32bit j = 127-length; j >= 0; --j)
125
 
      L[j] = TABLE[L[j+1] ^ L[j+length]];
126
 
 
127
 
   for(u32bit j = 0; j != 64; ++j)
128
 
      K[j] = make_u16bit(L[2*j+1], L[2*j]);
129
 
   }
130
 
 
131
 
/*************************************************
132
 
* Return the code of the effective key bits      *
133
 
*************************************************/
134
 
byte RC2::EKB_code(u32bit ekb)
135
 
   {
136
 
   const byte EKB[256] = {
137
 
      0xBD, 0x56, 0xEA, 0xF2, 0xA2, 0xF1, 0xAC, 0x2A, 0xB0, 0x93, 0xD1, 0x9C,
138
 
      0x1B, 0x33, 0xFD, 0xD0, 0x30, 0x04, 0xB6, 0xDC, 0x7D, 0xDF, 0x32, 0x4B,
139
 
      0xF7, 0xCB, 0x45, 0x9B, 0x31, 0xBB, 0x21, 0x5A, 0x41, 0x9F, 0xE1, 0xD9,
140
 
      0x4A, 0x4D, 0x9E, 0xDA, 0xA0, 0x68, 0x2C, 0xC3, 0x27, 0x5F, 0x80, 0x36,
141
 
      0x3E, 0xEE, 0xFB, 0x95, 0x1A, 0xFE, 0xCE, 0xA8, 0x34, 0xA9, 0x13, 0xF0,
142
 
      0xA6, 0x3F, 0xD8, 0x0C, 0x78, 0x24, 0xAF, 0x23, 0x52, 0xC1, 0x67, 0x17,
143
 
      0xF5, 0x66, 0x90, 0xE7, 0xE8, 0x07, 0xB8, 0x60, 0x48, 0xE6, 0x1E, 0x53,
144
 
      0xF3, 0x92, 0xA4, 0x72, 0x8C, 0x08, 0x15, 0x6E, 0x86, 0x00, 0x84, 0xFA,
145
 
      0xF4, 0x7F, 0x8A, 0x42, 0x19, 0xF6, 0xDB, 0xCD, 0x14, 0x8D, 0x50, 0x12,
146
 
      0xBA, 0x3C, 0x06, 0x4E, 0xEC, 0xB3, 0x35, 0x11, 0xA1, 0x88, 0x8E, 0x2B,
147
 
      0x94, 0x99, 0xB7, 0x71, 0x74, 0xD3, 0xE4, 0xBF, 0x3A, 0xDE, 0x96, 0x0E,
148
 
      0xBC, 0x0A, 0xED, 0x77, 0xFC, 0x37, 0x6B, 0x03, 0x79, 0x89, 0x62, 0xC6,
149
 
      0xD7, 0xC0, 0xD2, 0x7C, 0x6A, 0x8B, 0x22, 0xA3, 0x5B, 0x05, 0x5D, 0x02,
150
 
      0x75, 0xD5, 0x61, 0xE3, 0x18, 0x8F, 0x55, 0x51, 0xAD, 0x1F, 0x0B, 0x5E,
151
 
      0x85, 0xE5, 0xC2, 0x57, 0x63, 0xCA, 0x3D, 0x6C, 0xB4, 0xC5, 0xCC, 0x70,
152
 
      0xB2, 0x91, 0x59, 0x0D, 0x47, 0x20, 0xC8, 0x4F, 0x58, 0xE0, 0x01, 0xE2,
153
 
      0x16, 0x38, 0xC4, 0x6F, 0x3B, 0x0F, 0x65, 0x46, 0xBE, 0x7E, 0x2D, 0x7B,
154
 
      0x82, 0xF9, 0x40, 0xB5, 0x1D, 0x73, 0xF8, 0xEB, 0x26, 0xC7, 0x87, 0x97,
155
 
      0x25, 0x54, 0xB1, 0x28, 0xAA, 0x98, 0x9D, 0xA5, 0x64, 0x6D, 0x7A, 0xD4,
156
 
      0x10, 0x81, 0x44, 0xEF, 0x49, 0xD6, 0xAE, 0x2E, 0xDD, 0x76, 0x5C, 0x2F,
157
 
      0xA7, 0x1C, 0xC9, 0x09, 0x69, 0x9A, 0x83, 0xCF, 0x29, 0x39, 0xB9, 0xE9,
158
 
      0x4C, 0xFF, 0x43, 0xAB };
159
 
 
160
 
   if(ekb < 256)
161
 
      return EKB[ekb];
162
 
   else
163
 
      throw Encoding_Error("RC2::EKB_code: EKB is too large");
164
 
   }
165
 
 
166
 
}