string.c: Improve documentation of create_argv().
[paraslash.git] / crypt_common.c
1 /*
2 * Copyright (C) 2005 Andre Noll <maan@tuebingen.mpg.de>
3 *
4 * Licensed under the GPL v2. For licencing details see COPYING.
5 */
6
7 /** \file crypt_common.c Crypto functions independent of openssl/libgcrypt. */
8
9 #include <regex.h>
10
11 #include "para.h"
12 #include "error.h"
13 #include "string.h"
14 #include "crypt.h"
15 #include "crypt_backend.h"
16
17 /** If the key begins with this text, we treat it as an ssh key. */
18 #define KEY_TYPE_TXT "ssh-rsa"
19
20 /**
21 * Check if given buffer starts with a ssh rsa key signature.
22 *
23 * \param data The buffer.
24 * \param size Number of data bytes.
25 *
26 * \return Number of header bytes to be skipped on success, zero if
27 * ssh rsa signature was not found.
28 */
29 size_t is_ssh_rsa_key(char *data, size_t size)
30 {
31 char *cp;
32
33 if (size < strlen(KEY_TYPE_TXT) + 2)
34 return 0;
35 cp = memchr(data, ' ', size);
36 if (cp == NULL)
37 return 0;
38 if (strncmp(KEY_TYPE_TXT, data, strlen(KEY_TYPE_TXT)))
39 return 0;
40 cp++;
41 if (cp >= data + size)
42 return 0;
43 if (*cp == '\0')
44 return 0;
45 return cp - data;
46 }
47
48 /*
49 * This base64/uudecode stuff below is taken from openssh-5.2p1, Copyright (c)
50 * 1996 by Internet Software Consortium. Portions Copyright (c) 1995 by
51 * International Business Machines, Inc.
52 */
53
54 static const char Base64[] =
55 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
56 static const char Pad64 = '=';
57
58 /**
59 * base64-decode a buffer.
60 *
61 * \param src The buffer to decode.
62 * \param target Result is stored here.
63 * \param targsize Number of bytes of \a target.
64 *
65 * Skips all whitespace anywhere. Converts characters, four at a time, starting
66 * at (or after) src from base - 64 numbers into three 8 bit bytes in the
67 * target area.
68 *
69 * \return The number of data bytes stored at the target, -E_BASE64 on errors.
70 */
71 int base64_decode(char const *src, unsigned char *target, size_t targsize)
72 {
73 unsigned int tarindex, state;
74 int ch;
75 char *pos;
76
77 state = 0;
78 tarindex = 0;
79
80 while ((ch = *src++) != '\0') {
81 if (para_isspace(ch)) /* Skip whitespace anywhere. */
82 continue;
83
84 if (ch == Pad64)
85 break;
86
87 pos = strchr(Base64, ch);
88 if (pos == NULL) /* A non-base64 character. */
89 return -E_BASE64;
90
91 switch (state) {
92 case 0:
93 if (tarindex >= targsize)
94 return -E_BASE64;
95 target[tarindex] = (pos - Base64) << 2;
96 state = 1;
97 break;
98 case 1:
99 if (tarindex + 1 >= targsize)
100 return -E_BASE64;
101 target[tarindex] |= (pos - Base64) >> 4;
102 target[tarindex + 1] = ((pos - Base64) & 0x0f) << 4;
103 tarindex++;
104 state = 2;
105 break;
106 case 2:
107 if (tarindex + 1 >= targsize)
108 return -E_BASE64;
109 target[tarindex] |= (pos - Base64) >> 2;
110 target[tarindex + 1] = ((pos - Base64) & 0x03) << 6;
111 tarindex++;
112 state = 3;
113 break;
114 case 3:
115 if (tarindex >= targsize)
116 return -E_BASE64;
117 target[tarindex] |= pos - Base64;
118 tarindex++;
119 state = 0;
120 break;
121 }
122 }
123
124 /*
125 * We are done decoding Base-64 chars. Let's see if we ended
126 * on a byte boundary, and/or with erroneous trailing characters.
127 */
128
129 if (ch == Pad64) { /* We got a pad char. */
130 ch = *src++; /* Skip it, get next. */
131 switch (state) {
132 case 0: /* Invalid = in first position */
133 case 1: /* Invalid = in second position */
134 return -E_BASE64;
135
136 case 2: /* Valid, means one byte of info */
137 /* Skip any number of spaces. */
138 for (; ch != '\0'; ch = *src++)
139 if (!isspace(ch))
140 break;
141 /* Make sure there is another trailing = sign. */
142 if (ch != Pad64)
143 return -E_BASE64;
144 ch = *src++; /* Skip the = */
145 /* Fall through to "single trailing =" case. */
146 /* FALLTHROUGH */
147
148 case 3: /* Valid, means two bytes of info */
149 /*
150 * We know this char is an =. Is there anything but
151 * whitespace after it?
152 */
153 for (; ch != '\0'; ch = *src++)
154 if (!isspace(ch))
155 return -E_BASE64;
156
157 /*
158 * Now make sure for cases 2 and 3 that the "extra"
159 * bits that slopped past the last full byte were
160 * zeros. If we don't check them, they become a
161 * subliminal channel.
162 */
163 if (target[tarindex] != 0)
164 return -E_BASE64;
165 }
166 } else {
167 /*
168 * We ended by seeing the end of the string. Make sure we
169 * have no partial bytes lying around.
170 */
171 if (state != 0)
172 return -E_BASE64;
173 }
174
175 return tarindex;
176 }
177
178 /**
179 * uudecode a buffer.
180 *
181 * \param src The buffer to decode.
182 * \param target Result buffer.
183 * \param targsize The length of \a target in bytes.
184 *
185 * This is just a simple wrapper for base64_decode() which strips whitespace.
186 *
187 * \return The return value of the underlying call to base64_decode().
188 */
189 int uudecode(const char *src, unsigned char *target, size_t targsize)
190 {
191 int len;
192 char *encoded, *p;
193
194 /* copy the 'readonly' source */
195 encoded = para_strdup(src);
196 /* skip whitespace and data */
197 for (p = encoded; *p == ' ' || *p == '\t'; p++)
198 ;
199 for (; *p != '\0' && *p != ' ' && *p != '\t'; p++)
200 ;
201 /* and remove trailing whitespace because base64_decode needs this */
202 *p = '\0';
203 len = base64_decode(encoded, target, targsize);
204 free(encoded);
205 return len;
206 }
207
208 /**
209 * Read a 4-byte number from a buffer in big-endian format.
210 *
211 * \param vp The buffer.
212 *
213 * The byte-order of the buffer is expected to be big-endian, unlike read_u32()
214 * of portable_io.h which expects little endian.
215 *
216 * \return The 32 bit number given by \a vp.
217 */
218 uint32_t read_ssh_u32(const void *vp)
219 {
220 const unsigned char *p = (const unsigned char *)vp;
221 uint32_t v;
222
223 v = (uint32_t)p[0] << 24;
224 v |= (uint32_t)p[1] << 16;
225 v |= (uint32_t)p[2] << 8;
226 v |= (uint32_t)p[3];
227
228 return v;
229 }
230
231 /**
232 * Sanity checks for the header of an ssh key.
233 *
234 * \param blob The buffer.
235 * \param blen The number of bytes of \a blob.
236 *
237 * This performs some checks to make sure we really have an ssh key. It also
238 * computes the offset in bytes of the start of the key values (modulus,
239 * exponent..).
240 *
241 * \return The number of bytes to skip until the start of the first encoded
242 * number (usually 11).
243 */
244 int check_ssh_key_header(const unsigned char *blob, int blen)
245 {
246 const unsigned char *p = blob, *end = blob + blen;
247 uint32_t rlen;
248
249 if (p + 4 > end)
250 return -E_SSH_KEY_HEADER;
251 rlen = read_ssh_u32(p);
252 p += 4;
253 if (p + rlen < p)
254 return -E_SSH_KEY_HEADER;
255 if (p + rlen > end)
256 return -E_SSH_KEY_HEADER;
257 if (rlen < strlen(KEY_TYPE_TXT))
258 return -E_SSH_KEY_HEADER;
259 PARA_DEBUG_LOG("type: %s, rlen: %d\n", p, rlen);
260 if (strncmp((char *)p, KEY_TYPE_TXT, strlen(KEY_TYPE_TXT)))
261 return -E_SSH_KEY_HEADER;
262 return 4 + rlen;
263 }
264
265 /**
266 * Check existence and permissions of a key file.
267 *
268 * \param file The path of the key file.
269 * \param private_key Whether this is a private key.
270 *
271 * This checks whether the file exists. If it is a private key, we additionally
272 * check that the permissions are restrictive enough. It is considered an error
273 * if we own the file and it is readable for others.
274 *
275 * \return Standard.
276 */
277 int check_key_file(const char *file, bool private_key)
278 {
279 struct stat st;
280
281 if (stat(file, &st) != 0)
282 return -ERRNO_TO_PARA_ERROR(errno);
283 if (!private_key)
284 return 0;
285 if ((st.st_uid == getuid()) && (st.st_mode & 077) != 0)
286 return -E_KEY_PERM;
287 return 1;
288 }
289
290 void hash_to_asc(unsigned char *hash, char *asc)
291 {
292 int i;
293 const char hexchar[] = "0123456789abcdef";
294
295 for (i = 0; i < HASH_SIZE; i++) {
296 asc[2 * i] = hexchar[hash[i] >> 4];
297 asc[2 * i + 1] = hexchar[hash[i] & 0xf];
298 }
299 asc[2 * HASH_SIZE] = '\0';
300 }
301
302 int hash_compare(unsigned char *h1, unsigned char *h2)
303 {
304 int i;
305
306 for (i = 0; i < HASH_SIZE; i++) {
307 if (h1[i] < h2[i])
308 return -1;
309 if (h1[i] > h2[i])
310 return 1;
311 }
312 return 0;
313 }