nasl_socket.h File Reference

#include "nasl_lex_ctxt.h"
#include "nasl_tree.h"

Include dependency graph for nasl_socket.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
tree_cell *	nasl_open_sock_tcp (lex_ctxt *)
	Open a TCP socket to the target host.
tree_cell *	nasl_open_sock_udp (lex_ctxt *)
tree_cell *	nasl_open_sock_tcp_bufsz (lex_ctxt *, int)
tree_cell *	nasl_socket_get_error (lex_ctxt *)
tree_cell *	nasl_open_priv_sock_tcp (lex_ctxt *)
tree_cell *	nasl_open_priv_sock_udp (lex_ctxt *)
tree_cell *	nasl_get_mtu (lex_ctxt *)
tree_cell *	nasl_send (lex_ctxt *)
tree_cell *	nasl_socket_negotiate_ssl (lex_ctxt *)
tree_cell *	nasl_socket_check_ssl_safe_renegotiation (lex_ctxt *)
	Check if Secure Renegotiation is supported in the server side.
tree_cell *	nasl_socket_ssl_do_handshake (lex_ctxt *)
	Do a re-handshake of the TLS/SSL protocol.
tree_cell *	nasl_recv (lex_ctxt *)
tree_cell *	nasl_recv_line (lex_ctxt *)
tree_cell *	nasl_socket_get_cert (lex_ctxt *)
tree_cell *	nasl_socket_get_ssl_session_id (lex_ctxt *)
tree_cell *	nasl_socket_get_ssl_version (lex_ctxt *)
tree_cell *	nasl_socket_get_ssl_ciphersuite (lex_ctxt *)
tree_cell *	nasl_socket_cert_verify (lex_ctxt *)
	Verify a certificate.
tree_cell *	nasl_close_socket (lex_ctxt *)
tree_cell *	nasl_join_multicast_group (lex_ctxt *)
tree_cell *	nasl_leave_multicast_group (lex_ctxt *)
tree_cell *	nasl_get_source_port (lex_ctxt *)
tree_cell *	nasl_get_sock_info (lex_ctxt *lexic)
	Get info pertaining to a socket.

Function Documentation

nasl_close_socket()

tree_cell * nasl_close_socket

(

lex_ctxt *

lexic

)

Definition at line 1012 of file nasl_socket.c.

{
  int soc;
  int type;
  unsigned int opt_len = sizeof (type);
  int e;
 
  soc = get_int_var_by_num (lexic, 0, -1);
  if (fd_is_stream (soc))
    {
      wait_before_next_probe ();
      return close_stream_connection (soc) < 0 ? NULL : FAKE_CELL;
    }
  if (lowest_socket == 0 || soc < lowest_socket)
    {
      nasl_perror (lexic, "close(%d): Invalid socket value\n", soc);
      return NULL;
    }
 
  e = getsockopt (soc, SOL_SOCKET, SO_TYPE, &type, &opt_len);
  if (e == 0)
    {
      if (type == SOCK_DGRAM)
        {
          rm_udp_data (lexic->script_infos, soc);
          return FAKE_CELL;
        }
      close (soc);
      return FAKE_CELL;
    }
  else
    nasl_perror (lexic, "close(%d): %s\n", soc, strerror (errno));
 
  return NULL;
}

References close_stream_connection(), FAKE_CELL, fd_is_stream(), get_int_var_by_num(), lowest_socket, nasl_perror(), rm_udp_data(), struct_lex_ctxt::script_infos, and wait_before_next_probe().

Referenced by http_close_socket().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_get_mtu()

tree_cell * nasl_get_mtu

(

lex_ctxt *

lexic

)

Definition at line 943 of file nasl_socket.c.

{
  int mtu;
  if ((mtu = get_mtu (plug_get_host_ip (lexic->script_infos))) == -1)
    {
      nasl_perror (
        lexic,
        "Unable to get MTU of used interface. get_mtu is not available.\n");
    }
  tree_cell *retc;
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = mtu;
 
  return retc;
}

References alloc_typed_cell(), CONST_INT, get_mtu(), TC::i_val, nasl_perror(), plug_get_host_ip(), struct_lex_ctxt::script_infos, and TC::x.

Here is the call graph for this function:

nasl_get_sock_info()

tree_cell * nasl_get_sock_info

(

lex_ctxt *

lexic

)

Get info pertaining to a socket.

NASL Function: get_sock_info\n

This function is used to retrieve various information about an active socket. It requires the NASL socket number and a string to select the information to retrieve.

Supported keywords are:

• dport Return the destination port. This is an integer. NOTE: Not yet implemented.
• sport Return the source port. This is an integer. NOTE: Not yet implemented.
• encaps Return the encapsulation of the socket. Example output: "TLScustom".
• tls-proto Return a string with the actual TLS protocol in use. n/a" is returned if no SSL/TLS session is active. Example output: "TLSv1". - @a tls-kx Return a string describing the key exchange algorithm. Example output: "RSA". - @a tls-certtype Return the type of the certificate in use by the session. Example output: "X.509" - @a tls-cipher Return the cipher algorithm in use by the session; Example output: "AES-256-CBC". - @a tls-mac Return the message authentication algorithms used by the session. Example output: "SHA1". - @a tls-auth Return the peer's authentication type. Example output: "CERT".
• tls-cert Return the peer's certificates for an SSL or TLS connection. This is an array of binary strings or NULL if no certificate is known.

