Mercurial > vim

comparison src/crypt_zip.c @ 6122:18ac55444b37 v7.4.399

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
updated for version 7.4.399 Problem: Encryption implementation is messy. Blowfish encryption has a weakness. Solution: Refactor the encryption, store the state in an allocated struct instead of using a save/restore mechanism. Introduce the "blowfish2" method, which does not have the weakness and encrypts the whole undo file. (largely by David Leadbeater)
author Bram Moolenaar <bram@vim.org>
date Sun, 10 Aug 2014 13:38:34 +0200
parents
children af3c41a3c53f
comparison
equal deleted inserted replaced
6121:913d16b4904c 6122:18ac55444b37
1 /* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10 /*
11 * crypt_zip.c: Zip encryption support.
12 */
13 #include "vim.h"
14
15 #if defined(FEAT_CRYPT) || defined(PROTO)
16 /*
17 * Optional encryption support.
18 * Mohsin Ahmed, mosh@sasi.com, 98-09-24
19 * Based on zip/crypt sources.
20 *
21 * NOTE FOR USA: Since 2000 exporting this code from the USA is allowed to
22 * most countries. There are a few exceptions, but that still should not be a
23 * problem since this code was originally created in Europe and India.
24 */
25
26 /* Need a type that should be 32 bits. 64 also works but wastes space. */
27 # if VIM_SIZEOF_INT >= 4
28 typedef unsigned int u32_T; /* int is at least 32 bits */
29 # else
30 typedef unsigned long u32_T; /* long should be 32 bits or more */
31 # endif
32
33 /* The state of encryption, referenced by cryptstate_T. */
34 typedef struct {
35 u32_T keys[3];
36 } zip_state_T;
37
38
39 static void make_crc_tab __ARGS((void));
40
41 static u32_T crc_32_table[256];
42
43 /*
44 * Fill the CRC table, if not done already.
45 */
46 static void
47 make_crc_tab()
48 {
49 u32_T s, t, v;
50 static int done = FALSE;
51
52 if (done)
53 return;
54 for (t = 0; t < 256; t++)
55 {
56 v = t;
57 for (s = 0; s < 8; s++)
58 v = (v >> 1) ^ ((v & 1) * (u32_T)0xedb88320L);
59 crc_32_table[t] = v;
60 }
61 done = TRUE;
62 }
63
64 #define CRC32(c, b) (crc_32_table[((int)(c) ^ (b)) & 0xff] ^ ((c) >> 8))
65
66 /*
67 * Return the next byte in the pseudo-random sequence.
68 */
69 #define DECRYPT_BYTE_ZIP(keys, t) { \
70 short_u temp = (short_u)keys[2] | 2; \
71 t = (int)(((unsigned)(temp * (temp ^ 1U)) >> 8) & 0xff); \
72 }
73
74 /*
75 * Update the encryption keys with the next byte of plain text.
76 */
77 #define UPDATE_KEYS_ZIP(keys, c) { \
78 keys[0] = CRC32(keys[0], (c)); \
79 keys[1] += keys[0] & 0xff; \
80 keys[1] = keys[1] * 134775813L + 1; \
81 keys[2] = CRC32(keys[2], (int)(keys[1] >> 24)); \
82 }
83
84 /*
85 * Initialize for encryption/decryption.
86 */
87 void
88 crypt_zip_init(state, key, salt, salt_len, seed, seed_len)
89 cryptstate_T *state;
90 char_u *key;
91 char_u *salt UNUSED;
92 int salt_len UNUSED;
93 char_u *seed UNUSED;
94 int seed_len UNUSED;
95 {
96 char_u *p;
97 zip_state_T *zs;
98
99 zs = (zip_state_T *)alloc(sizeof(zip_state_T));
100 state->method_state = zs;
101
102 make_crc_tab();
103 zs->keys[0] = 305419896L;
104 zs->keys[1] = 591751049L;
105 zs->keys[2] = 878082192L;
106 for (p = key; *p != NUL; ++p)
107 {
108 UPDATE_KEYS_ZIP(zs->keys, (int)*p);
109 }
110 }
111
112 /*
113 * Encrypt "from[len]" into "to[len]".
114 * "from" and "to" can be equal to encrypt in place.
115 */
116 void
117 crypt_zip_encode(state, from, len, to)
118 cryptstate_T *state;
119 char_u *from;
120 size_t len;
121 char_u *to;
122 {
123 zip_state_T *zs = state->method_state;
124 size_t i;
125 int ztemp, t;
126
127 for (i = 0; i < len; ++i)
128 {
129 ztemp = from[i];
130 DECRYPT_BYTE_ZIP(zs->keys, t);
131 UPDATE_KEYS_ZIP(zs->keys, ztemp);
132 to[i] = t ^ ztemp;
133 }
134 }
135
136 /*
137 * Decrypt "from[len]" into "to[len]".
138 */
139 void
140 crypt_zip_decode(state, from, len, to)
141 cryptstate_T *state;
142 char_u *from;
143 size_t len;
144 char_u *to;
145 {
146 zip_state_T *zs = state->method_state;
147 size_t i;
148 short_u temp;
149
150 for (i = 0; i < len; ++i)
151 {
152 temp = (short_u)zs->keys[2] | 2;
153 temp = (int)(((unsigned)(temp * (temp ^ 1U)) >> 8) & 0xff);
154 UPDATE_KEYS_ZIP(zs->keys, to[i] = from[i] ^ temp);
155 }
156 }
157
158 #endif /* FEAT_CRYPT */