blob: 927508f585d68a33a2673a178dbed74b5d2b39cb [file] [log] [blame]
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001/*
Damien Miller95def091999-11-25 00:26:21 +11002 * Author: Tatu Ylonen <ylo@cs.hut.fi>
Damien Miller95def091999-11-25 00:26:21 +11003 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
4 * All rights reserved
Damien Miller95def091999-11-25 00:26:21 +11005 * Functions for returning the canonical host name of the remote site.
Damien Miller4af51302000-04-16 11:18:38 +10006 *
Damien Millere4340be2000-09-16 13:29:08 +11007 * As far as I am concerned, the code I have written for this software
8 * can be used freely for any purpose. Any derived versions of this
9 * software must be clearly marked as such, and if the derived work is
10 * incompatible with the protocol description in the RFC file, it must be
11 * called by a name other than "ssh" or "Secure Shell".
Damien Miller95def091999-11-25 00:26:21 +110012 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100013
14#include "includes.h"
Ben Lindstromf15a3862001-04-05 23:32:17 +000015RCSID("$OpenBSD: canohost.c,v 1.24 2001/04/05 15:48:19 stevesk Exp $");
Damien Millerd4a8b7e1999-10-27 13:42:43 +100016
17#include "packet.h"
18#include "xmalloc.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000019#include "log.h"
Ben Lindstrom31ca54a2001-02-09 02:11:24 +000020#include "canohost.h"
Damien Millerd4a8b7e1999-10-27 13:42:43 +100021
Damien Miller33804262001-02-04 23:20:18 +110022void check_ip_options(int socket, char *ipaddr);
23
Damien Miller5428f641999-11-25 11:54:57 +110024/*
25 * Return the canonical name of the host at the other end of the socket. The
26 * caller should free the returned string with xfree.
27 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100028
Damien Miller95def091999-11-25 00:26:21 +110029char *
Damien Miller33804262001-02-04 23:20:18 +110030get_remote_hostname(int socket, int reverse_mapping_check)
Damien Millerd4a8b7e1999-10-27 13:42:43 +100031{
Damien Miller34132e52000-01-14 15:45:46 +110032 struct sockaddr_storage from;
33 int i;
34 socklen_t fromlen;
35 struct addrinfo hints, *ai, *aitop;
Damien Miller33804262001-02-04 23:20:18 +110036 char name[NI_MAXHOST], ntop[NI_MAXHOST], ntop2[NI_MAXHOST];
Damien Millerd4a8b7e1999-10-27 13:42:43 +100037
Damien Miller95def091999-11-25 00:26:21 +110038 /* Get IP address of client. */
39 fromlen = sizeof(from);
40 memset(&from, 0, sizeof(from));
Damien Miller33804262001-02-04 23:20:18 +110041 if (getpeername(socket, (struct sockaddr *) &from, &fromlen) < 0) {
Damien Miller95def091999-11-25 00:26:21 +110042 debug("getpeername failed: %.100s", strerror(errno));
43 fatal_cleanup();
Damien Millerd4a8b7e1999-10-27 13:42:43 +100044 }
Damien Miller7bcb0892000-03-11 20:45:40 +110045#ifdef IPV4_IN_IPV6
46 if (from.ss_family == AF_INET6) {
47 struct sockaddr_in6 *from6 = (struct sockaddr_in6 *)&from;
48
49 /* Detect IPv4 in IPv6 mapped address and convert it to */
50 /* plain (AF_INET) IPv4 address */
51 if (IN6_IS_ADDR_V4MAPPED(&from6->sin6_addr)) {
52 struct sockaddr_in *from4 = (struct sockaddr_in *)&from;
53 struct in_addr addr;
54 u_int16_t port;
55
56 memcpy(&addr, ((char *)&from6->sin6_addr) + 12, sizeof(addr));
57 port = from6->sin6_port;
58
59 memset(&from, 0, sizeof(from));
Kevin Stevesef4eea92001-02-05 12:42:17 +000060
Damien Miller7bcb0892000-03-11 20:45:40 +110061 from4->sin_family = AF_INET;
62 memcpy(&from4->sin_addr, &addr, sizeof(addr));
63 from4->sin_port = port;
64 }
65 }
66#endif
Damien Miller33804262001-02-04 23:20:18 +110067 if (from.ss_family == AF_INET)
68 check_ip_options(socket, ntop);
Damien Miller7bcb0892000-03-11 20:45:40 +110069
Damien Miller34132e52000-01-14 15:45:46 +110070 if (getnameinfo((struct sockaddr *)&from, fromlen, ntop, sizeof(ntop),
71 NULL, 0, NI_NUMERICHOST) != 0)
72 fatal("get_remote_hostname: getnameinfo NI_NUMERICHOST failed");
Damien Miller95def091999-11-25 00:26:21 +110073
Ben Lindstrom874a0b32001-02-10 21:39:49 +000074 debug("Trying to reverse map address %.100s.", ntop);
Damien Miller34132e52000-01-14 15:45:46 +110075 /* Map the IP address to a host name. */
76 if (getnameinfo((struct sockaddr *)&from, fromlen, name, sizeof(name),
Damien Miller33804262001-02-04 23:20:18 +110077 NULL, 0, NI_NAMEREQD) != 0) {
78 /* Host name not found. Use ip address. */
79 log("Could not reverse map address %.100s.", ntop);
80 return xstrdup(ntop);
Damien Millerd4a8b7e1999-10-27 13:42:43 +100081 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +100082
Damien Miller33804262001-02-04 23:20:18 +110083 /* Got host name. */
84 name[sizeof(name) - 1] = '\0';
Damien Miller5428f641999-11-25 11:54:57 +110085 /*
Damien Miller33804262001-02-04 23:20:18 +110086 * Convert it to all lowercase (which is expected by the rest
87 * of this software).
Damien Miller5428f641999-11-25 11:54:57 +110088 */
Damien Miller33804262001-02-04 23:20:18 +110089 for (i = 0; name[i]; i++)
90 if (isupper(name[i]))
91 name[i] = tolower(name[i]);
Damien Miller95def091999-11-25 00:26:21 +110092
Damien Miller33804262001-02-04 23:20:18 +110093 if (!reverse_mapping_check)
94 return xstrdup(name);
95 /*
96 * Map it back to an IP address and check that the given
97 * address actually is an address of this host. This is
98 * necessary because anyone with access to a name server can
99 * define arbitrary names for an IP address. Mapping from
100 * name to IP address can be trusted better (but can still be
101 * fooled if the intruder has access to the name server of
102 * the domain).
103 */
104 memset(&hints, 0, sizeof(hints));
105 hints.ai_family = from.ss_family;
106 hints.ai_socktype = SOCK_STREAM;
107 if (getaddrinfo(name, NULL, &hints, &aitop) != 0) {
108 log("reverse mapping checking getaddrinfo for %.700s "
109 "failed - POSSIBLE BREAKIN ATTEMPT!", name);
110 return xstrdup(ntop);
Damien Miller95def091999-11-25 00:26:21 +1100111 }
Damien Miller33804262001-02-04 23:20:18 +1100112 /* Look for the address from the list of addresses. */
113 for (ai = aitop; ai; ai = ai->ai_next) {
114 if (getnameinfo(ai->ai_addr, ai->ai_addrlen, ntop2,
115 sizeof(ntop2), NULL, 0, NI_NUMERICHOST) == 0 &&
116 (strcmp(ntop, ntop2) == 0))
117 break;
118 }
119 freeaddrinfo(aitop);
120 /* If we reached the end of the list, the address was not there. */
121 if (!ai) {
122 /* Address not found for the host name. */
123 log("Address %.100s maps to %.600s, but this does not "
124 "map back to the address - POSSIBLE BREAKIN ATTEMPT!",
125 ntop, name);
126 return xstrdup(ntop);
127 }
Damien Miller95def091999-11-25 00:26:21 +1100128 return xstrdup(name);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000129}
130
Damien Miller5428f641999-11-25 11:54:57 +1100131/*
Damien Miller33804262001-02-04 23:20:18 +1100132 * If IP options are supported, make sure there are none (log and
133 * disconnect them if any are found). Basically we are worried about
134 * source routing; it can be used to pretend you are somebody
135 * (ip-address) you are not. That itself may be "almost acceptable"
136 * under certain circumstances, but rhosts autentication is useless
137 * if source routing is accepted. Notice also that if we just dropped
138 * source routing here, the other side could use IP spoofing to do
139 * rest of the interaction and could still bypass security. So we
140 * exit here if we detect any IP options.
141 */
142/* IPv4 only */
143void
144check_ip_options(int socket, char *ipaddr)
145{
Ben Lindstrom075390a2001-02-10 21:34:46 +0000146 u_char options[200];
147 char text[sizeof(options) * 3 + 1];
Damien Miller33804262001-02-04 23:20:18 +1100148 socklen_t option_size;
Ben Lindstrom075390a2001-02-10 21:34:46 +0000149 int i, ipproto;
Damien Miller33804262001-02-04 23:20:18 +1100150 struct protoent *ip;
151
152 if ((ip = getprotobyname("ip")) != NULL)
153 ipproto = ip->p_proto;
154 else
155 ipproto = IPPROTO_IP;
156 option_size = sizeof(options);
157 if (getsockopt(socket, ipproto, IP_OPTIONS, (void *)options,
158 &option_size) >= 0 && option_size != 0) {
Ben Lindstrom075390a2001-02-10 21:34:46 +0000159 text[0] = '\0';
160 for (i = 0; i < option_size; i++)
161 snprintf(text + i*3, sizeof(text) - i*3,
162 " %2.2x", options[i]);
Damien Miller33804262001-02-04 23:20:18 +1100163 log("Connection from %.100s with IP options:%.800s",
164 ipaddr, text);
165 packet_disconnect("Connection from %.100s with IP options:%.800s",
166 ipaddr, text);
167 }
168}
169
170/*
Damien Miller5428f641999-11-25 11:54:57 +1100171 * Return the canonical name of the host in the other side of the current
172 * connection. The host name is cached, so it is efficient to call this
173 * several times.
174 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000175
Damien Miller95def091999-11-25 00:26:21 +1100176const char *
Damien Miller33804262001-02-04 23:20:18 +1100177get_canonical_hostname(int reverse_mapping_check)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000178{
Damien Miller34132e52000-01-14 15:45:46 +1100179 static char *canonical_host_name = NULL;
Damien Miller33804262001-02-04 23:20:18 +1100180 static int reverse_mapping_checked = 0;
Damien Miller34132e52000-01-14 15:45:46 +1100181
Damien Miller33804262001-02-04 23:20:18 +1100182 /* Check if we have previously retrieved name with same option. */
183 if (canonical_host_name != NULL) {
184 if (reverse_mapping_checked != reverse_mapping_check)
185 xfree(canonical_host_name);
186 else
187 return canonical_host_name;
188 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000189
Damien Miller95def091999-11-25 00:26:21 +1100190 /* Get the real hostname if socket; otherwise return UNKNOWN. */
Damien Miller34132e52000-01-14 15:45:46 +1100191 if (packet_connection_is_on_socket())
Damien Miller33804262001-02-04 23:20:18 +1100192 canonical_host_name = get_remote_hostname(
193 packet_get_connection_in(), reverse_mapping_check);
Damien Miller95def091999-11-25 00:26:21 +1100194 else
195 canonical_host_name = xstrdup("UNKNOWN");
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000196
Damien Miller33804262001-02-04 23:20:18 +1100197 reverse_mapping_checked = reverse_mapping_check;
Damien Miller95def091999-11-25 00:26:21 +1100198 return canonical_host_name;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000199}
200
Damien Miller5428f641999-11-25 11:54:57 +1100201/*
Damien Millerd83ff352001-01-30 09:19:34 +1100202 * Returns the remote IP-address of socket as a string. The returned
203 * string must be freed.
204 */
205
206char *
207get_peer_ipaddr(int socket)
208{
209 struct sockaddr_storage from;
210 socklen_t fromlen;
211 char ntop[NI_MAXHOST];
212
213 /* Get IP address of client. */
214 fromlen = sizeof(from);
215 memset(&from, 0, sizeof(from));
216 if (getpeername(socket, (struct sockaddr *) & from, &fromlen) < 0) {
217 debug("get_peer_ipaddr: getpeername failed: %.100s", strerror(errno));
218 return NULL;
219 }
220 /* Get the IP address in ascii. */
221 if (getnameinfo((struct sockaddr *)&from, fromlen, ntop, sizeof(ntop),
222 NULL, 0, NI_NUMERICHOST) != 0) {
223 error("get_peer_ipaddr: getnameinfo NI_NUMERICHOST failed");
224 return NULL;
225 }
226 return xstrdup(ntop);
227}
228
229/*
Damien Miller5428f641999-11-25 11:54:57 +1100230 * Returns the IP-address of the remote host as a string. The returned
Damien Miller34132e52000-01-14 15:45:46 +1100231 * string must not be freed.
Damien Miller5428f641999-11-25 11:54:57 +1100232 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000233
Damien Miller95def091999-11-25 00:26:21 +1100234const char *
235get_remote_ipaddr()
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000236{
Damien Miller34132e52000-01-14 15:45:46 +1100237 static char *canonical_host_ip = NULL;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000238
Damien Millerd83ff352001-01-30 09:19:34 +1100239 /* Check whether we have cached the ipaddr. */
240 if (canonical_host_ip == NULL) {
241 if (packet_connection_is_on_socket()) {
242 canonical_host_ip =
243 get_peer_ipaddr(packet_get_connection_in());
244 if (canonical_host_ip == NULL)
245 fatal_cleanup();
246 } else {
247 /* If not on socket, return UNKNOWN. */
248 canonical_host_ip = xstrdup("UNKNOWN");
249 }
Damien Miller95def091999-11-25 00:26:21 +1100250 }
Damien Miller95def091999-11-25 00:26:21 +1100251 return canonical_host_ip;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000252}
253
Ben Lindstromf15a3862001-04-05 23:32:17 +0000254const char *
255get_remote_name_or_ip(u_int utmp_len, int reverse_mapping_check)
256{
257 static const char *remote = "";
258 if (utmp_len > 0)
259 remote = get_canonical_hostname(reverse_mapping_check);
260 if (utmp_len == 0 || strlen(remote) > utmp_len)
261 remote = get_remote_ipaddr();
262 return remote;
263}
264
Damien Miller34132e52000-01-14 15:45:46 +1100265/* Returns the local/remote port for the socket. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000266
Damien Miller34132e52000-01-14 15:45:46 +1100267int
268get_sock_port(int sock, int local)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000269{
Damien Miller34132e52000-01-14 15:45:46 +1100270 struct sockaddr_storage from;
271 socklen_t fromlen;
272 char strport[NI_MAXSERV];
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000273
Damien Miller95def091999-11-25 00:26:21 +1100274 /* Get IP address of client. */
275 fromlen = sizeof(from);
276 memset(&from, 0, sizeof(from));
Damien Miller34132e52000-01-14 15:45:46 +1100277 if (local) {
278 if (getsockname(sock, (struct sockaddr *)&from, &fromlen) < 0) {
279 error("getsockname failed: %.100s", strerror(errno));
280 return 0;
281 }
282 } else {
283 if (getpeername(sock, (struct sockaddr *) & from, &fromlen) < 0) {
284 debug("getpeername failed: %.100s", strerror(errno));
285 fatal_cleanup();
286 }
Damien Miller95def091999-11-25 00:26:21 +1100287 }
288 /* Return port number. */
Damien Miller34132e52000-01-14 15:45:46 +1100289 if (getnameinfo((struct sockaddr *)&from, fromlen, NULL, 0,
290 strport, sizeof(strport), NI_NUMERICSERV) != 0)
291 fatal("get_sock_port: getnameinfo NI_NUMERICSERV failed");
292 return atoi(strport);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000293}
294
Damien Miller34132e52000-01-14 15:45:46 +1100295/* Returns remote/local port number for the current connection. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000296
Damien Miller4af51302000-04-16 11:18:38 +1000297int
Damien Miller34132e52000-01-14 15:45:46 +1100298get_port(int local)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000299{
Damien Miller5428f641999-11-25 11:54:57 +1100300 /*
301 * If the connection is not a socket, return 65535. This is
302 * intentionally chosen to be an unprivileged port number.
303 */
Damien Miller34132e52000-01-14 15:45:46 +1100304 if (!packet_connection_is_on_socket())
Damien Miller95def091999-11-25 00:26:21 +1100305 return 65535;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000306
Damien Miller34132e52000-01-14 15:45:46 +1100307 /* Get socket and return the port number. */
308 return get_sock_port(packet_get_connection_in(), local);
309}
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000310
Damien Miller4af51302000-04-16 11:18:38 +1000311int
Damien Miller34132e52000-01-14 15:45:46 +1100312get_peer_port(int sock)
313{
314 return get_sock_port(sock, 0);
315}
316
Damien Miller4af51302000-04-16 11:18:38 +1000317int
Damien Miller34132e52000-01-14 15:45:46 +1100318get_remote_port()
319{
320 return get_port(0);
321}
322
323int
324get_local_port()
325{
326 return get_port(1);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000327}