NASL Unnamed Parameters:\n

• A NASL socket
• A string keyword; see above.

NASL Named Parameters:\n

• asstring If true return a human readable string instead of an integer. Used only with these keywords: encaps.

NASL Returns:\n An integer or a string or NULL on error.

Parameters

[in]

lexic

Lexical context of the NASL interpreter.

Returns

A tree cell.

Definition at line 1297 of file nasl_socket.c.

{
  int sock;
  int type;
  int err;
  const char *keyword, *s;
  tree_cell *retc;
  int as_string;
  int transport;
  gnutls_session_t tls_session;
  char *strval;
  int intval;
 
  sock = get_int_var_by_num (lexic, 0, -1);
  if (sock <= 0)
    {
      nasl_perror (lexic, "error: socket %d is not valid\n");
      return NULL;
    }
 
  keyword = get_str_var_by_num (lexic, 1);
  if (!keyword
      || !((type = get_var_type_by_num (lexic, 1)) == VAR2_STRING
           || type == VAR2_DATA))
    {
      nasl_perror (lexic, "error: second argument is not of type string\n");
      return NULL;
    }
 
  as_string = !!get_int_var_by_name (lexic, "asstring", 0);
 
  transport = 0;
  strval = NULL;
  intval = 0;
  retc = FAKE_CELL; /* Dummy value to detect retc == NULL.  */
 
  {
    void *tmp = NULL;
    err = get_sock_infos (sock, &transport, &tmp);
    tls_session = tmp;
  }
  if (err)
    {
      nasl_perror (lexic, "error retrieving infos for socket %d: %s\n", sock,
                   strerror (err));
      retc = NULL;
    }
  else if (!strcmp (keyword, "encaps"))
    {
      if (as_string)
        strval = g_strdup (get_encaps_name (transport));
      else
        intval = transport;
    }
  else if (!strcmp (keyword, "tls-proto"))
    {
      if (!tls_session)
        s = "n/a";
      else
        s =
          gnutls_protocol_get_name (gnutls_protocol_get_version (tls_session));
      strval = g_strdup (s ? s : "[?]");
    }
  else if (!strcmp (keyword, "tls-kx"))
    {
      if (!tls_session)
        s = "n/a";
      else
        s = gnutls_kx_get_name (gnutls_kx_get (tls_session));
      strval = g_strdup (s ? s : "");
    }
  else if (!strcmp (keyword, "tls-certtype"))
    {
      if (!tls_session)
        s = "n/a";
      else
        s = gnutls_certificate_type_get_name (
          gnutls_certificate_type_get (tls_session));
      strval = g_strdup (s ? s : "");
    }
  else if (!strcmp (keyword, "tls-cipher"))
    {
      if (!tls_session)
        s = "n/a";
      else
        s = gnutls_cipher_get_name (gnutls_cipher_get (tls_session));
      strval = g_strdup (s ? s : "");
    }
  else if (!strcmp (keyword, "tls-mac"))
    {
      if (!tls_session)
        s = "n/a";
      else
        s = gnutls_mac_get_name (gnutls_mac_get (tls_session));
      strval = g_strdup (s ? s : "");
    }
  else if (!strcmp (keyword, "tls-auth"))
    {
      if (!tls_session)
        s = "n/a";
      else
        {
          switch (gnutls_auth_get_type (tls_session))
            {
            case GNUTLS_CRD_ANON:
              s = "ANON";
              break;
            case GNUTLS_CRD_CERTIFICATE:
              s = "CERT";
              break;
            case GNUTLS_CRD_PSK:
              s = "PSK";
              break;
            case GNUTLS_CRD_SRP:
              s = "SRP";
              break;
            default:
              s = "[?]";
              break;
            }
        }
      strval = g_strdup (s);
    }
  else if (!strcmp (keyword, "tls-cert"))
    {
      /* We only support X.509 for now.  GNUTLS also allows for
         OpenPGP, but we are not prepared for that.  */
      if (tls_session
          && gnutls_certificate_type_get (tls_session) == GNUTLS_CRT_X509)
        {
          const gnutls_datum_t *list;
          unsigned int nlist = 0;
          nasl_array *a;
          anon_nasl_var v;
 
          list = gnutls_certificate_get_peers (tls_session, &nlist);
          if (!list)
            retc = NULL; /* No certificate or other error.  */
          else
            {
              unsigned int i;
              retc = alloc_typed_cell (DYN_ARRAY);
              retc->x.ref_val = a = g_malloc0 (sizeof *a);
 
              for (i = 0; i < nlist; i++)
                {
                  memset (&v, 0, sizeof v);
                  v.var_type = VAR2_DATA;
                  v.v.v_str.s_val = list[i].data;
                  v.v.v_str.s_siz = list[i].size;
                  add_var_to_list (a, i, &v);
                }
            }
        }
    }
  else
    {
      nasl_perror (lexic, "unknown keyword '%s'\n", keyword);
      retc = NULL;
    }
 
  if (!retc)
    ;
  else if (retc != FAKE_CELL)
    ; /* Already allocated.  */
  else if (strval)
    {
      retc = alloc_typed_cell (CONST_STR);
      retc->x.str_val = strval;
      retc->size = strlen (strval);
    }
  else
    {
      retc = alloc_typed_cell (CONST_INT);
      retc->x.i_val = intval;
    }
 
  return retc;
}

