canohost.c

   1 /* $OpenBSD: canohost.c,v 1.59 2006/07/26 13:57:17 stevesk Exp $ */
   2 /*
   3  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   4  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   5  *                    All rights reserved
   6  * Functions for returning the canonical host name of the remote site.
   7  *
   8  * As far as I am concerned, the code I have written for this software
   9  * can be used freely for any purpose.  Any derived versions of this
  10  * software must be clearly marked as such, and if the derived work is
  11  * incompatible with the protocol description in the RFC file, it must be
  12  * called by a name other than "ssh" or "Secure Shell".
  13  */
  14
  15 #include "includes.h"
  16
  17 #include <sys/types.h>
  18 #include <sys/socket.h>
  19
  20 #include <netinet/in.h>
  21
  22 #include <ctype.h>
  23 #include <errno.h>
  24 #include <netdb.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "packet.h"
  29 #include "xmalloc.h"
  30 #include "log.h"
  31 #include "canohost.h"
  32
  33 static void check_ip_options(int, char *);
  34
  35 /*
  36  * Return the canonical name of the host at the other end of the socket. The
  37  * caller should free the returned string with xfree.
  38  */
  39
  40 static char *
  41 get_remote_hostname(int sock, int use_dns)
  42 {
  43         struct sockaddr_storage from;
  44         int i;
  45         socklen_t fromlen;
  46         struct addrinfo hints, *ai, *aitop;
  47         char name[NI_MAXHOST], ntop[NI_MAXHOST], ntop2[NI_MAXHOST];
  48
  49         /* Get IP address of client. */
  50         fromlen = sizeof(from);
  51         memset(&from, 0, sizeof(from));
  52         if (getpeername(sock, (struct sockaddr *)&from, &fromlen) < 0) {
  53                 debug("getpeername failed: %.100s", strerror(errno));
  54                 cleanup_exit(255);
  55         }
  56
  57         if (from.ss_family == AF_INET)
  58                 check_ip_options(sock, ntop);
  59
  60         ipv64_normalise_mapped(&from, &fromlen);
  61
  62         if (from.ss_family == AF_INET6)
  63                 fromlen = sizeof(struct sockaddr_in6);
  64
  65         if (getnameinfo((struct sockaddr *)&from, fromlen, ntop, sizeof(ntop),
  66             NULL, 0, NI_NUMERICHOST) != 0)
  67                 fatal("get_remote_hostname: getnameinfo NI_NUMERICHOST failed");
  68
  69         if (!use_dns)
  70                 return xstrdup(ntop);
  71
  72         debug3("Trying to reverse map address %.100s.", ntop);
  73         /* Map the IP address to a host name. */
  74         if (getnameinfo((struct sockaddr *)&from, fromlen, name, sizeof(name),
  75             NULL, 0, NI_NAMEREQD) != 0) {
  76                 /* Host name not found.  Use ip address. */
  77                 return xstrdup(ntop);
  78         }
  79
  80         /*
  81          * if reverse lookup result looks like a numeric hostname,
  82          * someone is trying to trick us by PTR record like following:
  83          *      1.1.1.10.in-addr.arpa.  IN PTR  2.3.4.5
  84          */
  85         memset(&hints, 0, sizeof(hints));
  86         hints.ai_socktype = SOCK_DGRAM; /*dummy*/
  87         hints.ai_flags = AI_NUMERICHOST;
  88         if (getaddrinfo(name, "0", &hints, &ai) == 0) {
  89                 logit("Nasty PTR record \"%s\" is set up for %s, ignoring",
  90                     name, ntop);
  91                 freeaddrinfo(ai);
  92                 return xstrdup(ntop);
  93         }
  94
  95         /*
  96          * Convert it to all lowercase (which is expected by the rest
  97          * of this software).
  98          */
  99         for (i = 0; name[i]; i++)
 100                 if (isupper(name[i]))
 101                         name[i] = (char)tolower(name[i]);
 102         /*
 103          * Map it back to an IP address and check that the given
 104          * address actually is an address of this host.  This is
 105          * necessary because anyone with access to a name server can
 106          * define arbitrary names for an IP address. Mapping from
 107          * name to IP address can be trusted better (but can still be
 108          * fooled if the intruder has access to the name server of
 109          * the domain).
 110          */
 111         memset(&hints, 0, sizeof(hints));
 112         hints.ai_family = from.ss_family;
 113         hints.ai_socktype = SOCK_STREAM;
 114         if (getaddrinfo(name, NULL, &hints, &aitop) != 0) {
 115                 logit("reverse mapping checking getaddrinfo for %.700s "
 116                     "[%s] failed - POSSIBLE BREAK-IN ATTEMPT!", name, ntop);
 117                 return xstrdup(ntop);
 118         }
 119         /* Look for the address from the list of addresses. */
 120         for (ai = aitop; ai; ai = ai->ai_next) {
 121                 if (getnameinfo(ai->ai_addr, ai->ai_addrlen, ntop2,
 122                     sizeof(ntop2), NULL, 0, NI_NUMERICHOST) == 0 &&
 123                     (strcmp(ntop, ntop2) == 0))
 124                                 break;
 125         }
 126         freeaddrinfo(aitop);
 127         /* If we reached the end of the list, the address was not there. */
 128         if (!ai) {
 129                 /* Address not found for the host name. */
 130                 logit("Address %.100s maps to %.600s, but this does not "
 131                     "map back to the address - POSSIBLE BREAK-IN ATTEMPT!",
 132                     ntop, name);
 133                 return xstrdup(ntop);
 134         }
 135         return xstrdup(name);
 136 }
 137
 138 /*
 139  * If IP options are supported, make sure there are none (log and
 140  * disconnect them if any are found).  Basically we are worried about
 141  * source routing; it can be used to pretend you are somebody
 142  * (ip-address) you are not. That itself may be "almost acceptable"
 143  * under certain circumstances, but rhosts autentication is useless
 144  * if source routing is accepted. Notice also that if we just dropped
 145  * source routing here, the other side could use IP spoofing to do
 146  * rest of the interaction and could still bypass security.  So we
 147  * exit here if we detect any IP options.
 148  */
 149 /* IPv4 only */
 150 static void
 151 check_ip_options(int sock, char *ipaddr)
 152 {
 153 #ifdef IP_OPTIONS
 154         u_char options[200];
 155         char text[sizeof(options) * 3 + 1];
 156         socklen_t option_size;
 157         u_int i;
 158         int ipproto;
 159         struct protoent *ip;
 160
 161         if ((ip = getprotobyname("ip")) != NULL)
 162                 ipproto = ip->p_proto;
 163         else
 164                 ipproto = IPPROTO_IP;
 165         option_size = sizeof(options);
 166         if (getsockopt(sock, ipproto, IP_OPTIONS, options,
 167             &option_size) >= 0 && option_size != 0) {
 168                 text[0] = '\0';
 169                 for (i = 0; i < option_size; i++)
 170                         snprintf(text + i*3, sizeof(text) - i*3,
 171                             " %2.2x", options[i]);
 172                 fatal("Connection from %.100s with IP options:%.800s",
 173                     ipaddr, text);
 174         }
 175 #endif /* IP_OPTIONS */
 176 }
 177
 178 void
 179 ipv64_normalise_mapped(struct sockaddr_storage *addr, socklen_t *len)
 180 {
 181         struct sockaddr_in6 *a6 = (struct sockaddr_in6 *)addr;
 182         struct sockaddr_in *a4 = (struct sockaddr_in *)addr;
 183         struct in_addr inaddr;
 184         u_int16_t port;
 185
 186         if (addr->ss_family != AF_INET6 ||
 187             !IN6_IS_ADDR_V4MAPPED(&a6->sin6_addr))
 188                 return;
 189
 190         debug3("Normalising mapped IPv4 in IPv6 address");
 191
 192         memcpy(&inaddr, ((char *)&a6->sin6_addr) + 12, sizeof(inaddr));
 193         port = a6->sin6_port;
 194
 195         memset(addr, 0, sizeof(*a4));
 196
 197         a4->sin_family = AF_INET;
 198         *len = sizeof(*a4);
 199         memcpy(&a4->sin_addr, &inaddr, sizeof(inaddr));
 200         a4->sin_port = port;
 201 }
 202
 203 /*
 204  * Return the canonical name of the host in the other side of the current
 205  * connection.  The host name is cached, so it is efficient to call this
 206  * several times.
 207  */
 208
 209 const char *
 210 get_canonical_hostname(int use_dns)
 211 {
 212         char *host;
 213         static char *canonical_host_name = NULL;
 214         static char *remote_ip = NULL;
 215
 216         /* Check if we have previously retrieved name with same option. */
 217         if (use_dns && canonical_host_name != NULL)
 218                 return canonical_host_name;
 219         if (!use_dns && remote_ip != NULL)
 220                 return remote_ip;
 221
 222         /* Get the real hostname if socket; otherwise return UNKNOWN. */
 223         if (packet_connection_is_on_socket())
 224                 host = get_remote_hostname(packet_get_connection_in(), use_dns);
 225         else
 226                 host = "UNKNOWN";
 227
 228         if (use_dns)
 229                 canonical_host_name = host;
 230         else
 231                 remote_ip = host;
 232         return host;
 233 }
 234
 235 /*
 236  * Returns the local/remote IP-address/hostname of socket as a string.
 237  * The returned string must be freed.
 238  */
 239 static char *
 240 get_socket_address(int sock, int remote, int flags)
 241 {
 242         struct sockaddr_storage addr;
 243         socklen_t addrlen;
 244         char ntop[NI_MAXHOST];
 245         int r;
 246
 247         /* Get IP address of client. */
 248         addrlen = sizeof(addr);
 249         memset(&addr, 0, sizeof(addr));
 250
 251         if (remote) {
 252                 if (getpeername(sock, (struct sockaddr *)&addr, &addrlen)
 253                     < 0)
 254                         return NULL;
 255         } else {
 256                 if (getsockname(sock, (struct sockaddr *)&addr, &addrlen)
 257                     < 0)
 258                         return NULL;
 259         }
 260
 261         /* Work around Linux IPv6 weirdness */
 262         if (addr.ss_family == AF_INET6)
 263                 addrlen = sizeof(struct sockaddr_in6);
 264
 265         ipv64_normalise_mapped(&addr, &addrlen);
 266
 267         /* Get the address in ascii. */
 268         if ((r = getnameinfo((struct sockaddr *)&addr, addrlen, ntop,
 269             sizeof(ntop), NULL, 0, flags)) != 0) {
 270                 error("get_socket_address: getnameinfo %d failed: %s", flags,
 271                     r == EAI_SYSTEM ? strerror(errno) : gai_strerror(r));
 272                 return NULL;
 273         }
 274         return xstrdup(ntop);
 275 }
 276
 277 char *
 278 get_peer_ipaddr(int sock)
 279 {
 280         char *p;
 281
 282         if ((p = get_socket_address(sock, 1, NI_NUMERICHOST)) != NULL)
 283                 return p;
 284         return xstrdup("UNKNOWN");
 285 }
 286
 287 char *
 288 get_local_ipaddr(int sock)
 289 {
 290         char *p;
 291
 292         if ((p = get_socket_address(sock, 0, NI_NUMERICHOST)) != NULL)
 293                 return p;
 294         return xstrdup("UNKNOWN");
 295 }
 296
 297 char *
 298 get_local_name(int sock)
 299 {
 300         return get_socket_address(sock, 0, NI_NAMEREQD);
 301 }
 302
 303 /*
 304  * Returns the IP-address of the remote host as a string.  The returned
 305  * string must not be freed.
 306  */
 307
 308 const char *
 309 get_remote_ipaddr(void)
 310 {
 311         static char *canonical_host_ip = NULL;
 312
 313         /* Check whether we have cached the ipaddr. */
 314         if (canonical_host_ip == NULL) {
 315                 if (packet_connection_is_on_socket()) {
 316                         canonical_host_ip =
 317                             get_peer_ipaddr(packet_get_connection_in());
 318                         if (canonical_host_ip == NULL)
 319                                 cleanup_exit(255);
 320                 } else {
 321                         /* If not on socket, return UNKNOWN. */
 322                         canonical_host_ip = xstrdup("UNKNOWN");
 323                 }
 324         }
 325         return canonical_host_ip;
 326 }
 327
 328 const char *
 329 get_remote_name_or_ip(u_int utmp_len, int use_dns)
 330 {
 331         static const char *remote = "";
 332         if (utmp_len > 0)
 333                 remote = get_canonical_hostname(use_dns);
 334         if (utmp_len == 0 || strlen(remote) > utmp_len)
 335                 remote = get_remote_ipaddr();
 336         return remote;
 337 }
 338
 339 /* Returns the local/remote port for the socket. */
 340
 341 static int
 342 get_sock_port(int sock, int local)
 343 {
 344         struct sockaddr_storage from;
 345         socklen_t fromlen;
 346         char strport[NI_MAXSERV];
 347         int r;
 348
 349         /* Get IP address of client. */
 350         fromlen = sizeof(from);
 351         memset(&from, 0, sizeof(from));
 352         if (local) {
 353                 if (getsockname(sock, (struct sockaddr *)&from, &fromlen) < 0) {
 354                         error("getsockname failed: %.100s", strerror(errno));
 355                         return 0;
 356                 }
 357         } else {
 358                 if (getpeername(sock, (struct sockaddr *)&from, &fromlen) < 0) {
 359                         debug("getpeername failed: %.100s", strerror(errno));
 360                         return -1;
 361                 }
 362         }
 363
 364         /* Work around Linux IPv6 weirdness */
 365         if (from.ss_family == AF_INET6)
 366                 fromlen = sizeof(struct sockaddr_in6);
 367
 368         /* Return port number. */
 369         if ((r = getnameinfo((struct sockaddr *)&from, fromlen, NULL, 0,
 370             strport, sizeof(strport), NI_NUMERICSERV)) != 0)
 371                 fatal("get_sock_port: getnameinfo NI_NUMERICSERV failed: %s",
 372                     r == EAI_SYSTEM ? strerror(errno) : gai_strerror(r));
 373         return atoi(strport);
 374 }
 375
 376 /* Returns remote/local port number for the current connection. */
 377
 378 static int
 379 get_port(int local)
 380 {
 381         /*
 382          * If the connection is not a socket, return 65535.  This is
 383          * intentionally chosen to be an unprivileged port number.
 384          */
 385         if (!packet_connection_is_on_socket())
 386                 return 65535;
 387
 388         /* Get socket and return the port number. */
 389         return get_sock_port(packet_get_connection_in(), local);
 390 }
 391
 392 int
 393 get_peer_port(int sock)
 394 {
 395         return get_sock_port(sock, 0);
 396 }
 397
 398 int
 399 get_remote_port(void)
 400 {
 401         static int port = -1;
 402
 403         /* Cache to avoid getpeername() on a dead connection */
 404         if (port == -1)
 405                 port = get_port(0);
 406
 407         return port;
 408 }
 409
 410 int
 411 get_local_port(void)
 412 {
 413         return get_port(1);
 414 }