nasl_init.c

来自「大国补丁后的nessus2.2.8的源代码」· C语言 代码 · 共 456 行 · 第 1/2 页

  { "element", "udp", NULL },
  
  "set_udp_elements", set_udp_elements, 0,
  { "data", "udp", "uh_dport", "uh_sport", "uh_sum", "uh_ulen", NULL },
  
  "dump_udp_packet", dump_udp_packet, 999, { NULL },
  
  "forge_icmp_packet",forge_icmp_packet, 0,
  { "data", "icmp_cksum", "icmp_code", "icmp_id", "icmp_seq", "icmp_type", 
    "ip", "update_ip_len", NULL },
    
  "get_icmp_element", get_icmp_element, 0, 
  { "element", "icmp", NULL },

  "forge_igmp_packet", forge_igmp_packet, 0, 
  { "code", "data", "group", "ip", "type", "update_ip_len", NULL },
  "send_packet", nasl_send_packet, 99, 
  { "length", "pcap_active", "pcap_filter", "pcap_timeout", NULL },
  
  "pcap_next", nasl_pcap_next, 1, { "interface", "pcap_filter", "timeout", NULL},
  "send_capture", nasl_send_capture, 1, { "data", "interface", "length", "option", "pcap_filter", "socket", "timeout", NULL},
  
#ifdef HAVE_SSL
#ifdef HAVE_OPENSSL_MD2_H
  "MD2", nasl_md2, 1, { NULL },
#endif  
#ifdef HAVE_OPENSSL_MD4_H
  "MD4", nasl_md4, 1, { NULL },
#endif
  "MD5", nasl_md5, 1, { NULL }, 
  "SHA", nasl_sha, 1, { NULL },
  "SHA1", nasl_sha1, 1, { NULL },
  "RIPEMD160", nasl_ripemd160, 1, { NULL },
#ifdef HAVE_OPENSSL_MD2_H  
  "HMAC_MD2", nasl_hmac_md2, 0, { "data", "key", NULL },
#endif  
  "HMAC_MD5", nasl_hmac_md5, 0, { "data", "key", NULL },
  "HMAC_SHA", nasl_hmac_sha, 0, { "data", "key", NULL },
  "HMAC_SHA1", nasl_hmac_sha1, 0, { "data", "key", NULL },
  "HMAC_DSS", nasl_hmac_dss, 0, { "data", "key", NULL },
 
  "HMAC_RIPEMD160", nasl_hmac_ripemd160, 0, { "data", "key", NULL },
  "dh_generate_key", nasl_dh_generate_key, 0, { "g" , "p", "priv", NULL },
  "bn_random", nasl_bn_random, 0, { "need", NULL },
  "bn_cmp", nasl_bn_cmp, 0, { "key1", "key2", NULL },
  "dh_compute_key", nasl_dh_compute_key, 0, { "dh_server_pub", "g", "p", "priv_key", "pub_key", NULL },
  "rsa_public_decrypt", nasl_rsa_public_decrypt, 0, { "e", "n", "sig", NULL },
  "bf_cbc_encrypt", nasl_bf_cbc_encrypt, 0, { "data", "iv", "key", NULL},
  "bf_cbc_decrypt", nasl_bf_cbc_decrypt, 0, { "data", "iv", "key", NULL},
  "dsa_do_verify", nasl_dsa_do_verify, 0, { "data", "g", "p", "pub", "q", "r", "s", NULL },
  "pem_to_rsa", nasl_pem_to_rsa, 0, { "passphrase", "priv", NULL },
  "pem_to_dsa", nasl_pem_to_dsa, 0, { "passphrase", "priv", NULL },
  "rsa_sign", nasl_rsa_sign, 0, { "d", "data", "e", "n", NULL },
  "dsa_do_sign", nasl_dsa_do_sign, 0, { "data", "g", "p", "priv", "pub", "q", NULL },  
#endif  

  "pread", nasl_pread, 0, { "argv", "cd", "cmd", "nice", NULL },
  "find_in_path", nasl_find_in_path, 1, { NULL },
  "fread", nasl_fread, 1, { NULL },
  "fwrite", nasl_fwrite, 0, { "data", "file", NULL },
  "unlink", nasl_unlink, 1, { NULL },
  "get_tmp_dir", nasl_get_tmp_dir, 0, { NULL },


  "file_stat", nasl_file_stat, 1, { NULL },
  "file_open", nasl_file_open, 0, { "mode", "name", NULL },
  "file_close", nasl_file_close, 1, { NULL },
  "file_read", nasl_file_read, 0, { "fp", "length", NULL },
  "file_write", nasl_file_write, 0, { "data", "fp", NULL },
  "file_seek", nasl_file_seek, 0, { "fp", "offset", NULL }, 

  "shared_socket_register", nasl_shared_socket_register, 0, { "name", "socket", NULL},
  "shared_socket_acquire", nasl_shared_socket_acquire, 1, { NULL },
  "shared_socket_release", nasl_shared_socket_release, 1, { NULL },
  "shared_socket_destroy", nasl_shared_socket_destroy, 1, { NULL },

  NULL, NULL, 0, { NULL }
} ;

/* String variables */
static struct {
  const char	*name;
  const char	*val;
} libsvars[] = {
  "NESSUS_VERSION", VERSION,
  NULL, NULL, 
};