References add_var_to_list(), alloc_typed_cell(), CONST_INT, CONST_STR, DYN_ARRAY, FAKE_CELL, get_encaps_name(), get_int_var_by_name(), get_int_var_by_num(), get_sock_infos(), get_str_var_by_num(), get_var_type_by_num(), TC::i_val, nasl_perror(), TC::ref_val, st_nasl_string::s_siz, st_nasl_string::s_val, TC::size, TC::str_val, st_a_nasl_var::v, st_a_nasl_var::v_str, VAR2_DATA, VAR2_STRING, st_a_nasl_var::var_type, and TC::x.

Here is the call graph for this function:

nasl_get_source_port()

tree_cell * nasl_get_source_port

(

lex_ctxt *

lexic

)

Definition at line 1155 of file nasl_socket.c.

{
  struct sockaddr_in ia;
  int s, fd;
  unsigned int l;
  tree_cell *retc;
  int type;
  unsigned int type_len = sizeof (type);
 
  s = get_int_var_by_num (lexic, 0, -1);
  if (s < 0)
    {
      nasl_perror (lexic, "get_source_port: missing socket parameter\n");
      return NULL;
    }
  if (!fd_is_stream (s)
      && getsockopt (s, SOL_SOCKET, SO_TYPE, &type, &type_len) == 0
      && type == SOCK_DGRAM)
    fd = s;
  else
    fd = openvas_get_socket_from_connection (s);
 
  if (fd < 0)
    {
      nasl_perror (lexic, "get_source_port: invalid socket parameter %d\n", s);
      return NULL;
    }
  l = sizeof (ia);
  if (getsockname (fd, (struct sockaddr *) &ia, &l) < 0)
    {
      nasl_perror (lexic, "get_source_port: getsockname(%d): %s\n", fd,
                   strerror (errno));
      return NULL;
    }
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = ntohs (ia.sin_port);
  return retc;
}

References alloc_typed_cell(), CONST_INT, fd_is_stream(), get_int_var_by_num(), TC::i_val, nasl_perror(), openvas_get_socket_from_connection(), and TC::x.

Here is the call graph for this function:

nasl_join_multicast_group()

tree_cell * nasl_join_multicast_group

(

lex_ctxt *

lexic

)

Definition at line 1057 of file nasl_socket.c.

{
  char *a;
  int i, j;
  struct ip_mreq m;
  tree_cell *retc = NULL;
 
  a = get_str_var_by_num (lexic, 0);
  if (a == NULL)
    {
      nasl_perror (lexic, "join_multicast_group: missing parameter\n");
      return NULL;
    }
  if (!inet_aton (a, &m.imr_multiaddr))
    {
      nasl_perror (lexic, "join_multicast_group: invalid parameter '%s'\n", a);
      return NULL;
    }
  m.imr_interface.s_addr = INADDR_ANY;
 
  j = -1;
  for (i = 0; i < jmg_max; i++)
    if (jmg_desc[i].in.s_addr == m.imr_multiaddr.s_addr
        && jmg_desc[i].count > 0)
      {
        jmg_desc[i].count++;
        break;
      }
    else if (jmg_desc[i].count <= 0)
      j = i;
 
  if (i >= jmg_max)
    {
      int s = socket (AF_INET, SOCK_DGRAM, 0);
      if (s < 0)
        {
          nasl_perror (lexic, "join_multicast_group: socket: %s\n",
                       strerror (errno));
          return NULL;
        }
 
      if (setsockopt (s, IPPROTO_IP, IP_ADD_MEMBERSHIP, &m, sizeof (m)) < 0)
        {
          nasl_perror (
            lexic, "join_multicast_group: setsockopt(IP_ADD_MEMBERSHIP): %s\n",
            strerror (errno));
          close (s);
          return NULL;
        }
 
      if (j < 0)
        {
          jmg_desc = g_realloc (jmg_desc, sizeof (*jmg_desc) * (jmg_max + 1));
          j = jmg_max++;
        }
      jmg_desc[j].s = s;
      jmg_desc[j].in = m.imr_multiaddr;
      jmg_desc[j].count = 1;
    }
 
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = 1;
  return retc;
}

References alloc_typed_cell(), CONST_INT, get_str_var_by_num(), jmg_desc, jmg_max, and nasl_perror().

Here is the call graph for this function:

nasl_leave_multicast_group()

tree_cell * nasl_leave_multicast_group

(

lex_ctxt *

lexic

)

Definition at line 1123 of file nasl_socket.c.

