?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel - Restore ability to thaw checkpoints
[dragonfly.git] / crypto / openssh / servconf.c
blob19253a8881cfe102587b98b7aacf0491d7ebb547
1 /* $OpenBSD: servconf.c,v 1.195 2009/04/14 21:10:54 jj Exp $ */
2 /*
3 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
4 * All rights reserved
5 *
6 * As far as I am concerned, the code I have written for this software
7 * can be used freely for any purpose. Any derived versions of this
8 * software must be clearly marked as such, and if the derived work is
9 * incompatible with the protocol description in the RFC file, it must be
10 * called by a name other than "ssh" or "Secure Shell".
11 */
12
13 #include "includes.h"
14
15 #include <sys/types.h>
16 #include <sys/socket.h>
17
18 #include <netdb.h>
19 #include <pwd.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <signal.h>
24 #include <unistd.h>
25 #include <stdarg.h>
26 #include <errno.h>
27
28 #include "openbsd-compat/sys-queue.h"
29 #include "xmalloc.h"
30 #include "ssh.h"
31 #include "log.h"
32 #include "buffer.h"
33 #include "servconf.h"
34 #include "compat.h"
35 #include "pathnames.h"
36 #include "misc.h"
37 #include "cipher.h"
38 #include "key.h"
39 #include "kex.h"
40 #include "mac.h"
41 #include "match.h"
42 #include "channels.h"
43 #include "groupaccess.h"
44 #include "version.h"
45
46 static void add_listen_addr(ServerOptions *, char *, int);
47 static void add_one_listen_addr(ServerOptions *, char *, int);
48
49 /* Use of privilege separation or not */
50 extern int use_privsep;
51 extern Buffer cfg;
52
53 /* Initializes the server options to their default values. */
54
55 void
56 initialize_server_options(ServerOptions *options)
57 {
58 memset(options, 0, sizeof(*options));
59
60 /* Portable-specific options */
61 options->use_pam = -1;
62
63 /* Standard Options */
64 options->num_ports = 0;
65 options->ports_from_cmdline = 0;
66 options->listen_addrs = NULL;
67 options->address_family = -1;
68 options->num_host_key_files = 0;
69 options->pid_file = NULL;
70 options->server_key_bits = -1;
71 options->login_grace_time = -1;
72 options->key_regeneration_time = -1;
73 options->permit_root_login = PERMIT_NOT_SET;
74 options->ignore_rhosts = -1;
75 options->ignore_user_known_hosts = -1;
76 options->print_motd = -1;
77 options->print_lastlog = -1;
78 options->x11_forwarding = -1;
79 options->x11_display_offset = -1;
80 options->x11_use_localhost = -1;
81 options->xauth_location = NULL;
82 options->strict_modes = -1;
83 options->tcp_keep_alive = -1;
84 options->log_facility = SYSLOG_FACILITY_NOT_SET;
85 options->log_level = SYSLOG_LEVEL_NOT_SET;
86 options->rhosts_rsa_authentication = -1;
87 options->hostbased_authentication = -1;
88 options->hostbased_uses_name_from_packet_only = -1;
89 options->rsa_authentication = -1;
90 options->pubkey_authentication = -1;
91 options->kerberos_authentication = -1;
92 options->kerberos_or_local_passwd = -1;
93 options->kerberos_ticket_cleanup = -1;
94 options->kerberos_get_afs_token = -1;
95 options->gss_authentication=-1;
96 options->gss_cleanup_creds = -1;
97 options->password_authentication = -1;
98 options->kbd_interactive_authentication = -1;
99 options->challenge_response_authentication = -1;
100 options->permit_blacklisted_keys = -1;
101 options->permit_empty_passwd = -1;
102 options->permit_user_env = -1;
103 options->use_login = -1;
104 options->compression = -1;
105 options->allow_tcp_forwarding = -1;
106 options->allow_agent_forwarding = -1;
107 options->num_allow_users = 0;
108 options->num_deny_users = 0;
109 options->num_allow_groups = 0;
110 options->num_deny_groups = 0;
111 options->ciphers = NULL;
112 options->macs = NULL;
113 options->protocol = SSH_PROTO_UNKNOWN;
114 options->gateway_ports = -1;
115 options->num_subsystems = 0;
116 options->max_startups_begin = -1;
117 options->max_startups_rate = -1;
118 options->max_startups = -1;
119 options->max_authtries = -1;
120 options->max_sessions = -1;
121 options->banner = NULL;
122 options->use_dns = -1;
123 options->client_alive_interval = -1;
124 options->client_alive_count_max = -1;
125 options->authorized_keys_file = NULL;
126 options->authorized_keys_file2 = NULL;
127 options->num_accept_env = 0;
128 options->permit_tun = -1;
129 options->num_permitted_opens = -1;
130 options->adm_forced_command = NULL;
131 options->chroot_directory = NULL;
132 options->zero_knowledge_password_authentication = -1;
133 options->none_enabled = -1;
134 options->tcp_rcv_buf_poll = -1;
135 options->hpn_disabled = -1;
136 options->hpn_buffer_size = -1;
137 }
138
139 void
140 fill_default_server_options(ServerOptions *options)
141 {
142 /* needed for hpn socket tests */
143 int sock;
144 int socksize;
145 int socksizelen = sizeof(int);
146
147 /* Portable-specific options */
148 if (options->use_pam == -1)
149 options->use_pam = 0;
150
151 /* Standard Options */
152 if (options->protocol == SSH_PROTO_UNKNOWN)
153 options->protocol = SSH_PROTO_2;
154 if (options->num_host_key_files == 0) {
155 /* fill default hostkeys for protocols */
156 if (options->protocol & SSH_PROTO_1)
157 options->host_key_files[options->num_host_key_files++] =
158 _PATH_HOST_KEY_FILE;
159 if (options->protocol & SSH_PROTO_2) {
160 options->host_key_files[options->num_host_key_files++] =
161 _PATH_HOST_RSA_KEY_FILE;
162 options->host_key_files[options->num_host_key_files++] =
163 _PATH_HOST_DSA_KEY_FILE;
164 }
165 }
166 if (options->num_ports == 0)
167 options->ports[options->num_ports++] = SSH_DEFAULT_PORT;
168 if (options->listen_addrs == NULL)
169 add_listen_addr(options, NULL, 0);
170 if (options->pid_file == NULL)
171 options->pid_file = _PATH_SSH_DAEMON_PID_FILE;
172 if (options->server_key_bits == -1)
173 options->server_key_bits = 1024;
174 if (options->login_grace_time == -1)
175 options->login_grace_time = 120;
176 if (options->key_regeneration_time == -1)
177 options->key_regeneration_time = 3600;
178 if (options->permit_root_login == PERMIT_NOT_SET)
179 options->permit_root_login = PERMIT_NO;
180 if (options->ignore_rhosts == -1)
181 options->ignore_rhosts = 1;
182 if (options->ignore_user_known_hosts == -1)
183 options->ignore_user_known_hosts = 0;
184 if (options->print_motd == -1)
185 options->print_motd = 1;
186 if (options->print_lastlog == -1)
187 options->print_lastlog = 1;
188 if (options->x11_forwarding == -1)
189 options->x11_forwarding = 1;
190 if (options->x11_display_offset == -1)
191 options->x11_display_offset = 10;
192 if (options->x11_use_localhost == -1)
193 options->x11_use_localhost = 1;
194 if (options->xauth_location == NULL)
195 options->xauth_location = _PATH_XAUTH;
196 if (options->strict_modes == -1)
197 options->strict_modes = 1;
198 if (options->tcp_keep_alive == -1)
199 options->tcp_keep_alive = 1;
200 if (options->log_facility == SYSLOG_FACILITY_NOT_SET)
201 options->log_facility = SYSLOG_FACILITY_AUTH;
202 if (options->log_level == SYSLOG_LEVEL_NOT_SET)
203 options->log_level = SYSLOG_LEVEL_INFO;
204 if (options->rhosts_rsa_authentication == -1)
205 options->rhosts_rsa_authentication = 0;
206 if (options->hostbased_authentication == -1)
207 options->hostbased_authentication = 0;
208 if (options->hostbased_uses_name_from_packet_only == -1)
209 options->hostbased_uses_name_from_packet_only = 0;
210 if (options->rsa_authentication == -1)
211 options->rsa_authentication = 1;
212 if (options->pubkey_authentication == -1)
213 options->pubkey_authentication = 1;
214 if (options->kerberos_authentication == -1)
215 options->kerberos_authentication = 0;
216 if (options->kerberos_or_local_passwd == -1)
217 options->kerberos_or_local_passwd = 1;
218 if (options->kerberos_ticket_cleanup == -1)
219 options->kerberos_ticket_cleanup = 1;
220 if (options->kerberos_get_afs_token == -1)
221 options->kerberos_get_afs_token = 0;
222 if (options->gss_authentication == -1)
223 options->gss_authentication = 0;
224 if (options->gss_cleanup_creds == -1)
225 options->gss_cleanup_creds = 1;
226 if (options->password_authentication == -1)
227 options->password_authentication = 1;
228 if (options->kbd_interactive_authentication == -1)
229 options->kbd_interactive_authentication = 0;
230 if (options->challenge_response_authentication == -1)
231 options->challenge_response_authentication = 1;
232 if (options->permit_blacklisted_keys == -1)
233 options->permit_blacklisted_keys = 0;
234 if (options->permit_empty_passwd == -1)
235 options->permit_empty_passwd = 0;
236 if (options->permit_user_env == -1)
237 options->permit_user_env = 0;
238 if (options->use_login == -1)
239 options->use_login = 0;
240 if (options->compression == -1)
241 options->compression = COMP_DELAYED;
242 if (options->allow_tcp_forwarding == -1)
243 options->allow_tcp_forwarding = 1;
244 if (options->allow_agent_forwarding == -1)
245 options->allow_agent_forwarding = 1;
246 if (options->gateway_ports == -1)
247 options->gateway_ports = 0;
248 if (options->max_startups == -1)
249 options->max_startups = 10;
250 if (options->max_startups_rate == -1)
251 options->max_startups_rate = 100; /* 100% */
252 if (options->max_startups_begin == -1)
253 options->max_startups_begin = options->max_startups;
254 if (options->max_authtries == -1)
255 options->max_authtries = DEFAULT_AUTH_FAIL_MAX;
256 if (options->max_sessions == -1)
257 options->max_sessions = DEFAULT_SESSIONS_MAX;
258 if (options->use_dns == -1)
259 options->use_dns = 1;
260 if (options->client_alive_interval == -1)
261 options->client_alive_interval = 0;
262 if (options->client_alive_count_max == -1)
263 options->client_alive_count_max = 3;
264 if (options->authorized_keys_file2 == NULL) {
265 /* authorized_keys_file2 falls back to authorized_keys_file */
266 if (options->authorized_keys_file != NULL)
267 options->authorized_keys_file2 = options->authorized_keys_file;
268 else
269 options->authorized_keys_file2 = _PATH_SSH_USER_PERMITTED_KEYS2;
270 }
271 if (options->authorized_keys_file == NULL)
272 options->authorized_keys_file = _PATH_SSH_USER_PERMITTED_KEYS;
273 if (options->permit_tun == -1)
274 options->permit_tun = SSH_TUNMODE_NO;
275 if (options->zero_knowledge_password_authentication == -1)
276 options->zero_knowledge_password_authentication = 0;
277
278 if (options->hpn_disabled == -1)
279 options->hpn_disabled = 0;
280
281 if (options->hpn_buffer_size == -1) {
282 /* option not explicitly set. Now we have to figure out */
283 /* what value to use */
284 if (options->hpn_disabled == 1) {
285 options->hpn_buffer_size = CHAN_SES_WINDOW_DEFAULT;
286 } else {
287 /* get the current RCV size and set it to that */
288 /*create a socket but don't connect it */
289 /* we use that the get the rcv socket size */
290 sock = socket(AF_INET, SOCK_STREAM, 0);
291 getsockopt(sock, SOL_SOCKET, SO_RCVBUF,
292 &socksize, &socksizelen);
293 close(sock);
294 options->hpn_buffer_size = socksize;
295 debug ("HPN Buffer Size: %d", options->hpn_buffer_size);
296
297 }
298 } else {
299 /* we have to do this incase the user sets both values in a contradictory */
300 /* manner. hpn_disabled overrrides hpn_buffer_size*/
301 if (options->hpn_disabled <= 0) {
302 if (options->hpn_buffer_size == 0)
303 options->hpn_buffer_size = 1;
304 /* limit the maximum buffer to 64MB */
305 if (options->hpn_buffer_size > 64*1024) {
306 options->hpn_buffer_size = 64*1024*1024;
307 } else {
308 options->hpn_buffer_size *= 1024;
309 }
310 } else
311 options->hpn_buffer_size = CHAN_TCP_WINDOW_DEFAULT;
312 }
313
314 /* Turn privilege separation on by default */
315 if (use_privsep == -1)
316 use_privsep = 1;
317
318 #ifndef HAVE_MMAP
319 if (use_privsep && options->compression == 1) {
320 error("This platform does not support both privilege "
321 "separation and compression");
322 error("Compression disabled");
323 options->compression = 0;
324 }
325 #endif
326
327 }
328
329 /* Keyword tokens. */
330 typedef enum {
331 sBadOption, /* == unknown option */
332 /* Portable-specific options */
333 sUsePAM,
334 /* Standard Options */
335 sPort, sHostKeyFile, sServerKeyBits, sLoginGraceTime, sKeyRegenerationTime,
336 sPermitRootLogin, sLogFacility, sLogLevel,
337 sRhostsRSAAuthentication, sRSAAuthentication,
338 sKerberosAuthentication, sKerberosOrLocalPasswd, sKerberosTicketCleanup,
339 sKerberosGetAFSToken,
340 sKerberosTgtPassing, sChallengeResponseAuthentication,
341 sPasswordAuthentication, sKbdInteractiveAuthentication,
342 sListenAddress, sAddressFamily,
343 sPrintMotd, sPrintLastLog, sIgnoreRhosts,
344 sX11Forwarding, sX11DisplayOffset, sX11UseLocalhost,
345 sStrictModes, sPermitBlacklistedKeys, sEmptyPasswd, sTCPKeepAlive,
346 sPermitUserEnvironment, sUseLogin, sAllowTcpForwarding, sCompression,
347 sAllowUsers, sDenyUsers, sAllowGroups, sDenyGroups,
348 sIgnoreUserKnownHosts, sCiphers, sMacs, sProtocol, sPidFile,
349 sGatewayPorts, sPubkeyAuthentication, sXAuthLocation, sSubsystem,
350 sMaxStartups, sMaxAuthTries, sMaxSessions,
351 sBanner, sUseDNS, sHostbasedAuthentication,
352 sHostbasedUsesNameFromPacketOnly, sClientAliveInterval,
353 sClientAliveCountMax, sAuthorizedKeysFile, sAuthorizedKeysFile2,
354 sGssAuthentication, sGssCleanupCreds, sAcceptEnv, sPermitTunnel,
355 sMatch, sPermitOpen, sForceCommand, sChrootDirectory,
356 sUsePrivilegeSeparation, sAllowAgentForwarding,
357 sZeroKnowledgePasswordAuthentication,
358 sNoneEnabled, sTcpRcvBufPoll, sHPNDisabled, sHPNBufferSize,
359 sVersionAddendum,
360 sDeprecated, sUnsupported
361 } ServerOpCodes;
362
363 #define SSHCFG_GLOBAL 0x01 /* allowed in main section of sshd_config */
364 #define SSHCFG_MATCH 0x02 /* allowed inside a Match section */
365 #define SSHCFG_ALL (SSHCFG_GLOBAL|SSHCFG_MATCH)
366
367 /* Textual representation of the tokens. */
368 static struct {
369 const char *name;
370 ServerOpCodes opcode;
371 u_int flags;
372 } keywords[] = {
373 /* Portable-specific options */
374 #ifdef USE_PAM
375 { "usepam", sUsePAM, SSHCFG_GLOBAL },
376 #else
377 { "usepam", sUnsupported, SSHCFG_GLOBAL },
378 #endif
379 { "pamauthenticationviakbdint", sDeprecated, SSHCFG_GLOBAL },
380 /* Standard Options */
381 { "port", sPort, SSHCFG_GLOBAL },
382 { "hostkey", sHostKeyFile, SSHCFG_GLOBAL },
383 { "hostdsakey", sHostKeyFile, SSHCFG_GLOBAL }, /* alias */
384 { "pidfile", sPidFile, SSHCFG_GLOBAL },
385 { "serverkeybits", sServerKeyBits, SSHCFG_GLOBAL },
386 { "logingracetime", sLoginGraceTime, SSHCFG_GLOBAL },
387 { "keyregenerationinterval", sKeyRegenerationTime, SSHCFG_GLOBAL },
388 { "permitrootlogin", sPermitRootLogin, SSHCFG_ALL },
389 { "syslogfacility", sLogFacility, SSHCFG_GLOBAL },
390 { "loglevel", sLogLevel, SSHCFG_GLOBAL },
391 { "rhostsauthentication", sDeprecated, SSHCFG_GLOBAL },
392 { "rhostsrsaauthentication", sRhostsRSAAuthentication, SSHCFG_ALL },
393 { "hostbasedauthentication", sHostbasedAuthentication, SSHCFG_ALL },
394 { "hostbasedusesnamefrompacketonly", sHostbasedUsesNameFromPacketOnly, SSHCFG_GLOBAL },
395 { "rsaauthentication", sRSAAuthentication, SSHCFG_ALL },
396 { "pubkeyauthentication", sPubkeyAuthentication, SSHCFG_ALL },
397 { "dsaauthentication", sPubkeyAuthentication, SSHCFG_GLOBAL }, /* alias */
398 #ifdef KRB5
399 { "kerberosauthentication", sKerberosAuthentication, SSHCFG_ALL },
400 { "kerberosorlocalpasswd", sKerberosOrLocalPasswd, SSHCFG_GLOBAL },
401 { "kerberosticketcleanup", sKerberosTicketCleanup, SSHCFG_GLOBAL },
402 #ifdef USE_AFS
403 { "kerberosgetafstoken", sKerberosGetAFSToken, SSHCFG_GLOBAL },
404 #else
405 { "kerberosgetafstoken", sUnsupported, SSHCFG_GLOBAL },
406 #endif
407 #else
408 { "kerberosauthentication", sUnsupported, SSHCFG_ALL },
409 { "kerberosorlocalpasswd", sUnsupported, SSHCFG_GLOBAL },
410 { "kerberosticketcleanup", sUnsupported, SSHCFG_GLOBAL },
411 { "kerberosgetafstoken", sUnsupported, SSHCFG_GLOBAL },
412 #endif
413 { "kerberostgtpassing", sUnsupported, SSHCFG_GLOBAL },
414 { "afstokenpassing", sUnsupported, SSHCFG_GLOBAL },
415 #ifdef GSSAPI
416 { "gssapiauthentication", sGssAuthentication, SSHCFG_ALL },
417 { "gssapicleanupcredentials", sGssCleanupCreds, SSHCFG_GLOBAL },
418 #else
419 { "gssapiauthentication", sUnsupported, SSHCFG_ALL },
420 { "gssapicleanupcredentials", sUnsupported, SSHCFG_GLOBAL },
421 #endif
422 { "passwordauthentication", sPasswordAuthentication, SSHCFG_ALL },
423 { "kbdinteractiveauthentication", sKbdInteractiveAuthentication, SSHCFG_ALL },
424 { "challengeresponseauthentication", sChallengeResponseAuthentication, SSHCFG_GLOBAL },
425 { "skeyauthentication", sChallengeResponseAuthentication, SSHCFG_GLOBAL }, /* alias */
426 #ifdef JPAKE
427 { "zeroknowledgepasswordauthentication", sZeroKnowledgePasswordAuthentication, SSHCFG_ALL },
428 #else
429 { "zeroknowledgepasswordauthentication", sUnsupported, SSHCFG_ALL },
430 #endif
431 { "checkmail", sDeprecated, SSHCFG_GLOBAL },
432 { "listenaddress", sListenAddress, SSHCFG_GLOBAL },
433 { "addressfamily", sAddressFamily, SSHCFG_GLOBAL },
434 { "printmotd", sPrintMotd, SSHCFG_GLOBAL },
435 { "printlastlog", sPrintLastLog, SSHCFG_GLOBAL },
436 { "ignorerhosts", sIgnoreRhosts, SSHCFG_GLOBAL },
437 { "ignoreuserknownhosts", sIgnoreUserKnownHosts, SSHCFG_GLOBAL },
438 { "x11forwarding", sX11Forwarding, SSHCFG_ALL },
439 { "x11displayoffset", sX11DisplayOffset, SSHCFG_ALL },
440 { "x11uselocalhost", sX11UseLocalhost, SSHCFG_ALL },
441 { "xauthlocation", sXAuthLocation, SSHCFG_GLOBAL },
442 { "strictmodes", sStrictModes, SSHCFG_GLOBAL },
443 { "permitblacklistedkeys", sPermitBlacklistedKeys, SSHCFG_GLOBAL },
444 { "permitemptypasswords", sEmptyPasswd, SSHCFG_ALL },
445 { "permituserenvironment", sPermitUserEnvironment, SSHCFG_GLOBAL },
446 { "uselogin", sUseLogin, SSHCFG_GLOBAL },
447 { "compression", sCompression, SSHCFG_GLOBAL },
448 { "tcpkeepalive", sTCPKeepAlive, SSHCFG_GLOBAL },
449 { "keepalive", sTCPKeepAlive, SSHCFG_GLOBAL }, /* obsolete alias */
450 { "allowtcpforwarding", sAllowTcpForwarding, SSHCFG_ALL },
451 { "allowagentforwarding", sAllowAgentForwarding, SSHCFG_ALL },
452 { "allowusers", sAllowUsers, SSHCFG_GLOBAL },
453 { "denyusers", sDenyUsers, SSHCFG_GLOBAL },
454 { "allowgroups", sAllowGroups, SSHCFG_GLOBAL },
455 { "denygroups", sDenyGroups, SSHCFG_GLOBAL },
456 { "ciphers", sCiphers, SSHCFG_GLOBAL },
457 { "macs", sMacs, SSHCFG_GLOBAL },
458 { "protocol", sProtocol, SSHCFG_GLOBAL },
459 { "gatewayports", sGatewayPorts, SSHCFG_ALL },
460 { "subsystem", sSubsystem, SSHCFG_GLOBAL },
461 { "maxstartups", sMaxStartups, SSHCFG_GLOBAL },
462 { "maxauthtries", sMaxAuthTries, SSHCFG_ALL },
463 { "maxsessions", sMaxSessions, SSHCFG_ALL },
464 { "banner", sBanner, SSHCFG_ALL },
465 { "usedns", sUseDNS, SSHCFG_GLOBAL },
466 { "verifyreversemapping", sDeprecated, SSHCFG_GLOBAL },
467 { "reversemappingcheck", sDeprecated, SSHCFG_GLOBAL },
468 { "clientaliveinterval", sClientAliveInterval, SSHCFG_GLOBAL },
469 { "clientalivecountmax", sClientAliveCountMax, SSHCFG_GLOBAL },
470 { "authorizedkeysfile", sAuthorizedKeysFile, SSHCFG_GLOBAL },
471 { "authorizedkeysfile2", sAuthorizedKeysFile2, SSHCFG_GLOBAL },
472 { "useprivilegeseparation", sUsePrivilegeSeparation, SSHCFG_GLOBAL },
473 { "versionaddendum", sVersionAddendum , SSHCFG_GLOBAL },
474 { "acceptenv", sAcceptEnv, SSHCFG_GLOBAL },
475 { "permittunnel", sPermitTunnel, SSHCFG_GLOBAL },
476 { "match", sMatch, SSHCFG_ALL },
477 { "permitopen", sPermitOpen, SSHCFG_ALL },
478 { "forcecommand", sForceCommand, SSHCFG_ALL },
479 { "chrootdirectory", sChrootDirectory, SSHCFG_ALL },
480 { "noneenabled", sNoneEnabled },
481 { "hpndisabled", sHPNDisabled },
482 { "hpnbuffersize", sHPNBufferSize },
483 { "tcprcvbufpoll", sTcpRcvBufPoll },
484 { NULL, sBadOption, 0 }
485 };
486
487 static struct {
488 int val;
489 char *text;
490 } tunmode_desc[] = {
491 { SSH_TUNMODE_NO, "no" },
492 { SSH_TUNMODE_POINTOPOINT, "point-to-point" },
493 { SSH_TUNMODE_ETHERNET, "ethernet" },
494 { SSH_TUNMODE_YES, "yes" },
495 { -1, NULL }
496 };
497
498 /*
499 * Returns the number of the token pointed to by cp or sBadOption.
500 */
501
502 static ServerOpCodes
503 parse_token(const char *cp, const char *filename,
504 int linenum, u_int *flags)
505 {
506 u_int i;
507
508 for (i = 0; keywords[i].name; i++)
509 if (strcasecmp(cp, keywords[i].name) == 0) {
510 debug ("Config token is %s", keywords[i].name);
511 *flags = keywords[i].flags;
512 return keywords[i].opcode;
513 }
514
515 error("%s: line %d: Bad configuration option: %s",
516 filename, linenum, cp);
517 return sBadOption;
518 }
519
520 static void
521 add_listen_addr(ServerOptions *options, char *addr, int port)
522 {
523 u_int i;
524
525 if (options->num_ports == 0)
526 options->ports[options->num_ports++] = SSH_DEFAULT_PORT;
527 if (options->address_family == -1)
528 options->address_family = AF_UNSPEC;
529 if (port == 0)
530 for (i = 0; i < options->num_ports; i++)
531 add_one_listen_addr(options, addr, options->ports[i]);
532 else
533 add_one_listen_addr(options, addr, port);
534 }
535
536 static void
537 add_one_listen_addr(ServerOptions *options, char *addr, int port)
538 {
539 struct addrinfo hints, *ai, *aitop;
540 char strport[NI_MAXSERV];
541 int gaierr;
542
543 memset(&hints, 0, sizeof(hints));
544 hints.ai_family = options->address_family;
545 hints.ai_socktype = SOCK_STREAM;
546 hints.ai_flags = (addr == NULL) ? AI_PASSIVE : 0;
547 snprintf(strport, sizeof strport, "%d", port);
548 if ((gaierr = getaddrinfo(addr, strport, &hints, &aitop)) != 0)
549 fatal("bad addr or host: %s (%s)",
550 addr ? addr : "<NULL>",
551 ssh_gai_strerror(gaierr));
552 for (ai = aitop; ai->ai_next; ai = ai->ai_next)
553 ;
554 ai->ai_next = options->listen_addrs;
555 options->listen_addrs = aitop;
556 }
557
558 /*
559 * The strategy for the Match blocks is that the config file is parsed twice.
560 *
561 * The first time is at startup. activep is initialized to 1 and the
562 * directives in the global context are processed and acted on. Hitting a
563 * Match directive unsets activep and the directives inside the block are
564 * checked for syntax only.
565 *
566 * The second time is after a connection has been established but before
567 * authentication. activep is initialized to 2 and global config directives
568 * are ignored since they have already been processed. If the criteria in a
569 * Match block is met, activep is set and the subsequent directives
570 * processed and actioned until EOF or another Match block unsets it. Any
571 * options set are copied into the main server config.
572 *
573 * Potential additions/improvements:
574 * - Add Match support for pre-kex directives, eg Protocol, Ciphers.
575 *
576 * - Add a Tag directive (idea from David Leonard) ala pf, eg:
577 * Match Address 192.168.0.*
578 * Tag trusted
579 * Match Group wheel
580 * Tag trusted
581 * Match Tag trusted
582 * AllowTcpForwarding yes
583 * GatewayPorts clientspecified
584 * [...]
585 *
586 * - Add a PermittedChannelRequests directive
587 * Match Group shell
588 * PermittedChannelRequests session,forwarded-tcpip
589 */
590
591 static int
592 match_cfg_line_group(const char *grps, int line, const char *user)
593 {
594 int result = 0;
595 struct passwd *pw;
596
597 if (user == NULL)
598 goto out;
599
600 if ((pw = getpwnam(user)) == NULL) {
601 debug("Can't match group at line %d because user %.100s does "
602 "not exist", line, user);
603 } else if (ga_init(pw->pw_name, pw->pw_gid) == 0) {
604 debug("Can't Match group because user %.100s not in any group "
605 "at line %d", user, line);
606 } else if (ga_match_pattern_list(grps) != 1) {
607 debug("user %.100s does not match group list %.100s at line %d",
608 user, grps, line);
609 } else {
610 debug("user %.100s matched group list %.100s at line %d", user,
611 grps, line);
612 result = 1;
613 }
614 out:
615 ga_free();
616 return result;
617 }
618
619 static int
620 match_cfg_line(char **condition, int line, const char *user, const char *host,
621 const char *address)
622 {
623 int result = 1;
624 char *arg, *attrib, *cp = *condition;
625 size_t len;
626
627 if (user == NULL)
628 debug3("checking syntax for 'Match %s'", cp);
629 else
630 debug3("checking match for '%s' user %s host %s addr %s", cp,
631 user ? user : "(null)", host ? host : "(null)",
632 address ? address : "(null)");
633
634 while ((attrib = strdelim(&cp)) && *attrib != '\0') {
635 if ((arg = strdelim(&cp)) == NULL || *arg == '\0') {
636 error("Missing Match criteria for %s", attrib);
637 return -1;
638 }
639 len = strlen(arg);
640 if (strcasecmp(attrib, "user") == 0) {
641 if (!user) {
642 result = 0;
643 continue;
644 }
645 if (match_pattern_list(user, arg, len, 0) != 1)
646 result = 0;
647 else
648 debug("user %.100s matched 'User %.100s' at "
649 "line %d", user, arg, line);
650 } else if (strcasecmp(attrib, "group") == 0) {
651 switch (match_cfg_line_group(arg, line, user)) {
652 case -1:
653 return -1;
654 case 0:
655 result = 0;
656 }
657 } else if (strcasecmp(attrib, "host") == 0) {
658 if (!host) {
659 result = 0;
660 continue;
661 }
662 if (match_hostname(host, arg, len) != 1)
663 result = 0;
664 else
665 debug("connection from %.100s matched 'Host "
666 "%.100s' at line %d", host, arg, line);
667 } else if (strcasecmp(attrib, "address") == 0) {
668 switch (addr_match_list(address, arg)) {
669 case 1:
670 debug("connection from %.100s matched 'Address "
671 "%.100s' at line %d", address, arg, line);
672 break;
673 case 0:
674 case -1:
675 result = 0;
676 break;
677 case -2:
678 return -1;
679 }
680 } else {
681 error("Unsupported Match attribute %s", attrib);
682 return -1;
683 }
684 }
685 if (user != NULL)
686 debug3("match %sfound", result ? "" : "not ");
687 *condition = cp;
688 return result;
689 }
690
691 #define WHITESPACE " \t\r\n"
692
693 int
694 process_server_config_line(ServerOptions *options, char *line,
695 const char *filename, int linenum, int *activep, const char *user,
696 const char *host, const char *address)
697 {
698 char *cp, **charptr, *arg, *p;
699 int cmdline = 0, *intptr, value, n;
700 SyslogFacility *log_facility_ptr;
701 LogLevel *log_level_ptr;
702 ServerOpCodes opcode;
703 int port;
704 u_int i, flags = 0;
705 size_t len;
706
707 cp = line;
708 if ((arg = strdelim(&cp)) == NULL)
709 return 0;
710 /* Ignore leading whitespace */
711 if (*arg == '\0')
712 arg = strdelim(&cp);
713 if (!arg || !*arg || *arg == '#')
714 return 0;
715 intptr = NULL;
716 charptr = NULL;
717 opcode = parse_token(arg, filename, linenum, &flags);
718
719 if (activep == NULL) { /* We are processing a command line directive */
720 cmdline = 1;
721 activep = &cmdline;
722 }
723 if (*activep && opcode != sMatch)
724 debug3("%s:%d setting %s %s", filename, linenum, arg, cp);
725 if (*activep == 0 && !(flags & SSHCFG_MATCH)) {
726 if (user == NULL) {
727 fatal("%s line %d: Directive '%s' is not allowed "
728 "within a Match block", filename, linenum, arg);
729 } else { /* this is a directive we have already processed */
730 while (arg)
731 arg = strdelim(&cp);
732 return 0;
733 }
734 }
735
736 switch (opcode) {
737 /* Portable-specific options */
738 case sUsePAM:
739 intptr = &options->use_pam;
740 goto parse_flag;
741
742 /* Standard Options */
743 case sBadOption:
744 return -1;
745 case sPort:
746 /* ignore ports from configfile if cmdline specifies ports */
747 if (options->ports_from_cmdline)
748 return 0;
749 if (options->listen_addrs != NULL)
750 fatal("%s line %d: ports must be specified before "
751 "ListenAddress.", filename, linenum);
752 if (options->num_ports >= MAX_PORTS)
753 fatal("%s line %d: too many ports.",
754 filename, linenum);
755 arg = strdelim(&cp);
756 if (!arg || *arg == '\0')
757 fatal("%s line %d: missing port number.",
758 filename, linenum);
759 options->ports[options->num_ports++] = a2port(arg);
760 if (options->ports[options->num_ports-1] <= 0)
761 fatal("%s line %d: Badly formatted port number.",
762 filename, linenum);
763 break;
764
765 case sServerKeyBits:
766 intptr = &options->server_key_bits;
767 parse_int:
768 arg = strdelim(&cp);
769 if (!arg || *arg == '\0')
770 fatal("%s line %d: missing integer value.",
771 filename, linenum);
772 value = atoi(arg);
773 if (*activep && *intptr == -1)
774 *intptr = value;
775 break;
776
777 case sLoginGraceTime:
778 intptr = &options->login_grace_time;
779 parse_time:
780 arg = strdelim(&cp);
781 if (!arg || *arg == '\0')
782 fatal("%s line %d: missing time value.",
783 filename, linenum);
784 if ((value = convtime(arg)) == -1)
785 fatal("%s line %d: invalid time value.",
786 filename, linenum);
787 if (*intptr == -1)
788 *intptr = value;
789 break;
790
791 case sKeyRegenerationTime:
792 intptr = &options->key_regeneration_time;
793 goto parse_time;
794
795 case sListenAddress:
796 arg = strdelim(&cp);
797 if (arg == NULL || *arg == '\0')
798 fatal("%s line %d: missing address",
799 filename, linenum);
800 /* check for bare IPv6 address: no "[]" and 2 or more ":" */
801 if (strchr(arg, '[') == NULL && (p = strchr(arg, ':')) != NULL
802 && strchr(p+1, ':') != NULL) {
803 add_listen_addr(options, arg, 0);
804 break;
805 }
806 p = hpdelim(&arg);
807 if (p == NULL)
808 fatal("%s line %d: bad address:port usage",
809 filename, linenum);
810 p = cleanhostname(p);
811 if (arg == NULL)
812 port = 0;
813 else if ((port = a2port(arg)) <= 0)
814 fatal("%s line %d: bad port number", filename, linenum);
815
816 add_listen_addr(options, p, port);
817
818 break;
819
820 case sAddressFamily:
821 arg = strdelim(&cp);
822 if (!arg || *arg == '\0')
823 fatal("%s line %d: missing address family.",
824 filename, linenum);
825 intptr = &options->address_family;
826 if (options->listen_addrs != NULL)
827 fatal("%s line %d: address family must be specified before "
828 "ListenAddress.", filename, linenum);
829 if (strcasecmp(arg, "inet") == 0)
830 value = AF_INET;
831 else if (strcasecmp(arg, "inet6") == 0)
832 value = AF_INET6;
833 else if (strcasecmp(arg, "any") == 0)
834 value = AF_UNSPEC;
835 else
836 fatal("%s line %d: unsupported address family \"%s\".",
837 filename, linenum, arg);
838 if (*intptr == -1)
839 *intptr = value;
840 break;
841
842 case sHostKeyFile:
843 intptr = &options->num_host_key_files;
844 if (*intptr >= MAX_HOSTKEYS)
845 fatal("%s line %d: too many host keys specified (max %d).",
846 filename, linenum, MAX_HOSTKEYS);
847 charptr = &options->host_key_files[*intptr];
848 parse_filename:
849 arg = strdelim(&cp);
850 if (!arg || *arg == '\0')
851 fatal("%s line %d: missing file name.",
852 filename, linenum);
853 if (*activep && *charptr == NULL) {
854 *charptr = tilde_expand_filename(arg, getuid());
855 /* increase optional counter */
856 if (intptr != NULL)
857 *intptr = *intptr + 1;
858 }
859 break;
860
861 case sPidFile:
862 charptr = &options->pid_file;
863 goto parse_filename;
864
865 case sPermitRootLogin:
866 intptr = &options->permit_root_login;
867 arg = strdelim(&cp);
868 if (!arg || *arg == '\0')
869 fatal("%s line %d: missing yes/"
870 "without-password/forced-commands-only/no "
871 "argument.", filename, linenum);
872 value = 0; /* silence compiler */
873 if (strcmp(arg, "without-password") == 0)
874 value = PERMIT_NO_PASSWD;
875 else if (strcmp(arg, "forced-commands-only") == 0)
876 value = PERMIT_FORCED_ONLY;
877 else if (strcmp(arg, "yes") == 0)
878 value = PERMIT_YES;
879 else if (strcmp(arg, "no") == 0)
880 value = PERMIT_NO;
881 else
882 fatal("%s line %d: Bad yes/"
883 "without-password/forced-commands-only/no "
884 "argument: %s", filename, linenum, arg);
885 if (*activep && *intptr == -1)
886 *intptr = value;
887 break;
888
889 case sIgnoreRhosts:
890 intptr = &options->ignore_rhosts;
891 parse_flag:
892 arg = strdelim(&cp);
893 if (!arg || *arg == '\0')
894 fatal("%s line %d: missing yes/no argument.",
895 filename, linenum);
896 value = 0; /* silence compiler */
897 if (strcmp(arg, "yes") == 0)
898 value = 1;
899 else if (strcmp(arg, "no") == 0)
900 value = 0;
901 else
902 fatal("%s line %d: Bad yes/no argument: %s",
903 filename, linenum, arg);
904 if (*activep && *intptr == -1)
905 *intptr = value;
906 break;
907
908 case sNoneEnabled:
909 intptr = &options->none_enabled;
910 goto parse_flag;
911
912 case sTcpRcvBufPoll:
913 intptr = &options->tcp_rcv_buf_poll;
914 goto parse_flag;
915
916 case sHPNDisabled:
917 intptr = &options->hpn_disabled;
918 goto parse_flag;
919
920 case sHPNBufferSize:
921 intptr = &options->hpn_buffer_size;
922 goto parse_int;
923
924 case sIgnoreUserKnownHosts:
925 intptr = &options->ignore_user_known_hosts;
926 goto parse_flag;
927
928 case sRhostsRSAAuthentication:
929 intptr = &options->rhosts_rsa_authentication;
930 goto parse_flag;
931
932 case sHostbasedAuthentication:
933 intptr = &options->hostbased_authentication;
934 goto parse_flag;
935
936 case sHostbasedUsesNameFromPacketOnly:
937 intptr = &options->hostbased_uses_name_from_packet_only;
938 goto parse_flag;
939
940 case sRSAAuthentication:
941 intptr = &options->rsa_authentication;
942 goto parse_flag;
943
944 case sPubkeyAuthentication:
945 intptr = &options->pubkey_authentication;
946 goto parse_flag;
947
948 case sKerberosAuthentication:
949 intptr = &options->kerberos_authentication;
950 goto parse_flag;
951
952 case sKerberosOrLocalPasswd:
953 intptr = &options->kerberos_or_local_passwd;
954 goto parse_flag;
955
956 case sKerberosTicketCleanup:
957 intptr = &options->kerberos_ticket_cleanup;
958 goto parse_flag;
959
960 case sKerberosGetAFSToken:
961 intptr = &options->kerberos_get_afs_token;
962 goto parse_flag;
963
964 case sGssAuthentication:
965 intptr = &options->gss_authentication;
966 goto parse_flag;
967
968 case sGssCleanupCreds:
969 intptr = &options->gss_cleanup_creds;
970 goto parse_flag;
971
972 case sPasswordAuthentication:
973 intptr = &options->password_authentication;
974 goto parse_flag;
975
976 case sZeroKnowledgePasswordAuthentication:
977 intptr = &options->zero_knowledge_password_authentication;
978 goto parse_flag;
979
980 case sKbdInteractiveAuthentication:
981 intptr = &options->kbd_interactive_authentication;
982 goto parse_flag;
983
984 case sChallengeResponseAuthentication:
985 intptr = &options->challenge_response_authentication;
986 goto parse_flag;
987
988 case sPrintMotd:
989 intptr = &options->print_motd;
990 goto parse_flag;
991
992 case sPrintLastLog:
993 intptr = &options->print_lastlog;
994 goto parse_flag;
995
996 case sX11Forwarding:
997 intptr = &options->x11_forwarding;
998 goto parse_flag;
999
1000 case sX11DisplayOffset:
1001 intptr = &options->x11_display_offset;
1002 goto parse_int;
1003
1004 case sX11UseLocalhost:
1005 intptr = &options->x11_use_localhost;
1006 goto parse_flag;
1007
1008 case sXAuthLocation:
1009 charptr = &options->xauth_location;
1010 goto parse_filename;
1011
1012 case sStrictModes:
1013 intptr = &options->strict_modes;
1014 goto parse_flag;
1015
1016 case sTCPKeepAlive:
1017 intptr = &options->tcp_keep_alive;
1018 goto parse_flag;
1019
1020 case sPermitBlacklistedKeys:
1021 intptr = &options->permit_blacklisted_keys;
1022 goto parse_flag;
1023
1024 case sEmptyPasswd:
1025 intptr = &options->permit_empty_passwd;
1026 goto parse_flag;
1027
1028 case sPermitUserEnvironment:
1029 intptr = &options->permit_user_env;
1030 goto parse_flag;
1031
1032 case sUseLogin:
1033 intptr = &options->use_login;
1034 goto parse_flag;
1035
1036 case sCompression:
1037 intptr = &options->compression;
1038 arg = strdelim(&cp);
1039 if (!arg || *arg == '\0')
1040 fatal("%s line %d: missing yes/no/delayed "
1041 "argument.", filename, linenum);
1042 value = 0; /* silence compiler */
1043 if (strcmp(arg, "delayed") == 0)
1044 value = COMP_DELAYED;
1045 else if (strcmp(arg, "yes") == 0)
1046 value = COMP_ZLIB;
1047 else if (strcmp(arg, "no") == 0)
1048 value = COMP_NONE;
1049 else
1050 fatal("%s line %d: Bad yes/no/delayed "
1051 "argument: %s", filename, linenum, arg);
1052 if (*intptr == -1)
1053 *intptr = value;
1054 break;
1055
1056 case sGatewayPorts:
1057 intptr = &options->gateway_ports;
1058 arg = strdelim(&cp);
1059 if (!arg || *arg == '\0')
1060 fatal("%s line %d: missing yes/no/clientspecified "
1061 "argument.", filename, linenum);
1062 value = 0; /* silence compiler */
1063 if (strcmp(arg, "clientspecified") == 0)
1064 value = 2;
1065 else if (strcmp(arg, "yes") == 0)
1066 value = 1;
1067 else if (strcmp(arg, "no") == 0)
1068 value = 0;
1069 else
1070 fatal("%s line %d: Bad yes/no/clientspecified "
1071 "argument: %s", filename, linenum, arg);
1072 if (*activep && *intptr == -1)
1073 *intptr = value;
1074 break;
1075
1076 case sUseDNS:
1077 intptr = &options->use_dns;
1078 goto parse_flag;
1079
1080 case sLogFacility:
1081 log_facility_ptr = &options->log_facility;
1082 arg = strdelim(&cp);
1083 value = log_facility_number(arg);
1084 if (value == SYSLOG_FACILITY_NOT_SET)
1085 fatal("%.200s line %d: unsupported log facility '%s'",
1086 filename, linenum, arg ? arg : "<NONE>");
1087 if (*log_facility_ptr == -1)
1088 *log_facility_ptr = (SyslogFacility) value;
1089 break;
1090
1091 case sLogLevel:
1092 log_level_ptr = &options->log_level;
1093 arg = strdelim(&cp);
1094 value = log_level_number(arg);
1095 if (value == SYSLOG_LEVEL_NOT_SET)
1096 fatal("%.200s line %d: unsupported log level '%s'",
1097 filename, linenum, arg ? arg : "<NONE>");
1098 if (*log_level_ptr == -1)
1099 *log_level_ptr = (LogLevel) value;
1100 break;
1101
1102 case sAllowTcpForwarding:
1103 intptr = &options->allow_tcp_forwarding;
1104 goto parse_flag;
1105
1106 case sAllowAgentForwarding:
1107 intptr = &options->allow_agent_forwarding;
1108 goto parse_flag;
1109
1110 case sUsePrivilegeSeparation:
1111 intptr = &use_privsep;
1112 goto parse_flag;
1113
1114 case sAllowUsers:
1115 while ((arg = strdelim(&cp)) && *arg != '\0') {
1116 if (options->num_allow_users >= MAX_ALLOW_USERS)
1117 fatal("%s line %d: too many allow users.",
1118 filename, linenum);
1119 options->allow_users[options->num_allow_users++] =
1120 xstrdup(arg);
1121 }
1122 break;
1123
1124 case sDenyUsers:
1125 while ((arg = strdelim(&cp)) && *arg != '\0') {
1126 if (options->num_deny_users >= MAX_DENY_USERS)
1127 fatal("%s line %d: too many deny users.",
1128 filename, linenum);
1129 options->deny_users[options->num_deny_users++] =
1130 xstrdup(arg);
1131 }
1132 break;
1133
1134 case sAllowGroups:
1135 while ((arg = strdelim(&cp)) && *arg != '\0') {
1136 if (options->num_allow_groups >= MAX_ALLOW_GROUPS)
1137 fatal("%s line %d: too many allow groups.",
1138 filename, linenum);
1139 options->allow_groups[options->num_allow_groups++] =
1140 xstrdup(arg);
1141 }
1142 break;
1143
1144 case sDenyGroups:
1145 while ((arg = strdelim(&cp)) && *arg != '\0') {
1146 if (options->num_deny_groups >= MAX_DENY_GROUPS)
1147 fatal("%s line %d: too many deny groups.",
1148 filename, linenum);
1149 options->deny_groups[options->num_deny_groups++] = xstrdup(arg);
1150 }
1151 break;
1152
1153 case sCiphers:
1154 arg = strdelim(&cp);
1155 if (!arg || *arg == '\0')
1156 fatal("%s line %d: Missing argument.", filename, linenum);
1157 if (!ciphers_valid(arg))
1158 fatal("%s line %d: Bad SSH2 cipher spec '%s'.",
1159 filename, linenum, arg ? arg : "<NONE>");
1160 if (options->ciphers == NULL)
1161 options->ciphers = xstrdup(arg);
1162 break;
1163
1164 case sMacs:
1165 arg = strdelim(&cp);
1166 if (!arg || *arg == '\0')
1167 fatal("%s line %d: Missing argument.", filename, linenum);
1168 if (!mac_valid(arg))
1169 fatal("%s line %d: Bad SSH2 mac spec '%s'.",
1170 filename, linenum, arg ? arg : "<NONE>");
1171 if (options->macs == NULL)
1172 options->macs = xstrdup(arg);
1173 break;
1174
1175 case sProtocol:
1176 intptr = &options->protocol;
1177 arg = strdelim(&cp);
1178 if (!arg || *arg == '\0')
1179 fatal("%s line %d: Missing argument.", filename, linenum);
1180 value = proto_spec(arg);
1181 if (value == SSH_PROTO_UNKNOWN)
1182 fatal("%s line %d: Bad protocol spec '%s'.",
1183 filename, linenum, arg ? arg : "<NONE>");
1184 if (*intptr == SSH_PROTO_UNKNOWN)
1185 *intptr = value;
1186 break;
1187
1188 case sSubsystem:
1189 if (options->num_subsystems >= MAX_SUBSYSTEMS) {
1190 fatal("%s line %d: too many subsystems defined.",
1191 filename, linenum);
1192 }
1193 arg = strdelim(&cp);
1194 if (!arg || *arg == '\0')
1195 fatal("%s line %d: Missing subsystem name.",
1196 filename, linenum);
1197 if (!*activep) {
1198 arg = strdelim(&cp);
1199 break;
1200 }
1201 for (i = 0; i < options->num_subsystems; i++)
1202 if (strcmp(arg, options->subsystem_name[i]) == 0)
1203 fatal("%s line %d: Subsystem '%s' already defined.",
1204 filename, linenum, arg);
1205 options->subsystem_name[options->num_subsystems] = xstrdup(arg);
1206 arg = strdelim(&cp);
1207 if (!arg || *arg == '\0')
1208 fatal("%s line %d: Missing subsystem command.",
1209 filename, linenum);
1210 options->subsystem_command[options->num_subsystems] = xstrdup(arg);
1211
1212 /* Collect arguments (separate to executable) */
1213 p = xstrdup(arg);
1214 len = strlen(p) + 1;
1215 while ((arg = strdelim(&cp)) != NULL && *arg != '\0') {
1216 len += 1 + strlen(arg);
1217 p = xrealloc(p, 1, len);
1218 strlcat(p, " ", len);
1219 strlcat(p, arg, len);
1220 }
1221 options->subsystem_args[options->num_subsystems] = p;
1222 options->num_subsystems++;
1223 break;
1224
1225 case sMaxStartups:
1226 arg = strdelim(&cp);
1227 if (!arg || *arg == '\0')
1228 fatal("%s line %d: Missing MaxStartups spec.",
1229 filename, linenum);
1230 if ((n = sscanf(arg, "%d:%d:%d",
1231 &options->max_startups_begin,
1232 &options->max_startups_rate,
1233 &options->max_startups)) == 3) {
1234 if (options->max_startups_begin >
1235 options->max_startups ||
1236 options->max_startups_rate > 100 ||
1237 options->max_startups_rate < 1)
1238 fatal("%s line %d: Illegal MaxStartups spec.",
1239 filename, linenum);
1240 } else if (n != 1)
1241 fatal("%s line %d: Illegal MaxStartups spec.",
1242 filename, linenum);
1243 else
1244 options->max_startups = options->max_startups_begin;
1245 break;
1246
1247 case sMaxAuthTries:
1248 intptr = &options->max_authtries;
1249 goto parse_int;
1250
1251 case sMaxSessions:
1252 intptr = &options->max_sessions;
1253 goto parse_int;
1254
1255 case sBanner:
1256 charptr = &options->banner;
1257 goto parse_filename;
1258
1259 /*
1260 * These options can contain %X options expanded at
1261 * connect time, so that you can specify paths like:
1262 *
1263 * AuthorizedKeysFile /etc/ssh_keys/%u
1264 */
1265 case sAuthorizedKeysFile:
1266 case sAuthorizedKeysFile2:
1267 charptr = (opcode == sAuthorizedKeysFile) ?
1268 &options->authorized_keys_file :
1269 &options->authorized_keys_file2;
1270 goto parse_filename;
1271
1272 case sClientAliveInterval:
1273 intptr = &options->client_alive_interval;
1274 goto parse_time;
1275
1276 case sClientAliveCountMax:
1277 intptr = &options->client_alive_count_max;
1278 goto parse_int;
1279
1280 case sAcceptEnv:
1281 while ((arg = strdelim(&cp)) && *arg != '\0') {
1282 if (strchr(arg, '=') != NULL)
1283 fatal("%s line %d: Invalid environment name.",
1284 filename, linenum);
1285 if (options->num_accept_env >= MAX_ACCEPT_ENV)
1286 fatal("%s line %d: too many allow env.",
1287 filename, linenum);
1288 if (!*activep)
1289 break;
1290 options->accept_env[options->num_accept_env++] =
1291 xstrdup(arg);
1292 }
1293 break;
1294
1295 case sPermitTunnel:
1296 intptr = &options->permit_tun;
1297 arg = strdelim(&cp);
1298 if (!arg || *arg == '\0')
1299 fatal("%s line %d: Missing yes/point-to-point/"
1300 "ethernet/no argument.", filename, linenum);
1301 value = -1;
1302 for (i = 0; tunmode_desc[i].val != -1; i++)
1303 if (strcmp(tunmode_desc[i].text, arg) == 0) {
1304 value = tunmode_desc[i].val;
1305 break;
1306 }
1307 if (value == -1)
1308 fatal("%s line %d: Bad yes/point-to-point/ethernet/"
1309 "no argument: %s", filename, linenum, arg);
1310 if (*intptr == -1)
1311 *intptr = value;
1312 break;
1313
1314 case sMatch:
1315 if (cmdline)
1316 fatal("Match directive not supported as a command-line "
1317 "option");
1318 value = match_cfg_line(&cp, linenum, user, host, address);
1319 if (value < 0)
1320 fatal("%s line %d: Bad Match condition", filename,
1321 linenum);
1322 *activep = value;
1323 break;
1324
1325 case sPermitOpen:
1326 arg = strdelim(&cp);
1327 if (!arg || *arg == '\0')
1328 fatal("%s line %d: missing PermitOpen specification",
1329 filename, linenum);
1330 n = options->num_permitted_opens; /* modified later */
1331 if (strcmp(arg, "any") == 0) {
1332 if (*activep && n == -1) {
1333 channel_clear_adm_permitted_opens();
1334 options->num_permitted_opens = 0;
1335 }
1336 break;
1337 }
1338 if (*activep && n == -1)
1339 channel_clear_adm_permitted_opens();
1340 for (; arg != NULL && *arg != '\0'; arg = strdelim(&cp)) {
1341 p = hpdelim(&arg);
1342 if (p == NULL)
1343 fatal("%s line %d: missing host in PermitOpen",
1344 filename, linenum);
1345 p = cleanhostname(p);
1346 if (arg == NULL || (port = a2port(arg)) <= 0)
1347 fatal("%s line %d: bad port number in "
1348 "PermitOpen", filename, linenum);
1349 if (*activep && n == -1)
1350 options->num_permitted_opens =
1351 channel_add_adm_permitted_opens(p, port);
1352 }
1353 break;
1354
1355 case sForceCommand:
1356 if (cp == NULL)
1357 fatal("%.200s line %d: Missing argument.", filename,
1358 linenum);
1359 len = strspn(cp, WHITESPACE);
1360 if (*activep && options->adm_forced_command == NULL)
1361 options->adm_forced_command = xstrdup(cp + len);
1362 return 0;
1363
1364 case sChrootDirectory:
1365 charptr = &options->chroot_directory;
1366
1367 arg = strdelim(&cp);
1368 if (!arg || *arg == '\0')
1369 fatal("%s line %d: missing file name.",
1370 filename, linenum);
1371 if (*activep && *charptr == NULL)
1372 *charptr = xstrdup(arg);
1373 break;
1374
1375 case sVersionAddendum:
1376 ssh_version_set_addendum(strtok(cp, "\n"));
1377 do {
1378 arg = strdelim(&cp);
1379 } while (arg != NULL && *arg != '\0');
1380 break;
1381
1382 case sDeprecated:
1383 logit("%s line %d: Deprecated option %s",
1384 filename, linenum, arg);
1385 while (arg)
1386 arg = strdelim(&cp);
1387 break;
1388
1389 case sUnsupported:
1390 logit("%s line %d: Unsupported option %s",
1391 filename, linenum, arg);
1392 while (arg)
1393 arg = strdelim(&cp);
1394 break;
1395
1396 default:
1397 fatal("%s line %d: Missing handler for opcode %s (%d)",
1398 filename, linenum, arg, opcode);
1399 }
1400 if ((arg = strdelim(&cp)) != NULL && *arg != '\0')
1401 fatal("%s line %d: garbage at end of line; \"%.200s\".",
1402 filename, linenum, arg);
1403 return 0;
1404 }
1405
1406 /* Reads the server configuration file. */
1407
1408 void
1409 load_server_config(const char *filename, Buffer *conf)
1410 {
1411 char line[1024], *cp;
1412 FILE *f;
1413
1414 debug2("%s: filename %s", __func__, filename);
1415 if ((f = fopen(filename, "r")) == NULL) {
1416 perror(filename);
1417 exit(1);
1418 }
1419 buffer_clear(conf);
1420 while (fgets(line, sizeof(line), f)) {
1421 /*
1422 * Trim out comments and strip whitespace
1423 * NB - preserve newlines, they are needed to reproduce
1424 * line numbers later for error messages
1425 */
1426 if ((cp = strchr(line, '#')) != NULL)
1427 memcpy(cp, "\n", 2);
1428 cp = line + strspn(line, " \t\r");
1429
1430 buffer_append(conf, cp, strlen(cp));
1431 }
1432 buffer_append(conf, "\0", 1);
1433 fclose(f);
1434 debug2("%s: done config len = %d", __func__, buffer_len(conf));
1435 }
1436
1437 void
1438 parse_server_match_config(ServerOptions *options, const char *user,
1439 const char *host, const char *address)
1440 {
1441 ServerOptions mo;
1442
1443 initialize_server_options(&mo);
1444 parse_server_config(&mo, "reprocess config", &cfg, user, host, address);
1445 copy_set_server_options(options, &mo, 0);
1446 }
1447
1448 /* Helper macros */
1449 #define M_CP_INTOPT(n) do {\
1450 if (src->n != -1) \
1451 dst->n = src->n; \
1452 } while (0)
1453 #define M_CP_STROPT(n) do {\
1454 if (src->n != NULL) { \
1455 if (dst->n != NULL) \
1456 xfree(dst->n); \
1457 dst->n = src->n; \
1458 } \
1459 } while(0)
1460
1461 /*
1462 * Copy any supported values that are set.
1463 *
1464 * If the preauth flag is set, we do not bother copying the string or
1465 * array values that are not used pre-authentication, because any that we
1466 * do use must be explictly sent in mm_getpwnamallow().
1467 */
1468 void
1469 copy_set_server_options(ServerOptions *dst, ServerOptions *src, int preauth)
1470 {
1471 M_CP_INTOPT(password_authentication);
1472 M_CP_INTOPT(gss_authentication);
1473 M_CP_INTOPT(rsa_authentication);
1474 M_CP_INTOPT(pubkey_authentication);
1475 M_CP_INTOPT(kerberos_authentication);
1476 M_CP_INTOPT(hostbased_authentication);
1477 M_CP_INTOPT(kbd_interactive_authentication);
1478 M_CP_INTOPT(zero_knowledge_password_authentication);
1479 M_CP_INTOPT(permit_root_login);
1480 M_CP_INTOPT(permit_empty_passwd);
1481
1482 M_CP_INTOPT(allow_tcp_forwarding);
1483 M_CP_INTOPT(allow_agent_forwarding);
1484 M_CP_INTOPT(gateway_ports);
1485 M_CP_INTOPT(x11_display_offset);
1486 M_CP_INTOPT(x11_forwarding);
1487 M_CP_INTOPT(x11_use_localhost);
1488 M_CP_INTOPT(max_sessions);
1489 M_CP_INTOPT(max_authtries);
1490
1491 M_CP_STROPT(banner);
1492 if (preauth)
1493 return;
1494 M_CP_STROPT(adm_forced_command);
1495 M_CP_STROPT(chroot_directory);
1496 }
1497
1498 #undef M_CP_INTOPT
1499 #undef M_CP_STROPT
1500
1501 void
1502 parse_server_config(ServerOptions *options, const char *filename, Buffer *conf,
1503 const char *user, const char *host, const char *address)
1504 {
1505 int active, linenum, bad_options = 0;
1506 char *cp, *obuf, *cbuf;
1507
1508 debug2("%s: config %s len %d", __func__, filename, buffer_len(conf));
1509
1510 obuf = cbuf = xstrdup(buffer_ptr(conf));
1511 active = user ? 0 : 1;
1512 linenum = 1;
1513 while ((cp = strsep(&cbuf, "\n")) != NULL) {
1514 if (process_server_config_line(options, cp, filename,
1515 linenum++, &active, user, host, address) != 0)
1516 bad_options++;
1517 }
1518 xfree(obuf);
1519 if (bad_options > 0)
1520 fatal("%s: terminating, %d bad configuration options",
1521 filename, bad_options);
1522 }
1523
1524 static const char *
1525 fmt_intarg(ServerOpCodes code, int val)
1526 {
1527 if (code == sAddressFamily) {
1528 switch (val) {
1529 case AF_INET:
1530 return "inet";
1531 case AF_INET6:
1532 return "inet6";
1533 case AF_UNSPEC:
1534 return "any";
1535 default:
1536 return "UNKNOWN";
1537 }
1538 }
1539 if (code == sPermitRootLogin) {
1540 switch (val) {
1541 case PERMIT_NO_PASSWD:
1542 return "without-password";
1543 case PERMIT_FORCED_ONLY:
1544 return "forced-commands-only";
1545 case PERMIT_YES:
1546 return "yes";
1547 }
1548 }
1549 if (code == sProtocol) {
1550 switch (val) {
1551 case SSH_PROTO_1:
1552 return "1";
1553 case SSH_PROTO_2:
1554 return "2";
1555 case (SSH_PROTO_1|SSH_PROTO_2):
1556 return "2,1";
1557 default:
1558 return "UNKNOWN";
1559 }
1560 }
1561 if (code == sGatewayPorts && val == 2)
1562 return "clientspecified";
1563 if (code == sCompression && val == COMP_DELAYED)
1564 return "delayed";
1565 switch (val) {
1566 case -1:
1567 return "unset";
1568 case 0:
1569 return "no";
1570 case 1:
1571 return "yes";
1572 }
1573 return "UNKNOWN";
1574 }
1575
1576 static const char *
1577 lookup_opcode_name(ServerOpCodes code)
1578 {
1579 u_int i;
1580
1581 for (i = 0; keywords[i].name != NULL; i++)
1582 if (keywords[i].opcode == code)
1583 return(keywords[i].name);
1584 return "UNKNOWN";
1585 }
1586
1587 static void
1588 dump_cfg_int(ServerOpCodes code, int val)
1589 {
1590 printf("%s %d\n", lookup_opcode_name(code), val);
1591 }
1592
1593 static void
1594 dump_cfg_fmtint(ServerOpCodes code, int val)
1595 {
1596 printf("%s %s\n", lookup_opcode_name(code), fmt_intarg(code, val));
1597 }
1598
1599 static void
1600 dump_cfg_string(ServerOpCodes code, const char *val)
1601 {
1602 if (val == NULL)
1603 return;
1604 printf("%s %s\n", lookup_opcode_name(code), val);
1605 }
1606
1607 static void
1608 dump_cfg_strarray(ServerOpCodes code, u_int count, char **vals)
1609 {
1610 u_int i;
1611
1612 for (i = 0; i < count; i++)
1613 printf("%s %s\n", lookup_opcode_name(code), vals[i]);
1614 }
1615
1616 void
1617 dump_config(ServerOptions *o)
1618 {
1619 u_int i;
1620 int ret;
1621 struct addrinfo *ai;
1622 char addr[NI_MAXHOST], port[NI_MAXSERV], *s = NULL;
1623
1624 /* these are usually at the top of the config */
1625 for (i = 0; i < o->num_ports; i++)
1626 printf("port %d\n", o->ports[i]);
1627 dump_cfg_fmtint(sProtocol, o->protocol);
1628 dump_cfg_fmtint(sAddressFamily, o->address_family);
1629
1630 /* ListenAddress must be after Port */
1631 for (ai = o->listen_addrs; ai; ai = ai->ai_next) {
1632 if ((ret = getnameinfo(ai->ai_addr, ai->ai_addrlen, addr,
1633 sizeof(addr), port, sizeof(port),
1634 NI_NUMERICHOST|NI_NUMERICSERV)) != 0) {
1635 error("getnameinfo failed: %.100s",
1636 (ret != EAI_SYSTEM) ? gai_strerror(ret) :
1637 strerror(errno));
1638 } else {
1639 if (ai->ai_family == AF_INET6)
1640 printf("listenaddress [%s]:%s\n", addr, port);
1641 else
1642 printf("listenaddress %s:%s\n", addr, port);
1643 }
1644 }
1645
1646 /* integer arguments */
1647 #ifdef USE_PAM
1648 dump_cfg_int(sUsePAM, o->use_pam);
1649 #endif
1650 dump_cfg_int(sServerKeyBits, o->server_key_bits);
1651 dump_cfg_int(sLoginGraceTime, o->login_grace_time);
1652 dump_cfg_int(sKeyRegenerationTime, o->key_regeneration_time);
1653 dump_cfg_int(sX11DisplayOffset, o->x11_display_offset);
1654 dump_cfg_int(sMaxAuthTries, o->max_authtries);
1655 dump_cfg_int(sMaxSessions, o->max_sessions);
1656 dump_cfg_int(sClientAliveInterval, o->client_alive_interval);
1657 dump_cfg_int(sClientAliveCountMax, o->client_alive_count_max);
1658
1659 /* formatted integer arguments */
1660 dump_cfg_fmtint(sPermitRootLogin, o->permit_root_login);
1661 dump_cfg_fmtint(sIgnoreRhosts, o->ignore_rhosts);
1662 dump_cfg_fmtint(sIgnoreUserKnownHosts, o->ignore_user_known_hosts);
1663 dump_cfg_fmtint(sRhostsRSAAuthentication, o->rhosts_rsa_authentication);
1664 dump_cfg_fmtint(sHostbasedAuthentication, o->hostbased_authentication);
1665 dump_cfg_fmtint(sHostbasedUsesNameFromPacketOnly,
1666 o->hostbased_uses_name_from_packet_only);
1667 dump_cfg_fmtint(sRSAAuthentication, o->rsa_authentication);
1668 dump_cfg_fmtint(sPubkeyAuthentication, o->pubkey_authentication);
1669 #ifdef KRB5
1670 dump_cfg_fmtint(sKerberosAuthentication, o->kerberos_authentication);
1671 dump_cfg_fmtint(sKerberosOrLocalPasswd, o->kerberos_or_local_passwd);
1672 dump_cfg_fmtint(sKerberosTicketCleanup, o->kerberos_ticket_cleanup);
1673 # ifdef USE_AFS
1674 dump_cfg_fmtint(sKerberosGetAFSToken, o->kerberos_get_afs_token);
1675 # endif
1676 #endif
1677 #ifdef GSSAPI
1678 dump_cfg_fmtint(sGssAuthentication, o->gss_authentication);
1679 dump_cfg_fmtint(sGssCleanupCreds, o->gss_cleanup_creds);
1680 #endif
1681 #ifdef JPAKE
1682 dump_cfg_fmtint(sZeroKnowledgePasswordAuthentication,
1683 o->zero_knowledge_password_authentication);
1684 #endif
1685 dump_cfg_fmtint(sPasswordAuthentication, o->password_authentication);
1686 dump_cfg_fmtint(sKbdInteractiveAuthentication,
1687 o->kbd_interactive_authentication);
1688 dump_cfg_fmtint(sChallengeResponseAuthentication,
1689 o->challenge_response_authentication);
1690 dump_cfg_fmtint(sPrintMotd, o->print_motd);
1691 dump_cfg_fmtint(sPrintLastLog, o->print_lastlog);
1692 dump_cfg_fmtint(sX11Forwarding, o->x11_forwarding);
1693 dump_cfg_fmtint(sX11UseLocalhost, o->x11_use_localhost);
1694 dump_cfg_fmtint(sStrictModes, o->strict_modes);
1695 dump_cfg_fmtint(sTCPKeepAlive, o->tcp_keep_alive);
1696 dump_cfg_fmtint(sEmptyPasswd, o->permit_empty_passwd);
1697 dump_cfg_fmtint(sPermitUserEnvironment, o->permit_user_env);
1698 dump_cfg_fmtint(sUseLogin, o->use_login);
1699 dump_cfg_fmtint(sCompression, o->compression);
1700 dump_cfg_fmtint(sGatewayPorts, o->gateway_ports);
1701 dump_cfg_fmtint(sUseDNS, o->use_dns);
1702 dump_cfg_fmtint(sAllowTcpForwarding, o->allow_tcp_forwarding);
1703 dump_cfg_fmtint(sUsePrivilegeSeparation, use_privsep);
1704
1705 /* string arguments */
1706 dump_cfg_string(sPidFile, o->pid_file);
1707 dump_cfg_string(sXAuthLocation, o->xauth_location);
1708 dump_cfg_string(sCiphers, o->ciphers);
1709 dump_cfg_string(sMacs, o->macs);
1710 dump_cfg_string(sBanner, o->banner);
1711 dump_cfg_string(sAuthorizedKeysFile, o->authorized_keys_file);
1712 dump_cfg_string(sAuthorizedKeysFile2, o->authorized_keys_file2);
1713 dump_cfg_string(sForceCommand, o->adm_forced_command);
1714
1715 /* string arguments requiring a lookup */
1716 dump_cfg_string(sLogLevel, log_level_name(o->log_level));
1717 dump_cfg_string(sLogFacility, log_facility_name(o->log_facility));
1718
1719 /* string array arguments */
1720 dump_cfg_strarray(sHostKeyFile, o->num_host_key_files,
1721 o->host_key_files);
1722 dump_cfg_strarray(sAllowUsers, o->num_allow_users, o->allow_users);
1723 dump_cfg_strarray(sDenyUsers, o->num_deny_users, o->deny_users);
1724 dump_cfg_strarray(sAllowGroups, o->num_allow_groups, o->allow_groups);
1725 dump_cfg_strarray(sDenyGroups, o->num_deny_groups, o->deny_groups);
1726 dump_cfg_strarray(sAcceptEnv, o->num_accept_env, o->accept_env);
1727
1728 /* other arguments */
1729 for (i = 0; i < o->num_subsystems; i++)
1730 printf("subsystem %s %s\n", o->subsystem_name[i],
1731 o->subsystem_args[i]);
1732
1733 printf("maxstartups %d:%d:%d\n", o->max_startups_begin,
1734 o->max_startups_rate, o->max_startups);
1735
1736 for (i = 0; tunmode_desc[i].val != -1; i++)
1737 if (tunmode_desc[i].val == o->permit_tun) {
1738 s = tunmode_desc[i].text;
1739 break;
1740 }
1741 dump_cfg_string(sPermitTunnel, s);
1742
1743 channel_print_adm_permitted_opens();
1744 }
DragonFly BSD