]>
Commit | Line | Data |
---|---|---|
1d270bd3 | 1 | /* $OpenBSD: authfile.c,v 1.144 2023/03/14 07:26:25 dtucker Exp $ */ |
d4a8b7e3 | 2 | /* |
bcd00abd | 3 | * Copyright (c) 2000, 2013 Markus Friedl. All rights reserved. |
e4340be5 DM |
4 | * |
5 | * Redistribution and use in source and binary forms, with or without | |
6 | * modification, are permitted provided that the following conditions | |
7 | * are met: | |
8 | * 1. Redistributions of source code must retain the above copyright | |
9 | * notice, this list of conditions and the following disclaimer. | |
10 | * 2. Redistributions in binary form must reproduce the above copyright | |
11 | * notice, this list of conditions and the following disclaimer in the | |
12 | * documentation and/or other materials provided with the distribution. | |
13 | * | |
14 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR | |
15 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES | |
16 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. | |
17 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, | |
18 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |
19 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
20 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
21 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
22 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | |
23 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
95def098 | 24 | */ |
d4a8b7e3 DM |
25 | |
26 | #include "includes.h" | |
f17883e6 DM |
27 | |
28 | #include <sys/types.h> | |
29 | #include <sys/stat.h> | |
d7834353 | 30 | #include <sys/uio.h> |
d4a8b7e3 | 31 | |
ba724050 | 32 | #include <errno.h> |
57cf6385 | 33 | #include <fcntl.h> |
a7a73ee3 | 34 | #include <stdio.h> |
8668706d | 35 | #include <stdarg.h> |
e7a1e5cf | 36 | #include <stdlib.h> |
e3476ed0 | 37 | #include <string.h> |
e6b3b610 | 38 | #include <unistd.h> |
087266ec | 39 | #include <limits.h> |
57cf6385 | 40 | |
d7834353 | 41 | #include "cipher.h" |
226cfa03 BL |
42 | #include "ssh.h" |
43 | #include "log.h" | |
31ca54aa | 44 | #include "authfile.h" |
f0f90989 | 45 | #include "misc.h" |
eccb9de7 | 46 | #include "atomicio.h" |
16db0a7e | 47 | #include "sshkey.h" |
8668706d DM |
48 | #include "sshbuf.h" |
49 | #include "ssherr.h" | |
5e39a499 | 50 | #include "krl.h" |
d4a8b7e3 | 51 | |
2ce12ef1 DM |
52 | #define MAX_KEY_FILE_SIZE (1024 * 1024) |
53 | ||
a2327927 DM |
54 | /* Save a key blob to a file */ |
55 | static int | |
8668706d | 56 | sshkey_save_private_blob(struct sshbuf *keybuf, const char *filename) |
a2327927 | 57 | { |
99aa8035 | 58 | int r; |
59 | mode_t omask; | |
a2327927 | 60 | |
99aa8035 | 61 | omask = umask(077); |
62 | r = sshbuf_write_file(filename, keybuf); | |
63 | umask(omask); | |
64 | return r; | |
a2327927 DM |
65 | } |
66 | ||
67 | int | |
8668706d DM |
68 | sshkey_save_private(struct sshkey *key, const char *filename, |
69 | const char *passphrase, const char *comment, | |
eb0d8e70 | 70 | int format, const char *openssh_format_cipher, int openssh_format_rounds) |
a2327927 | 71 | { |
8668706d DM |
72 | struct sshbuf *keyblob = NULL; |
73 | int r; | |
a2327927 | 74 | |
8668706d DM |
75 | if ((keyblob = sshbuf_new()) == NULL) |
76 | return SSH_ERR_ALLOC_FAIL; | |
77 | if ((r = sshkey_private_to_fileblob(key, keyblob, passphrase, comment, | |
eb0d8e70 | 78 | format, openssh_format_cipher, openssh_format_rounds)) != 0) |
a2327927 | 79 | goto out; |
8668706d | 80 | if ((r = sshkey_save_private_blob(keyblob, filename)) != 0) |
a2327927 | 81 | goto out; |
8668706d | 82 | r = 0; |
a2327927 | 83 | out: |
8668706d DM |
84 | sshbuf_free(keyblob); |
85 | return r; | |
a2327927 DM |
86 | } |
87 | ||
8668706d | 88 | /* XXX remove error() calls from here? */ |
8275fade | 89 | int |
8668706d | 90 | sshkey_perm_ok(int fd, const char *filename) |
eba71bab | 91 | { |
eba71bab DM |
92 | struct stat st; |
93 | ||
4d28fa78 | 94 | if (fstat(fd, &st) == -1) |
8668706d | 95 | return SSH_ERR_SYSTEM_ERROR; |
7aff2613 BL |
96 | /* |
97 | * if a key owned by the user is accessed, then we check the | |
98 | * permissions of the file. if the key owned by a different user, | |
99 | * then we don't care. | |
100 | */ | |
b70b61f5 | 101 | #ifdef HAVE_CYGWIN |
cb5e44a4 | 102 | if (check_ntsec(filename)) |
b70b61f5 | 103 | #endif |
7aff2613 | 104 | if ((st.st_uid == getuid()) && (st.st_mode & 077) != 0) { |
eba71bab DM |
105 | error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); |
106 | error("@ WARNING: UNPROTECTED PRIVATE KEY FILE! @"); | |
107 | error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); | |
7aff2613 | 108 | error("Permissions 0%3.3o for '%s' are too open.", |
04bd8b0b | 109 | (u_int)st.st_mode & 0777, filename); |
6b0d576b | 110 | error("It is required that your private key files are NOT accessible by others."); |
d0fca423 | 111 | error("This private key will be ignored."); |
8668706d | 112 | return SSH_ERR_KEY_BAD_PERMISSIONS; |
eba71bab | 113 | } |
8668706d | 114 | return 0; |
d0fca423 | 115 | } |
b257cca7 | 116 | |
8668706d DM |
117 | int |
118 | sshkey_load_private_type(int type, const char *filename, const char *passphrase, | |
6b39a7b4 | 119 | struct sshkey **keyp, char **commentp) |
a2327927 | 120 | { |
8668706d | 121 | int fd, r; |
bcd00abd | 122 | |
dce19bf6 | 123 | if (keyp != NULL) |
124 | *keyp = NULL; | |
8668706d DM |
125 | if (commentp != NULL) |
126 | *commentp = NULL; | |
d0fca423 | 127 | |
6b39a7b4 | 128 | if ((fd = open(filename, O_RDONLY)) == -1) |
8668706d | 129 | return SSH_ERR_SYSTEM_ERROR; |
6b39a7b4 | 130 | |
131 | r = sshkey_perm_ok(fd, filename); | |
132 | if (r != 0) | |
8668706d | 133 | goto out; |
a2327927 | 134 | |
1195f4cb | 135 | r = sshkey_load_private_type_fd(fd, type, passphrase, keyp, commentp); |
1b11ea7c | 136 | if (r == 0 && keyp && *keyp) |
137 | r = sshkey_set_filename(*keyp, filename); | |
1195f4cb | 138 | out: |
139 | close(fd); | |
140 | return r; | |
141 | } | |
142 | ||
094dd513 | 143 | int |
144 | sshkey_load_private(const char *filename, const char *passphrase, | |
145 | struct sshkey **keyp, char **commentp) | |
146 | { | |
147 | return sshkey_load_private_type(KEY_UNSPEC, filename, passphrase, | |
148 | keyp, commentp); | |
149 | } | |
150 | ||
1195f4cb | 151 | int |
152 | sshkey_load_private_type_fd(int fd, int type, const char *passphrase, | |
153 | struct sshkey **keyp, char **commentp) | |
154 | { | |
155 | struct sshbuf *buffer = NULL; | |
156 | int r; | |
157 | ||
dce19bf6 | 158 | if (keyp != NULL) |
159 | *keyp = NULL; | |
99aa8035 | 160 | if ((r = sshbuf_load_fd(fd, &buffer)) != 0 || |
1195f4cb | 161 | (r = sshkey_parse_private_fileblob_type(buffer, type, |
162 | passphrase, keyp, commentp)) != 0) | |
8668706d | 163 | goto out; |
1195f4cb | 164 | |
165 | /* success */ | |
8668706d DM |
166 | r = 0; |
167 | out: | |
52d70784 | 168 | sshbuf_free(buffer); |
8668706d | 169 | return r; |
d0fca423 BL |
170 | } |
171 | ||
2b13d393 | 172 | /* Load a pubkey from the unencrypted envelope of a new-format private key */ |
173 | static int | |
174 | sshkey_load_pubkey_from_private(const char *filename, struct sshkey **pubkeyp) | |
175 | { | |
176 | struct sshbuf *buffer = NULL; | |
177 | struct sshkey *pubkey = NULL; | |
178 | int r, fd; | |
179 | ||
180 | if (pubkeyp != NULL) | |
181 | *pubkeyp = NULL; | |
182 | ||
183 | if ((fd = open(filename, O_RDONLY)) == -1) | |
184 | return SSH_ERR_SYSTEM_ERROR; | |
185 | if ((r = sshbuf_load_fd(fd, &buffer)) != 0 || | |
186 | (r = sshkey_parse_pubkey_from_private_fileblob_type(buffer, | |
187 | KEY_UNSPEC, &pubkey)) != 0) | |
188 | goto out; | |
189 | if ((r = sshkey_set_filename(pubkey, filename)) != 0) | |
190 | goto out; | |
191 | /* success */ | |
192 | if (pubkeyp != NULL) { | |
193 | *pubkeyp = pubkey; | |
194 | pubkey = NULL; | |
195 | } | |
196 | r = 0; | |
197 | out: | |
198 | close(fd); | |
199 | sshbuf_free(buffer); | |
200 | sshkey_free(pubkey); | |
201 | return r; | |
202 | } | |
203 | ||
bba81213 | 204 | static int |
d01f3930 | 205 | sshkey_try_load_public(struct sshkey **kp, const char *filename, |
206 | char **commentp) | |
e4340be5 DM |
207 | { |
208 | FILE *f; | |
7f906352 | 209 | char *line = NULL, *cp; |
210 | size_t linesize = 0; | |
8668706d | 211 | int r; |
d01f3930 | 212 | struct sshkey *k = NULL; |
e4340be5 | 213 | |
1d270bd3 | 214 | if (kp == NULL) |
215 | return SSH_ERR_INVALID_ARGUMENT; | |
d01f3930 | 216 | *kp = NULL; |
8668706d DM |
217 | if (commentp != NULL) |
218 | *commentp = NULL; | |
219 | if ((f = fopen(filename, "r")) == NULL) | |
220 | return SSH_ERR_SYSTEM_ERROR; | |
d01f3930 | 221 | if ((k = sshkey_new(KEY_UNSPEC)) == NULL) { |
222 | fclose(f); | |
223 | return SSH_ERR_ALLOC_FAIL; | |
224 | } | |
7f906352 | 225 | while (getline(&line, &linesize, f) != -1) { |
8668706d DM |
226 | cp = line; |
227 | switch (*cp) { | |
228 | case '#': | |
229 | case '\n': | |
230 | case '\0': | |
231 | continue; | |
232 | } | |
233 | /* Abort loading if this looks like a private key */ | |
234 | if (strncmp(cp, "-----BEGIN", 10) == 0 || | |
235 | strcmp(cp, "SSH PRIVATE KEY FILE") == 0) | |
236 | break; | |
237 | /* Skip leading whitespace. */ | |
238 | for (; *cp && (*cp == ' ' || *cp == '\t'); cp++) | |
239 | ; | |
240 | if (*cp) { | |
241 | if ((r = sshkey_read(k, &cp)) == 0) { | |
242 | cp[strcspn(cp, "\r\n")] = '\0'; | |
243 | if (commentp) { | |
244 | *commentp = strdup(*cp ? | |
245 | cp : filename); | |
246 | if (*commentp == NULL) | |
247 | r = SSH_ERR_ALLOC_FAIL; | |
e4340be5 | 248 | } |
d01f3930 | 249 | /* success */ |
250 | *kp = k; | |
7f906352 | 251 | free(line); |
8668706d DM |
252 | fclose(f); |
253 | return r; | |
e4340be5 DM |
254 | } |
255 | } | |
e4340be5 | 256 | } |
d01f3930 | 257 | free(k); |
7f906352 | 258 | free(line); |
8668706d DM |
259 | fclose(f); |
260 | return SSH_ERR_INVALID_FORMAT; | |
e4340be5 DM |
261 | } |
262 | ||
afbfa68f | 263 | /* load public key from any pubkey file */ |
8668706d DM |
264 | int |
265 | sshkey_load_public(const char *filename, struct sshkey **keyp, char **commentp) | |
e4340be5 | 266 | { |
d01f3930 | 267 | char *pubfile = NULL; |
c514f3c0 | 268 | int r, oerrno; |
8668706d DM |
269 | |
270 | if (keyp != NULL) | |
271 | *keyp = NULL; | |
272 | if (commentp != NULL) | |
273 | *commentp = NULL; | |
d0fca423 | 274 | |
d01f3930 | 275 | if ((r = sshkey_try_load_public(keyp, filename, commentp)) == 0) |
afbfa68f | 276 | goto out; |
db274725 | 277 | |
8668706d | 278 | /* try .pub suffix */ |
d01f3930 | 279 | if (asprintf(&pubfile, "%s.pub", filename) == -1) |
8668706d | 280 | return SSH_ERR_ALLOC_FAIL; |
d01f3930 | 281 | if ((r = sshkey_try_load_public(keyp, pubfile, commentp)) == 0) |
afbfa68f | 282 | goto out; |
d01f3930 | 283 | |
2b13d393 | 284 | /* finally, try to extract public key from private key file */ |
285 | if ((r = sshkey_load_pubkey_from_private(filename, keyp)) == 0) | |
286 | goto out; | |
287 | ||
c514f3c0 | 288 | /* Pretend we couldn't find the key */ |
289 | r = SSH_ERR_SYSTEM_ERROR; | |
290 | errno = ENOENT; | |
291 | ||
afbfa68f | 292 | out: |
c514f3c0 | 293 | oerrno = errno; |
d01f3930 | 294 | free(pubfile); |
c514f3c0 | 295 | errno = oerrno; |
8668706d | 296 | return r; |
e4340be5 | 297 | } |
1aed65eb | 298 | |
c158331f | 299 | /* Load the certificate associated with the named private key */ |
8668706d DM |
300 | int |
301 | sshkey_load_cert(const char *filename, struct sshkey **keyp) | |
c158331f | 302 | { |
8668706d DM |
303 | struct sshkey *pub = NULL; |
304 | char *file = NULL; | |
305 | int r = SSH_ERR_INTERNAL_ERROR; | |
c158331f | 306 | |
dce19bf6 | 307 | if (keyp != NULL) |
308 | *keyp = NULL; | |
8668706d DM |
309 | |
310 | if (asprintf(&file, "%s-cert.pub", filename) == -1) | |
311 | return SSH_ERR_ALLOC_FAIL; | |
312 | ||
d01f3930 | 313 | r = sshkey_try_load_public(keyp, file, NULL); |
d59ce088 | 314 | free(file); |
89540b6d | 315 | sshkey_free(pub); |
8668706d | 316 | return r; |
c158331f DM |
317 | } |
318 | ||
319 | /* Load private key and certificate */ | |
8668706d DM |
320 | int |
321 | sshkey_load_private_cert(int type, const char *filename, const char *passphrase, | |
6b39a7b4 | 322 | struct sshkey **keyp) |
c158331f | 323 | { |
8668706d DM |
324 | struct sshkey *key = NULL, *cert = NULL; |
325 | int r; | |
326 | ||
dce19bf6 | 327 | if (keyp != NULL) |
328 | *keyp = NULL; | |
c158331f DM |
329 | |
330 | switch (type) { | |
1f0311c7 | 331 | #ifdef WITH_OPENSSL |
c158331f DM |
332 | case KEY_RSA: |
333 | case KEY_DSA: | |
eb8b60e3 | 334 | case KEY_ECDSA: |
8668706d | 335 | #endif /* WITH_OPENSSL */ |
16db0a7e | 336 | case KEY_ED25519: |
1b11ea7c | 337 | case KEY_XMSS: |
8668706d | 338 | case KEY_UNSPEC: |
c158331f DM |
339 | break; |
340 | default: | |
8668706d | 341 | return SSH_ERR_KEY_TYPE_UNKNOWN; |
c158331f DM |
342 | } |
343 | ||
8668706d | 344 | if ((r = sshkey_load_private_type(type, filename, |
6b39a7b4 | 345 | passphrase, &key, NULL)) != 0 || |
8668706d DM |
346 | (r = sshkey_load_cert(filename, &cert)) != 0) |
347 | goto out; | |
c158331f DM |
348 | |
349 | /* Make sure the private key matches the certificate */ | |
8668706d DM |
350 | if (sshkey_equal_public(key, cert) == 0) { |
351 | r = SSH_ERR_KEY_CERT_MISMATCH; | |
352 | goto out; | |
c158331f DM |
353 | } |
354 | ||
c28fc62d | 355 | if ((r = sshkey_to_certified(key)) != 0 || |
8668706d DM |
356 | (r = sshkey_cert_copy(cert, key)) != 0) |
357 | goto out; | |
358 | r = 0; | |
dce19bf6 | 359 | if (keyp != NULL) { |
360 | *keyp = key; | |
361 | key = NULL; | |
362 | } | |
8668706d | 363 | out: |
89540b6d | 364 | sshkey_free(key); |
365 | sshkey_free(cert); | |
8668706d | 366 | return r; |
c158331f DM |
367 | } |
368 | ||
1aed65eb | 369 | /* |
8668706d DM |
370 | * Returns success if the specified "key" is listed in the file "filename", |
371 | * SSH_ERR_KEY_NOT_FOUND: if the key is not listed or another error. | |
5e39a499 | 372 | * If "strict_type" is set then the key type must match exactly, |
cb885178 | 373 | * otherwise a comparison that ignores certificate data is performed. |
5e39a499 | 374 | * If "check_ca" is set and "key" is a certificate, then its CA key is |
375 | * also checked and sshkey_in_file() will return success if either is found. | |
1aed65eb DM |
376 | */ |
377 | int | |
5e39a499 | 378 | sshkey_in_file(struct sshkey *key, const char *filename, int strict_type, |
379 | int check_ca) | |
1aed65eb DM |
380 | { |
381 | FILE *f; | |
7f906352 | 382 | char *line = NULL, *cp; |
383 | size_t linesize = 0; | |
8668706d DM |
384 | int r = 0; |
385 | struct sshkey *pub = NULL; | |
7f906352 | 386 | |
8668706d DM |
387 | int (*sshkey_compare)(const struct sshkey *, const struct sshkey *) = |
388 | strict_type ? sshkey_equal : sshkey_equal_public; | |
1aed65eb | 389 | |
5e39a499 | 390 | if ((f = fopen(filename, "r")) == NULL) |
391 | return SSH_ERR_SYSTEM_ERROR; | |
1aed65eb | 392 | |
7f906352 | 393 | while (getline(&line, &linesize, f) != -1) { |
bbc8af72 | 394 | sshkey_free(pub); |
395 | pub = NULL; | |
1aed65eb DM |
396 | cp = line; |
397 | ||
398 | /* Skip leading whitespace. */ | |
399 | for (; *cp && (*cp == ' ' || *cp == '\t'); cp++) | |
400 | ; | |
401 | ||
402 | /* Skip comments and empty lines */ | |
403 | switch (*cp) { | |
404 | case '#': | |
405 | case '\n': | |
406 | case '\0': | |
407 | continue; | |
408 | } | |
409 | ||
8668706d DM |
410 | if ((pub = sshkey_new(KEY_UNSPEC)) == NULL) { |
411 | r = SSH_ERR_ALLOC_FAIL; | |
412 | goto out; | |
1aed65eb | 413 | } |
bbc8af72 | 414 | switch (r = sshkey_read(pub, &cp)) { |
415 | case 0: | |
416 | break; | |
417 | case SSH_ERR_KEY_LENGTH: | |
418 | continue; | |
419 | default: | |
8668706d | 420 | goto out; |
bbc8af72 | 421 | } |
5e39a499 | 422 | if (sshkey_compare(key, pub) || |
423 | (check_ca && sshkey_is_cert(key) && | |
424 | sshkey_compare(key->cert->signature_key, pub))) { | |
8668706d DM |
425 | r = 0; |
426 | goto out; | |
1aed65eb | 427 | } |
1aed65eb | 428 | } |
8668706d DM |
429 | r = SSH_ERR_KEY_NOT_FOUND; |
430 | out: | |
7f906352 | 431 | free(line); |
89540b6d | 432 | sshkey_free(pub); |
1aed65eb | 433 | fclose(f); |
8668706d | 434 | return r; |
1aed65eb | 435 | } |
8668706d | 436 | |
5e39a499 | 437 | /* |
438 | * Checks whether the specified key is revoked, returning 0 if not, | |
439 | * SSH_ERR_KEY_REVOKED if it is or another error code if something | |
440 | * unexpected happened. | |
441 | * This will check both the key and, if it is a certificate, its CA key too. | |
442 | * "revoked_keys_file" may be a KRL or a one-per-line list of public keys. | |
443 | */ | |
444 | int | |
445 | sshkey_check_revoked(struct sshkey *key, const char *revoked_keys_file) | |
446 | { | |
447 | int r; | |
448 | ||
5e39a499 | 449 | r = ssh_krl_file_contains_key(revoked_keys_file, key); |
450 | /* If this was not a KRL to begin with then continue below */ | |
451 | if (r != SSH_ERR_KRL_BAD_MAGIC) | |
452 | return r; | |
5e39a499 | 453 | |
454 | /* | |
455 | * If the file is not a KRL or we can't handle KRLs then attempt to | |
456 | * parse the file as a flat list of keys. | |
457 | */ | |
458 | switch ((r = sshkey_in_file(key, revoked_keys_file, 0, 1))) { | |
459 | case 0: | |
460 | /* Key found => revoked */ | |
461 | return SSH_ERR_KEY_REVOKED; | |
462 | case SSH_ERR_KEY_NOT_FOUND: | |
463 | /* Key not found => not revoked */ | |
464 | return 0; | |
465 | default: | |
466 | /* Some other error occurred */ | |
467 | return r; | |
468 | } | |
469 | } | |
470 | ||
dd8002fb | 471 | /* |
472 | * Advanced *cpp past the end of key options, defined as the first unquoted | |
473 | * whitespace character. Returns 0 on success or -1 on failure (e.g. | |
474 | * unterminated quotes). | |
475 | */ | |
476 | int | |
477 | sshkey_advance_past_options(char **cpp) | |
478 | { | |
479 | char *cp = *cpp; | |
480 | int quoted = 0; | |
481 | ||
482 | for (; *cp && (quoted || (*cp != ' ' && *cp != '\t')); cp++) { | |
483 | if (*cp == '\\' && cp[1] == '"') | |
484 | cp++; /* Skip both */ | |
485 | else if (*cp == '"') | |
486 | quoted = !quoted; | |
487 | } | |
488 | *cpp = cp; | |
489 | /* return failure for unterminated quotes */ | |
490 | return (*cp == '\0' && quoted) ? -1 : 0; | |
491 | } | |
492 | ||
878ba435 | 493 | /* Save a public key */ |
494 | int | |
495 | sshkey_save_public(const struct sshkey *key, const char *path, | |
496 | const char *comment) | |
497 | { | |
498 | int fd, oerrno; | |
499 | FILE *f = NULL; | |
500 | int r = SSH_ERR_INTERNAL_ERROR; | |
501 | ||
502 | if ((fd = open(path, O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1) | |
503 | return SSH_ERR_SYSTEM_ERROR; | |
504 | if ((f = fdopen(fd, "w")) == NULL) { | |
505 | r = SSH_ERR_SYSTEM_ERROR; | |
17904f05 | 506 | close(fd); |
878ba435 | 507 | goto fail; |
508 | } | |
509 | if ((r = sshkey_write(key, f)) != 0) | |
510 | goto fail; | |
511 | fprintf(f, " %s\n", comment); | |
17904f05 | 512 | if (ferror(f)) { |
878ba435 | 513 | r = SSH_ERR_SYSTEM_ERROR; |
17904f05 | 514 | goto fail; |
515 | } | |
516 | if (fclose(f) != 0) { | |
517 | r = SSH_ERR_SYSTEM_ERROR; | |
518 | f = NULL; | |
878ba435 | 519 | fail: |
17904f05 | 520 | if (f != NULL) { |
521 | oerrno = errno; | |
878ba435 | 522 | fclose(f); |
17904f05 | 523 | errno = oerrno; |
524 | } | |
878ba435 | 525 | return r; |
526 | } | |
527 | return 0; | |
528 | } |