{
  char *a;
  struct in_addr ia;
  int i;
 
  a = get_str_var_by_num (lexic, 0);
  if (a == NULL)
    {
      nasl_perror (lexic, "leave_multicast_group: missing parameter\n");
      return NULL;
    }
  if (!inet_aton (a, &ia))
    {
      nasl_perror (lexic, "leave_multicast_group: invalid parameter '%s'\n", a);
      return NULL;
    }
 
  for (i = 0; i < jmg_max; i++)
    if (jmg_desc[i].count > 0 && jmg_desc[i].in.s_addr == ia.s_addr)
      {
        if (--jmg_desc[i].count <= 0)
          close (jmg_desc[i].s);
        return FAKE_CELL;
      }
 
  nasl_perror (lexic, "leave_multicast_group: never joined group %s\n", a);
  return NULL;
}

References FAKE_CELL, get_str_var_by_num(), jmg_desc, jmg_max, and nasl_perror().

Here is the call graph for this function:

nasl_open_priv_sock_tcp()

tree_cell * nasl_open_priv_sock_tcp

(

lex_ctxt *

lexic

)

Definition at line 395 of file nasl_socket.c.

{
  return nasl_open_privileged_socket (lexic, IPPROTO_TCP);
}

References nasl_open_privileged_socket().

Here is the call graph for this function:

nasl_open_priv_sock_udp()

tree_cell * nasl_open_priv_sock_udp

(

lex_ctxt *

lexic

)

Definition at line 401 of file nasl_socket.c.

{
  return nasl_open_privileged_socket (lexic, IPPROTO_UDP);
}

References nasl_open_privileged_socket().

Here is the call graph for this function:

nasl_open_sock_tcp()

tree_cell * nasl_open_sock_tcp

(

lex_ctxt *

lexic

)

Open a TCP socket to the target host.

NASL Function: open_sock_tcp\n

This function is used to create a TCP connection to the target host. It requires the port number as its argument and has various optional named arguments to control encapsulation, timeout and buffering.

NASL Unnamed Parameters:\n

• A non-negative integer with the TCP port number.

NASL Named Parameters:\n

• bufsz An integer with the the size buffer size. Note that by default, no buffering is used.
• timeout An integer with the timeout value in seconds. The default timeout is controlled by a global value.
• transport One of the ENCAPS_* constants to force a specific encapsulation mode or force trying of all modes (ENCAPS_AUTO). This is for example useful to select a specific TLS or SSL version or use specific TLS connection setup priorities. See get_port_transport for a description of the ENCAPS constants.
• priority A string value with priorities for an TLS encapsulation. For the syntax of the priority string see the GNUTLS manual. This argument is only used in ENCAPS_TLScustom encapsulation.

NASL Returns:\n A positive integer as a NASL socket, 0 on connection error or

NULL on other errors.

Parameters

[in]

lexic

Lexical context of the NASL interpreter.

Returns

A tree cell.

Definition at line 509 of file nasl_socket.c.

{
  return nasl_open_sock_tcp_bufsz (lexic, -1);
}

References nasl_open_sock_tcp_bufsz().

Here is the call graph for this function:

nasl_open_sock_tcp_bufsz()

tree_cell * nasl_open_sock_tcp_bufsz	(	lex_ctxt *	lexic,
		int	bufsz )

Definition at line 409 of file nasl_socket.c.

{
  int soc = -1;
  struct script_infos *script_infos = lexic->script_infos;
  int to, port;
  int transport = -1;
  const char *priority;
  tree_cell *retc;
 
  to = get_int_var_by_name (lexic, "timeout", lexic->recv_timeout * 2);
  if (to < 0)
    to = 10;
 
  transport = get_int_var_by_name (lexic, "transport", -1);
 
  if (transport == OPENVAS_ENCAPS_TLScustom)
    {
      int type;
      priority = get_str_var_by_name (lexic, "priority");
      if (!priority)
        priority = NULL;
      type = get_var_type_by_name (lexic, "priority");
      if (type != VAR2_STRING && type != VAR2_DATA)
        priority = NULL;
    }
  else
    priority = NULL;
 
  if (bufsz < 0)
    bufsz = get_int_var_by_name (lexic, "bufsz", 0);
 
  port = get_int_var_by_num (lexic, 0, -1);
  if (port < 0)
    return NULL;
 
  wait_before_next_probe ();
 
  /* If "transport" has not been given, use auto detection if enabled
     in the KB. if "transport" has been given with a value of 0 force
     autodetection reagardless of what the KB tells.  */
  if (transport < 0)
    soc = open_stream_auto_encaps_ext (script_infos, port, to, 0);
  else if (transport == 0)
    soc = open_stream_auto_encaps_ext (script_infos, port, to, 1);
  else
    soc = open_stream_connection_ext (script_infos, port, transport, to,
                                      priority, NO_PRIORITY_FLAGS);
  if (bufsz > 0 && soc >= 0)
    {
      if (stream_set_buffer (soc, bufsz) < 0)
        nasl_perror (lexic, "stream_set_buffer: soc=%d,bufsz=%d\n", soc, bufsz);
    }
 
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = soc < 0 ? 0 : soc;
 
  return retc;
}

References alloc_typed_cell(), CONST_INT, get_int_var_by_name(), get_int_var_by_num(), get_str_var_by_name(), get_var_type_by_name(), TC::i_val, nasl_perror(), NO_PRIORITY_FLAGS, open_stream_auto_encaps_ext(), open_stream_connection_ext(), OPENVAS_ENCAPS_TLScustom, struct_lex_ctxt::recv_timeout, struct_lex_ctxt::script_infos, stream_set_buffer(), VAR2_DATA, VAR2_STRING, wait_before_next_probe(), and TC::x.

