[BACK]Return to canohost.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/canohost.c between version 1.5 and 1.6

version 1.5, 1999/11/15 00:42:01 version 1.6, 1999/11/23 22:25:53
Line 20 
Line 20 
 #include "xmalloc.h"  #include "xmalloc.h"
 #include "ssh.h"  #include "ssh.h"
   
 /* Return the canonical name of the host at the other end of the socket.  /* Return the canonical name of the host at the other end of the socket.
    The caller should free the returned string with xfree. */     The caller should free the returned string with xfree. */
   
 char *get_remote_hostname(int socket)  char *
   get_remote_hostname(int socket)
 {  {
   struct sockaddr_in from;          struct sockaddr_in from;
   int fromlen, i;          int fromlen, i;
   struct hostent *hp;          struct hostent *hp;
   char name[MAXHOSTNAMELEN];          char name[MAXHOSTNAMELEN];
   
   /* Get IP address of client. */          /* Get IP address of client. */
   fromlen = sizeof(from);          fromlen = sizeof(from);
   memset(&from, 0, sizeof(from));          memset(&from, 0, sizeof(from));
   if (getpeername(socket, (struct sockaddr *)&from, &fromlen) < 0)          if (getpeername(socket, (struct sockaddr *) & from, &fromlen) < 0) {
     {                  debug("getpeername failed: %.100s", strerror(errno));
       debug("getpeername failed: %.100s", strerror(errno));                  fatal_cleanup();
       fatal_cleanup();          }
     }          /* Map the IP address to a host name. */
           hp = gethostbyaddr((char *) &from.sin_addr, sizeof(struct in_addr),
   /* Map the IP address to a host name. */                             from.sin_family);
   hp = gethostbyaddr((char *)&from.sin_addr, sizeof(struct in_addr),          if (hp) {
                      from.sin_family);                  /* Got host name, find canonic host name. */
   if (hp)                  if (strchr(hp->h_name, '.') != 0)
     {                          strlcpy(name, hp->h_name, sizeof(name));
       /* Got host name, find canonic host name. */                  else if (hp->h_aliases != 0
       if (strchr(hp->h_name, '.') != 0)                           && hp->h_aliases[0] != 0
         strlcpy(name, hp->h_name, sizeof(name));                           && strchr(hp->h_aliases[0], '.') != 0)
       else if (hp->h_aliases != 0                          strlcpy(name, hp->h_aliases[0], sizeof(name));
                && hp->h_aliases[0] != 0                  else
                && strchr(hp->h_aliases[0], '.') != 0)                          strlcpy(name, hp->h_name, sizeof(name));
         strlcpy(name, hp->h_aliases[0], sizeof(name));  
       else  
         strlcpy(name, hp->h_name, sizeof(name));  
   
       /* Convert it to all lowercase (which is expected by the rest of this  
          software). */  
       for (i = 0; name[i]; i++)  
         if (isupper(name[i]))  
           name[i] = tolower(name[i]);  
   
       /* Map it back to an IP address and check that the given address actually                  /* Convert it to all lowercase (which is expected by the
          is an address of this host.  This is necessary because anyone with                     rest of this software). */
          access to a name server can define arbitrary names for an IP address.                  for (i = 0; name[i]; i++)
          Mapping from name to IP address can be trusted better (but can still                          if (isupper(name[i]))
          be fooled if the intruder has access to the name server of the                                  name[i] = tolower(name[i]);
          domain). */  
       hp = gethostbyname(name);                  /* Map it back to an IP address and check that the given
       if (!hp)                     address actually is an address of this host.  This is
         {                     necessary because anyone with access to a name server
           log("reverse mapping checking gethostbyname for %.700s failed - POSSIBLE BREAKIN ATTEMPT!", name);                     can define arbitrary names for an IP address. Mapping
           strlcpy(name, inet_ntoa(from.sin_addr), sizeof name);                     from name to IP address can be trusted better (but can
           goto check_ip_options;                     still be fooled if the intruder has access to the name
                      server of the domain). */
                   hp = gethostbyname(name);
                   if (!hp) {
                           log("reverse mapping checking gethostbyname for %.700s failed - POSSIBLE BREAKIN ATTEMPT!", name);
                           strlcpy(name, inet_ntoa(from.sin_addr), sizeof name);
                           goto check_ip_options;
                   }
                   /* Look for the address from the list of addresses. */
                   for (i = 0; hp->h_addr_list[i]; i++)
                           if (memcmp(hp->h_addr_list[i], &from.sin_addr, sizeof(from.sin_addr))
                               == 0)
                                   break;
                   /* If we reached the end of the list, the address was not
                      there. */
                   if (!hp->h_addr_list[i]) {
                           /* Address not found for the host name. */
                           log("Address %.100s maps to %.600s, but this does not map back to the address - POSSIBLE BREAKIN ATTEMPT!",
                               inet_ntoa(from.sin_addr), name);
                           strlcpy(name, inet_ntoa(from.sin_addr), sizeof name);
                           goto check_ip_options;
                   }
                   /* Address was found for the host name.  We accept the host name. */
           } else {
                   /* Host name not found.  Use ascii representation of the address. */
                   strlcpy(name, inet_ntoa(from.sin_addr), sizeof name);
                   log("Could not reverse map address %.100s.", name);
         }          }
       /* Look for the address from the list of addresses. */  
       for (i = 0; hp->h_addr_list[i]; i++)  check_ip_options:
         if (memcmp(hp->h_addr_list[i], &from.sin_addr, sizeof(from.sin_addr))  
             == 0)          /* If IP options are supported, make sure there are none (log and
           break;             disconnect them if any are found).  Basically we are worried
       /* If we reached the end of the list, the address was not there. */             about source routing; it can be used to pretend you are
       if (!hp->h_addr_list[i])             somebody (ip-address) you are not. That itself may be "almost
              acceptable" under certain circumstances, but rhosts
              autentication is useless if source routing is accepted. Notice
              also that if we just dropped source routing here, the other
              side could use IP spoofing to do rest of the interaction and
              could still bypass security.  So we exit here if we detect any
              IP options. */
         {          {
           /* Address not found for the host name. */                  unsigned char options[200], *ucp;
           log("Address %.100s maps to %.600s, but this does not map back to the address - POSSIBLE BREAKIN ATTEMPT!",                  char text[1024], *cp;
               inet_ntoa(from.sin_addr), name);                  int option_size, ipproto;
           strlcpy(name, inet_ntoa(from.sin_addr), sizeof name);                  struct protoent *ip;
           goto check_ip_options;  
                   if ((ip = getprotobyname("ip")) != NULL)
                           ipproto = ip->p_proto;
                   else
                           ipproto = IPPROTO_IP;
                   option_size = sizeof(options);
                   if (getsockopt(0, ipproto, IP_OPTIONS, (char *) options,
                                  &option_size) >= 0 && option_size != 0) {
                           cp = text;
                           /* Note: "text" buffer must be at least 3x as big as options. */
                           for (ucp = options; option_size > 0; ucp++, option_size--, cp += 3)
                                   sprintf(cp, " %2.2x", *ucp);
                           log("Connection from %.100s with IP options:%.800s",
                               inet_ntoa(from.sin_addr), text);
                           packet_disconnect("Connection from %.100s with IP options:%.800s",
                                             inet_ntoa(from.sin_addr), text);
                   }
         }          }
       /* Address was found for the host name.  We accept the host name. */  
     }  
   else  
     {  
       /* Host name not found.  Use ascii representation of the address. */  
       strlcpy(name, inet_ntoa(from.sin_addr), sizeof name);  
       log("Could not reverse map address %.100s.", name);  
     }  
   
  check_ip_options:          return xstrdup(name);
   
   /* If IP options are supported, make sure there are none (log and disconnect  
      them if any are found).  Basically we are worried about source routing;  
      it can be used to pretend you are somebody (ip-address) you are not.  
      That itself may be "almost acceptable" under certain circumstances,  
      but rhosts autentication is useless if source routing is accepted.  
      Notice also that if we just dropped source routing here, the other  
      side could use IP spoofing to do rest of the interaction and could still  
      bypass security.  So we exit here if we detect any IP options. */  
   {  
     unsigned char options[200], *ucp;  
     char text[1024], *cp;  
     int option_size, ipproto;  
     struct protoent *ip;  
   
     if ((ip = getprotobyname("ip")) != NULL)  
       ipproto = ip->p_proto;  
     else  
       ipproto = IPPROTO_IP;  
     option_size = sizeof(options);  
     if (getsockopt(0, ipproto, IP_OPTIONS, (char *)options,  
                    &option_size) >= 0 && option_size != 0)  
       {  
         cp = text;  
         /* Note: "text" buffer must be at least 3x as big as options. */  
         for (ucp = options; option_size > 0; ucp++, option_size--, cp += 3)  
           sprintf(cp, " %2.2x", *ucp);  
         log("Connection from %.100s with IP options:%.800s",  
             inet_ntoa(from.sin_addr), text);  
         packet_disconnect("Connection from %.100s with IP options:%.800s",  
                           inet_ntoa(from.sin_addr), text);  
       }  
   }  
   
   return xstrdup(name);  
 }  }
   
 static char *canonical_host_name = NULL;  static char *canonical_host_name = NULL;
 static char *canonical_host_ip = NULL;  static char *canonical_host_ip = NULL;
   
 /* Return the canonical name of the host in the other side of the current  /* Return the canonical name of the host in the other side of the current
    connection.  The host name is cached, so it is efficient to call this     connection.  The host name is cached, so it is efficient to call this
    several times. */     several times. */
   
 const char *get_canonical_hostname()  const char *
   get_canonical_hostname()
 {  {
   /* Check if we have previously retrieved this same name. */          /* Check if we have previously retrieved this same name. */
   if (canonical_host_name != NULL)          if (canonical_host_name != NULL)
     return canonical_host_name;                  return canonical_host_name;
   
   /* Get the real hostname if socket; otherwise return UNKNOWN. */          /* Get the real hostname if socket; otherwise return UNKNOWN. */
   if (packet_get_connection_in() == packet_get_connection_out())          if (packet_get_connection_in() == packet_get_connection_out())
     canonical_host_name = get_remote_hostname(packet_get_connection_in());                  canonical_host_name = get_remote_hostname(packet_get_connection_in());
   else          else
     canonical_host_name = xstrdup("UNKNOWN");                  canonical_host_name = xstrdup("UNKNOWN");
   
   return canonical_host_name;          return canonical_host_name;
 }  }
   
 /* Returns the IP-address of the remote host as a string.  The returned  /* Returns the IP-address of the remote host as a string.  The returned
    string need not be freed. */     string need not be freed. */
   
 const char *get_remote_ipaddr()  const char *
   get_remote_ipaddr()
 {  {
   struct sockaddr_in from;          struct sockaddr_in from;
   int fromlen, socket;          int fromlen, socket;
   
   /* Check if we have previously retrieved this same name. */          /* Check if we have previously retrieved this same name. */
   if (canonical_host_ip != NULL)          if (canonical_host_ip != NULL)
     return canonical_host_ip;                  return canonical_host_ip;
   
   /* If not a socket, return UNKNOWN. */          /* If not a socket, return UNKNOWN. */
   if (packet_get_connection_in() != packet_get_connection_out())          if (packet_get_connection_in() != packet_get_connection_out()) {
     {                  canonical_host_ip = xstrdup("UNKNOWN");
       canonical_host_ip = xstrdup("UNKNOWN");                  return canonical_host_ip;
       return canonical_host_ip;          }
     }          /* Get client socket. */
           socket = packet_get_connection_in();
   
   /* Get client socket. */          /* Get IP address of client. */
   socket = packet_get_connection_in();          fromlen = sizeof(from);
           memset(&from, 0, sizeof(from));
           if (getpeername(socket, (struct sockaddr *) & from, &fromlen) < 0) {
                   debug("getpeername failed: %.100s", strerror(errno));
                   fatal_cleanup();
           }
           /* Get the IP address in ascii. */
           canonical_host_ip = xstrdup(inet_ntoa(from.sin_addr));
   
   /* Get IP address of client. */          /* Return ip address string. */
   fromlen = sizeof(from);          return canonical_host_ip;
   memset(&from, 0, sizeof(from));  
   if (getpeername(socket, (struct sockaddr *)&from, &fromlen) < 0)  
     {  
       debug("getpeername failed: %.100s", strerror(errno));  
       fatal_cleanup();  
     }  
   
   /* Get the IP address in ascii. */  
   canonical_host_ip = xstrdup(inet_ntoa(from.sin_addr));  
   
   /* Return ip address string. */  
   return canonical_host_ip;  
 }  }
   
 /* Returns the port of the peer of the socket. */  /* Returns the port of the peer of the socket. */
   
 int get_peer_port(int sock)  int
   get_peer_port(int sock)
 {  {
   struct sockaddr_in from;          struct sockaddr_in from;
   int fromlen;          int fromlen;
   
   /* Get IP address of client. */          /* Get IP address of client. */
   fromlen = sizeof(from);          fromlen = sizeof(from);
   memset(&from, 0, sizeof(from));          memset(&from, 0, sizeof(from));
   if (getpeername(sock, (struct sockaddr *)&from, &fromlen) < 0)          if (getpeername(sock, (struct sockaddr *) & from, &fromlen) < 0) {
     {                  debug("getpeername failed: %.100s", strerror(errno));
       debug("getpeername failed: %.100s", strerror(errno));                  fatal_cleanup();
       fatal_cleanup();          }
     }          /* Return port number. */
           return ntohs(from.sin_port);
   /* Return port number. */  
   return ntohs(from.sin_port);  
 }  }
   
 /* Returns the port number of the remote host.  */  /* Returns the port number of the remote host.  */
   
 int get_remote_port()  int
   get_remote_port()
 {  {
   int socket;          int socket;
   
   /* If the connection is not a socket, return 65535.  This is intentionally          /* If the connection is not a socket, return 65535.  This is
      chosen to be an unprivileged port number. */             intentionally chosen to be an unprivileged port number. */
   if (packet_get_connection_in() != packet_get_connection_out())          if (packet_get_connection_in() != packet_get_connection_out())
     return 65535;                  return 65535;
   
   /* Get client socket. */          /* Get client socket. */
   socket = packet_get_connection_in();          socket = packet_get_connection_in();
   
   /* Get and return the peer port number. */          /* Get and return the peer port number. */
   return get_peer_port(socket);          return get_peer_port(socket);
 }  }
Legend:
Removed from v.1.5  
changed lines
  Added in v.1.6