/* Integer variables */
static struct {
  const char	*name;
  int		val;
} libivars[] = {
  "TRUE",	1,
  "FALSE",	0,
  "pcap_timeout",	5,
  
  "IPPROTO_TCP", IPPROTO_TCP,
  "IPPROTO_UDP", IPPROTO_UDP,
  "IPPROTO_ICMP", IPPROTO_ICMP,
  "IPROTO_IP", IPPROTO_IP,
  "IPPROTO_IGMP", IPPROTO_IGMP,

  "ENCAPS_IP",     NESSUS_ENCAPS_IP,
  "ENCAPS_SSLv23", NESSUS_ENCAPS_SSLv23,
  "ENCAPS_SSLv2",  NESSUS_ENCAPS_SSLv2,
  "ENCAPS_SSLv3",  NESSUS_ENCAPS_SSLv3,
  "ENCAPS_TLSv1",  NESSUS_ENCAPS_TLSv1,

  "NASL_LEVEL",	NASL_LEVEL,

  "TH_FIN", TH_FIN,
  "TH_SYN", TH_SYN,
  "TH_RST", TH_RST,
  "TH_PUSH", TH_PUSH,
  "TH_ACK", TH_ACK,
  "TH_URG", TH_URG,

  "IP_RF", IP_RF,
  "IP_DF", IP_DF,
  "IP_MF", IP_MF,
  "IP_OFFMASK", IP_OFFMASK,

  "ACT_INIT", ACT_INIT, 
  "ACT_GATHER_INFO", ACT_GATHER_INFO,
  "ACT_ATTACK", ACT_ATTACK,
  "ACT_MIXED_ATTACK", ACT_MIXED_ATTACK,
  "ACT_DESTRUCTIVE_ATTACK", ACT_DESTRUCTIVE_ATTACK,
  "ACT_DENIAL", ACT_DENIAL,
  "ACT_SCANNER", ACT_SCANNER,
  "ACT_SETTINGS", ACT_SETTINGS,
  "ACT_KILL_HOST", ACT_KILL_HOST,
  "ACT_FLOOD", ACT_FLOOD,
  "ACT_END", ACT_END,

  "MSG_OOB", MSG_OOB,

  "NOERR",      NASL_ERR_NOERR,
  "ETIMEDOUT",  NASL_ERR_ETIMEDOUT,
  "ECONNRESET", NASL_ERR_ECONNRESET,
  "EUNREACH",   NASL_ERR_EUNREACH,
  "EUNKNOWN",   NASL_ERR_EUNKNOWN,

  NULL, 0, 
};
/* See also in exec.c:
 * COMMAND_LINE
 * description
 */

int init_nasl_library(lex_ctxt* lexic)
{
  int		i, j, c;
  nasl_func	*pf;
  named_nasl_var	*v;
  tree_cell	tc;
  const char	**p, *q;

  memset(&tc, 0, sizeof(tc));
  for (i = 0, c= 0; i < sizeof(libfuncs) / sizeof(libfuncs[0])-1; i ++)
    {

      if ((pf = insert_nasl_func(lexic, libfuncs[i].name, NULL)) == NULL)
	{
	  nasl_perror(lexic, "init_nasl2_library: could not define fct '%s'\n",
		  libfuncs[i].name);
	  continue;
	}
      pf->block = libfuncs[i].c_code;
      pf->flags |= FUNC_FLAG_INTERNAL;
      pf->nb_unnamed_args = libfuncs[i].unnamed;

      for (j = 0, p = libfuncs[i].args, q = NULL; (*p) != NULL; j ++)
	{
	  if (q != NULL && strcmp(q, *p) > 0)
	    nasl_perror(lexic, "init_nasl2_library: unsorted args for function %s: %s > %s\n", libfuncs[i].name, q, (*p));
	  q = (*p);
	  p ++;
	}
      pf->nb_named_args = j;
      pf->args_names = (char**)libfuncs[i].args;

      c++;
    }

  tc.type = CONST_INT;
  for (i = 0; i < sizeof(libivars) / sizeof(libivars[0])-1; i ++)
    {
      tc.x.i_val = libivars[i].val;
      if ((v = add_named_var_to_ctxt(lexic, libivars[i].name, &tc)) == NULL)
	{
	  nasl_perror(lexic, "init_nasl2_library: could not define var '%s'\n",
		  libivars[i].name);
	  continue;
	}
      c ++;
    }

  tc.type = CONST_DATA;
  for (i = 0; i < sizeof(libsvars) / sizeof(libsvars[0])-1; i ++)
    {
      tc.x.str_val = libsvars[i].val;
      tc.size = strlen(libsvars[i].val);
      if ((v = add_named_var_to_ctxt(lexic, libsvars[i].name, &tc)) == NULL)
	{
	  nasl_perror(lexic, "init_nasl2_library: could not define var '%s'\n",
		  libsvars[i].name);
	  continue;
	}
      c ++;
    }

  if (add_named_var_to_ctxt(lexic, "NULL", NULL) == NULL)
    nasl_perror(lexic, "init_nasl2_library: could not define var 'NULL'\n");

  return c;
}



char * nasl_version()
{
  static char vers[sizeof(VERSION) + 1];
  strncpy(vers, VERSION, sizeof(vers) - 1);
  vers[sizeof(vers) - 1 ] = '\0';
  return vers;
}