Referenced by http_open_socket(), and nasl_open_sock_tcp().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_open_sock_udp()

tree_cell * nasl_open_sock_udp

(

lex_ctxt *

lexic

)

Definition at line 521 of file nasl_socket.c.

{
  int soc;
  tree_cell *retc;
  int port;
  struct sockaddr_in soca;
  struct sockaddr_in6 soca6;
  struct script_infos *script_infos = lexic->script_infos;
  struct in6_addr *ia;
 
  port = get_int_var_by_num (lexic, 0, -1);
  if (port < 0)
    return NULL;
 
  ia = plug_get_host_ip (script_infos);
  if (ia == NULL)
    return NULL;
  if (IN6_IS_ADDR_V4MAPPED (ia))
    {
      bzero (&soca, sizeof (soca));
      soca.sin_addr.s_addr = ia->s6_addr32[3];
      soca.sin_port = htons (port);
      soca.sin_family = AF_INET;
 
      soc = socket (AF_INET, SOCK_DGRAM, 0);
      if (soc < 0)
        return NULL;
      gvm_source_set_socket (soc, 0, AF_INET);
      if (connect (soc, (struct sockaddr *) &soca, sizeof (soca)) < 0)
        {
          close (soc);
          return NULL;
        }
    }
  else
    {
      bzero (&soca6, sizeof (soca6));
      memcpy (&soca6.sin6_addr, ia, sizeof (struct in6_addr));
      soca6.sin6_port = htons (port);
      soca6.sin6_family = AF_INET6;
 
      soc = socket (AF_INET6, SOCK_DGRAM, 0);
      if (soc < 0)
        return NULL;
      gvm_source_set_socket (soc, 0, AF_INET6);
      if (connect (soc, (struct sockaddr *) &soca6, sizeof (soca6)) < 0)
        {
          close (soc);
          return NULL;
        }
    }
 
  if (soc > 0 && lowest_socket == 0)
    lowest_socket = soc;
 
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = soc;
  return retc;
}

References alloc_typed_cell(), CONST_INT, get_int_var_by_num(), TC::i_val, lowest_socket, plug_get_host_ip(), struct_lex_ctxt::script_infos, and TC::x.

Here is the call graph for this function:

nasl_recv()

tree_cell * nasl_recv

(

lex_ctxt *

lexic

)

Definition at line 754 of file nasl_socket.c.

{
  char *data, *resend_data;
  int rd_len;
  long int len = get_int_var_by_name (lexic, "length", -1);
  long int min_len = get_int_var_by_name (lexic, "min", -1);
  int soc = get_int_var_by_name (lexic, "socket", 0);
  int to = get_int_var_by_name (lexic, "timeout", lexic->recv_timeout);
  fd_set rd;
  struct timeval tv;
  long int new_len = 0;
  int type = -1;
  unsigned int opt_len = sizeof (type);
  int e;
 
  if (len <= 0 || soc <= 0)
    return NULL;
 
  tv.tv_sec = to;
  tv.tv_usec = 0;
 
  data = g_malloc0 (len);
  if (!fd_is_stream (soc))
    e = getsockopt (soc, SOL_SOCKET, SO_TYPE, &type, &opt_len);
  else
    e = -1;
 
  if (e == 0 && type == SOCK_DGRAM)
    {
      /* As UDP packets may be lost, we retry up to 5 times */
      int retries = 5;
      int i;
 
      tv.tv_sec = to / retries;
      tv.tv_usec = (to % retries) * 100000;
 
      for (i = 0; i < retries; i++)
        {
          FD_ZERO (&rd);
          FD_SET (soc, &rd);
 
          if (select (soc + 1, &rd, NULL, NULL, &tv) > 0)
            {
              int alen;
              alen = recv (soc, data + new_len, len - new_len, 0);
 
              if (alen <= 0)
                {
                  if (!new_len)
                    {
                      g_free (data);
                      return NULL;
                    }
                }
              else
                new_len += alen;
 
              break; /* UDP data is never fragmented */
            }
          else
            {
              /* The packet may have been lost en route - we resend it */
 
              resend_data = get_udp_data (lexic->script_infos, soc, &rd_len);
              if (resend_data != NULL)
                send (soc, resend_data, rd_len, 0);
              tv.tv_sec = to / retries;
              tv.tv_usec = (to % retries) * 100000;
            }
        }
    }
  else
    {
      int old = stream_set_timeout (soc, tv.tv_sec);
      new_len = read_stream_connection_min (soc, data, min_len, len);
      stream_set_timeout (soc, old);
    }
  if (new_len > 0)
    {
      tree_cell *retc = alloc_typed_cell (CONST_DATA);
      retc->x.str_val = g_memdup2 (data, new_len);
      retc->size = new_len;
      g_free (data);
      return retc;
    }
  else
    {
      g_free (data);
      return NULL;
    }
}

References alloc_typed_cell(), CONST_DATA, fd_is_stream(), get_int_var_by_name(), get_udp_data(), len, read_stream_connection_min(), struct_lex_ctxt::recv_timeout, struct_lex_ctxt::script_infos, TC::size, TC::str_val, stream_set_timeout(), timeval(), and TC::x.

Here is the call graph for this function:

nasl_recv_line()

tree_cell * nasl_recv_line

(

lex_ctxt *

lexic

)

Definition at line 847 of file nasl_socket.c.

{
  long int len = get_int_var_by_name (lexic, "length", -1);
  int soc = get_int_var_by_name (lexic, "socket", 0);
  int timeout = get_int_var_by_name (lexic, "timeout", -1);
  char *data;
  long int new_len = 0;
  long int n = 0;
  tree_cell *retc;
  time_t t1 = 0;
 
  if (len == -1 || soc <= 0)
    {
      nasl_perror (lexic, "recv_line: missing or undefined parameter"
                          " length or socket\n");
      return NULL;
    }
 
  if (timeout >= 0) /* sycalls are much more expensive than simple tests */
    t1 = time (NULL);
 
  if (fd_is_stream (soc) != 0)
    {
      int bufsz = stream_get_buffer_sz (soc);
      if (bufsz <= 0)
        stream_set_buffer (soc, len + 1);
    }
 
  data = g_malloc0 (len + 1);
  for (;;)
    {
      int e = read_stream_connection_min (soc, data + n, 1, 1);
      if (e < 0)
        break;
      if (e == 0)
        {
          if (timeout >= 0 && time (NULL) - t1 < timeout)
            continue;
          else
            break;
        }
      n++;
      if ((data[n - 1] == '\n') || (n >= len))
        break;
    }
 
  if (n <= 0)
    {
      g_free (data);
      return NULL;
    }
 
  new_len = n;
 
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = new_len;
  retc->x.str_val = g_memdup2 (data, new_len + 1);
  g_free (data);
 
  return retc;
}

References alloc_typed_cell(), CONST_DATA, fd_is_stream(), get_int_var_by_name(), len, nasl_perror(), read_stream_connection_min(), TC::size, TC::str_val, stream_get_buffer_sz(), stream_set_buffer(), and TC::x.

Here is the call graph for this function:

nasl_send()

tree_cell * nasl_send

(

lex_ctxt *

lexic

)

Definition at line 960 of file nasl_socket.c.

{
  int soc = get_int_var_by_name (lexic, "socket", 0);
  char *data = get_str_var_by_name (lexic, "data");
  int option = get_int_var_by_name (lexic, "option", 0);
  long int length = get_int_var_by_name (lexic, "length", 0);
  long data_length = get_var_size_by_name (lexic, "data");
  int n;
  int mtu = -1;
  tree_cell *retc;
  int type;
  unsigned int type_len = sizeof (type);
 
  if (soc <= 0 || data == NULL)
    {
      nasl_perror (lexic, "Syntax error with the send() function\n");
      nasl_perror (lexic,
                   "Correct syntax is : send(socket:<soc>, data:<data>\n");
      return NULL;
    }
 
  if (length <= 0 || length > data_length)
    length = data_length;
 
  if (!fd_is_stream (soc)
      && getsockopt (soc, SOL_SOCKET, SO_TYPE, &type, &type_len) == 0
      && type == SOCK_DGRAM)
    {
      if ((mtu = get_udp_payload_size (plug_get_host_ip (lexic->script_infos)))
            > 0
          && mtu < length)
        nasl_perror (lexic,
                     "data payload is larger (%d) than max udp payload (%d)\n",
                     length, mtu);
 
      n = send (soc, data, length, option);
      add_udp_data (lexic->script_infos, soc, data, length);
    }
  else
    {
      wait_before_next_probe ();
      n = nsend (soc, data, length, option);
    }
 
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = n;
 
  return retc;
}

References add_udp_data(), alloc_typed_cell(), CONST_INT, fd_is_stream(), get_int_var_by_name(), get_str_var_by_name(), get_udp_payload_size(), get_var_size_by_name(), TC::i_val, length, nasl_perror(), nsend(), option, plug_get_host_ip(), struct_lex_ctxt::script_infos, wait_before_next_probe(), and TC::x.

Referenced by nasl_send_capture().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_socket_cert_verify()

tree_cell * nasl_socket_cert_verify

(

lex_ctxt *

lexic

)

Verify a certificate.

NASL Function: socket_cert_verify\n

This function is used to retrieve and verify a certificate from an active socket. It requires the NASL socket number.

NASL Named Parameters:\n

• socket A NASL socket.

NASL Returns:\n 0 in case of successful verification. A positive integer in

case of a verification error or NULL on other errors.

Parameters

[in]

lexic

Lexical context of the NASL interpreter.

Returns

A tree cell.

Definition at line 1496 of file nasl_socket.c.

{
  int soc, err;
  int ret;
  tree_cell *retc;
  gnutls_x509_crt_t *cert = NULL;
  gnutls_x509_trust_list_t ca_list;
  unsigned int ca_list_size = 0;
  unsigned int i, cert_n = 0;
  unsigned int voutput;
  const gnutls_datum_t *certs;
 
  int transport;
  gnutls_session_t tls_session;
 
  soc = get_int_var_by_name (lexic, "socket", -1);
  if (soc < 0)
    {
      nasl_perror (lexic, "socket_get_cert: Erroneous socket value %d\n", soc);
      return NULL;
    }
 
  {
    void *tmp = NULL;
    err = get_sock_infos (soc, &transport, &tmp);
    tls_session = tmp;
  }
  if (err)
    {
      nasl_perror (lexic, "error retrieving tls_session for socket %d: %s\n",
                   soc, strerror (err));
      return NULL;
    }
 
  /* We only support X.509 for now.  GNUTLS also allows for
     OpenPGP, but we are not prepared for that.  */
  if (tls_session
      && gnutls_certificate_type_get (tls_session) == GNUTLS_CRT_X509)
    {
      certs = gnutls_certificate_get_peers (tls_session, &cert_n);
      if (!certs)
        return NULL; /* No certificate or other error.  */
    }
  else
    return NULL;
 
  cert = g_malloc0 (sizeof (*cert) * cert_n);
  for (i = 0; i < cert_n; i++)
    {
      if (gnutls_x509_crt_init (&cert[i]) != GNUTLS_E_SUCCESS)
        {
          g_free (cert);
          return NULL;
        }
      if (gnutls_x509_crt_import (cert[i], &certs[i], GNUTLS_X509_FMT_DER)
          != GNUTLS_E_SUCCESS)
        {
          g_free (cert);
          return NULL;
        }
    }
 
  /* Init ca_list and load system CA trust list */
  ret = gnutls_x509_trust_list_init (&ca_list, ca_list_size);
  if (ret < 0)
    {
      g_free (cert);
      return NULL;
    }
  ret = gnutls_x509_trust_list_add_system_trust (ca_list, 0, 0);
  if (ret < 0)
    {
      g_free (cert);
      return NULL;
    }
 
  /* Certificate verification against a trust list*/
  if (gnutls_x509_trust_list_verify_crt (ca_list, cert, cert_n, 0, &voutput,
                                         NULL)
      != GNUTLS_E_SUCCESS)
    {
      g_free (cert);
      return NULL;
    }
  g_free (cert);
 
  ret = voutput;
 
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = ret;
  return retc;
}

References alloc_typed_cell(), CONST_INT, get_int_var_by_name(), get_sock_infos(), TC::i_val, nasl_perror(), and TC::x.

Here is the call graph for this function:

nasl_socket_check_ssl_safe_renegotiation()

tree_cell * nasl_socket_check_ssl_safe_renegotiation

(

lex_ctxt *

lexic

)

Check if Secure Renegotiation is supported in the server side.

NASL Function: socket_check_ssl_safe_renegotiation\n

NASL Named Parameters:\n

• socket An already stablished ssl/tls session.

NASL Returns:\n An 1 if supported, 0 otherwise. Null or -1 on error.

Definition at line 626 of file nasl_socket.c.

{
  int soc, ret;
  tree_cell *retc;
  soc = get_int_var_by_name (lexic, "socket", -1);
  if (soc < 0)
    {
      nasl_perror (lexic, "socket_get_cert: Erroneous socket value %d\n", soc);
      return NULL;
    }
  ret = socket_ssl_safe_renegotiation_status (soc);
 
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = ret;
  return retc;
}

References alloc_typed_cell(), CONST_INT, get_int_var_by_name(), TC::i_val, nasl_perror(), socket_ssl_safe_renegotiation_status(), and TC::x.

Here is the call graph for this function:

nasl_socket_get_cert()

tree_cell * nasl_socket_get_cert

(

lex_ctxt *

lexic

)

Definition at line 676 of file nasl_socket.c.

{
  int soc, cert_len = 0;
  tree_cell *retc;
  void *cert;
 
  soc = get_int_var_by_name (lexic, "socket", -1);
  if (soc < 0)
    {
      nasl_perror (lexic, "socket_get_cert: Erroneous socket value %d\n", soc);
      return NULL;
    }
  socket_get_cert (soc, &cert, &cert_len);
  if (cert_len <= 0)
    return NULL;
  retc = alloc_typed_cell (CONST_DATA);
  retc->x.str_val = cert;
  retc->size = cert_len;
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_int_var_by_name(), nasl_perror(), TC::size, socket_get_cert(), TC::str_val, and TC::x.

Here is the call graph for this function:

nasl_socket_get_error()

tree_cell * nasl_socket_get_error

(

lex_ctxt *

lexic

)

Definition at line 1195 of file nasl_socket.c.

{
  int soc = get_int_var_by_num (lexic, 0, -1);
  tree_cell *retc;
  int err;
 
  if (soc < 0 || !fd_is_stream (soc))
    return NULL;
 
  err = stream_get_err (soc);
  retc = alloc_typed_cell (CONST_INT);
 
  switch (err)
    {
    case 0:
      retc->x.i_val = NASL_ERR_NOERR;
      break;
    case ETIMEDOUT:
      retc->x.i_val = NASL_ERR_ETIMEDOUT;
      break;
    case EBADF:
    case EPIPE:
    case ECONNRESET:
    case ENOTSOCK:
      retc->x.i_val = NASL_ERR_ECONNRESET;
      break;
 
    case ENETUNREACH:
    case EHOSTUNREACH:
      retc->x.i_val = NASL_ERR_EUNREACH;
      break;
    case -1:
      g_message ("socket_get_error: Erroneous socket value %d", soc);
      break;
 
    default:
      g_message ("Unknown error %d %s", err, strerror (err));
    }
 
  return retc;
}

References alloc_typed_cell(), CONST_INT, fd_is_stream(), get_int_var_by_num(), TC::i_val, NASL_ERR_ECONNRESET, NASL_ERR_ETIMEDOUT, NASL_ERR_EUNREACH, NASL_ERR_NOERR, stream_get_err(), and TC::x.

Here is the call graph for this function:

nasl_socket_get_ssl_ciphersuite()

tree_cell * nasl_socket_get_ssl_ciphersuite

(

lex_ctxt *

lexic

)

Definition at line 737 of file nasl_socket.c.

{
  int soc, result;
  tree_cell *retc;
 
  soc = get_int_var_by_name (lexic, "socket", -1);
  result = socket_get_ssl_ciphersuite (soc);
  if (result < 0)
    return NULL;
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = result;
  return retc;
}

References alloc_typed_cell(), CONST_INT, get_int_var_by_name(), TC::i_val, socket_get_ssl_ciphersuite(), and TC::x.

Here is the call graph for this function:

nasl_socket_get_ssl_session_id()

tree_cell * nasl_socket_get_ssl_session_id

(

lex_ctxt *

lexic

)

Definition at line 698 of file nasl_socket.c.

{
  int soc;
  size_t sid_len = 0;
  tree_cell *retc;
  void *sid;
 
  soc = get_int_var_by_name (lexic, "socket", -1);
  if (soc < 0)
    {
      nasl_perror (lexic, "socket_get_cert: Erroneous socket value %d\n", soc);
      return NULL;
    }
  socket_get_ssl_session_id (soc, &sid, &sid_len);
  if (sid == NULL || sid_len == 0)
    return NULL;
  retc = alloc_typed_cell (CONST_DATA);
  retc->x.str_val = sid;
  retc->size = sid_len;
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_int_var_by_name(), nasl_perror(), TC::size, socket_get_ssl_session_id(), TC::str_val, and TC::x.

Here is the call graph for this function:

nasl_socket_get_ssl_version()

tree_cell * nasl_socket_get_ssl_version

(

lex_ctxt *

lexic

)

Definition at line 721 of file nasl_socket.c.

{
  int soc;
  int version;
  tree_cell *retc;
 
  soc = get_int_var_by_name (lexic, "socket", -1);
  version = socket_get_ssl_version (soc);
  if (version < 0)
    return NULL;
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = version;
  return retc;
}

References alloc_typed_cell(), CONST_INT, get_int_var_by_name(), TC::i_val, socket_get_ssl_version(), and TC::x.

Here is the call graph for this function:

nasl_socket_negotiate_ssl()

tree_cell * nasl_socket_negotiate_ssl

(

lex_ctxt *

lexic

)

Definition at line 582 of file nasl_socket.c.

{
  int soc, transport, ret;
  tree_cell *retc;
 
  soc = get_int_var_by_name (lexic, "socket", -1);
  transport =
    get_int_var_by_name (lexic, "transport", OPENVAS_ENCAPS_TLScustom);
  if (soc < 0)
    {
      nasl_perror (lexic, "socket_ssl_negotiate: Erroneous socket value %d\n",
                   soc);
      return NULL;
    }
  if (transport == -1)
    transport = OPENVAS_ENCAPS_TLScustom;
  else if (!IS_ENCAPS_SSL (transport))
    {
      nasl_perror (lexic,
                   "socket_ssl_negotiate: Erroneous transport value %d\n",
                   transport);
      return NULL;
    }
  ret = socket_negotiate_ssl (soc, transport, lexic->script_infos);
  if (ret < 0)
    return NULL;
 
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = ret;
  return retc;
}

References alloc_typed_cell(), CONST_INT, get_int_var_by_name(), TC::i_val, IS_ENCAPS_SSL, nasl_perror(), OPENVAS_ENCAPS_TLScustom, struct_lex_ctxt::script_infos, socket_negotiate_ssl(), and TC::x.

Here is the call graph for this function:

nasl_socket_ssl_do_handshake()

tree_cell * nasl_socket_ssl_do_handshake

(

lex_ctxt *

lexic

)

Do a re-handshake of the TLS/SSL protocol.

NASL Function: socket_ssl_do_handshake\n

NASL Named Parameters:\n

• socket An already stablished TLS/SSL session.

NASL Returns:\n An 1 on success, less than 0 on handshake error.

Null on nasl error.

Parameters

[in]

lexic

Lexical context of NASL interpreter.

Definition at line 658 of file nasl_socket.c.

{
  int soc, ret;
  tree_cell *retc;
  soc = get_int_var_by_name (lexic, "socket", -1);
  if (soc < 0)
    {
      nasl_perror (lexic, "socket_get_cert: Erroneous socket value %d\n", soc);
      return NULL;
    }
  ret = socket_ssl_do_handshake (soc);
 
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = ret;
  return retc;
}

References alloc_typed_cell(), CONST_INT, get_int_var_by_name(), TC::i_val, nasl_perror(), socket_ssl_do_handshake(), and TC::x.

Here is the call graph for this function: