nasl_crypto.h File Reference

#include "nasl_lex_ctxt.h"

Include dependency graph for nasl_crypto.h:

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

Go to the source code of this file.

Macros
#define	MD4_DIGEST_LENGTH   16

Functions
tree_cell *	nasl_md2 (lex_ctxt *)
tree_cell *	nasl_md4 (lex_ctxt *)
tree_cell *	nasl_md5 (lex_ctxt *)
tree_cell *	nasl_sha (lex_ctxt *)
tree_cell *	nasl_sha1 (lex_ctxt *)
tree_cell *	nasl_sha256 (lex_ctxt *)
tree_cell *	nasl_sha512 (lex_ctxt *)
tree_cell *	nasl_ripemd160 (lex_ctxt *)
tree_cell *	nasl_hmac_md2 (lex_ctxt *)
tree_cell *	nasl_hmac_md5 (lex_ctxt *)
tree_cell *	nasl_hmac_sha1 (lex_ctxt *)
tree_cell *	nasl_hmac_sha256 (lex_ctxt *)
tree_cell *	nasl_hmac_sha384 (lex_ctxt *)
tree_cell *	nasl_hmac_sha512 (lex_ctxt *)
tree_cell *	nasl_hmac_dss (lex_ctxt *)
tree_cell *	nasl_hmac_ripemd160 (lex_ctxt *)
tree_cell *	nasl_prf_sha256 (lex_ctxt *)
tree_cell *	nasl_prf_sha384 (lex_ctxt *)
tree_cell *	nasl_tls1_prf (lex_ctxt *)
tree_cell *	nasl_ntlmv1_hash (lex_ctxt *)
tree_cell *	nasl_nt_owf_gen (lex_ctxt *)
tree_cell *	nasl_lm_owf_gen (lex_ctxt *)
tree_cell *	nasl_ntv2_owf_gen (lex_ctxt *)
tree_cell *	nasl_ntlmv2_hash (lex_ctxt *)
tree_cell *	nasl_ntlmv2_response (lex_ctxt *lexic)
tree_cell *	nasl_ntlm2_response (lex_ctxt *lexic)
tree_cell *	nasl_ntlm_response (lex_ctxt *lexic)
tree_cell *	nasl_keyexchg (lex_ctxt *lexic)
tree_cell *	nasl_insert_hexzeros (lex_ctxt *lexic)
tree_cell *	nasl_get_password (lex_ctxt *lexic)
tree_cell *	nasl_get_sign (lex_ctxt *lexic)
tree_cell *	nasl_get_smb2_sign (lex_ctxt *lexic)
tree_cell *	nasl_smb_cmac_aes_sign (lex_ctxt *lexic)
tree_cell *	nasl_smb_gmac_aes_sign (lex_ctxt *lexic)
tree_cell *	nasl_cipher_des (lex_ctxt *)

Macro Definition Documentation

MD4_DIGEST_LENGTH

#define MD4_DIGEST_LENGTH   16

Definition at line 16 of file nasl_crypto.h.

Function Documentation

nasl_cipher_des()

tree_cell* nasl_cipher_des

(

lex_ctxt *

)

Definition at line 187 of file nasl_crypto.c.

{
  char *data, *key;
  size_t dlen, klen;
 
  data = get_str_var_by_num (lexic, 0);
  dlen = get_var_size_by_num (lexic, 0);
  key = get_str_var_by_num (lexic, 1);
  klen = get_var_size_by_num (lexic, 1);
  return nasl_cipher (GCRY_CIPHER_DES, data, dlen, key, klen);
}

References get_str_var_by_num(), get_var_size_by_num(), and nasl_cipher().

Here is the call graph for this function:

nasl_get_password()

tree_cell* nasl_get_password

(

lex_ctxt *

lexic

)

nasl_get_sign()

tree_cell* nasl_get_sign

(

lex_ctxt *

lexic

)

Definition at line 244 of file nasl_crypto.c.

{
  char *mac_key = (char *) get_str_var_by_name (lexic, "key");
  uint8_t *buf = (uint8_t *) get_str_var_by_name (lexic, "buf");
  int buflen = get_int_var_by_name (lexic, "buflen", -1);
  int seq_num = get_int_var_by_name (lexic, "seq_number", -1);
  if (mac_key == NULL || buf == NULL || buflen == -1 || seq_num <= -1)
    {
      nasl_perror (lexic, "Syntax : get_signature(key:<k>, buf:<b>, "
                          "buflen:<bl>, seq_number:<s>)\n");
      return NULL;
    }
  uint8_t calc_md5_mac[16];
  simple_packet_signature_ntlmssp ((uint8_t *) mac_key, buf, seq_num,
                                   calc_md5_mac);
  memcpy (buf + 18, calc_md5_mac, 8);
  char *ret = g_malloc0 (buflen);
  memcpy (ret, buf, buflen);
  tree_cell *retc;
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = buflen;
  retc->x.str_val = (char *) ret;
  return retc;
}

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

Here is the call graph for this function:

nasl_get_smb2_sign()

tree_cell* nasl_get_smb2_sign

(

lex_ctxt *

lexic

)

Definition at line 495 of file nasl_crypto.c.

{
  return nasl_smb_sign (G_CHECKSUM_SHA256, lexic);
}

References nasl_smb_sign().

Here is the call graph for this function:

nasl_hmac_dss()

tree_cell* nasl_hmac_dss

(

lex_ctxt *

)

nasl_hmac_md2()

tree_cell* nasl_hmac_md2

(

lex_ctxt *

)

Definition at line 213 of file nasl_crypto.c.

{
  return nasl_hmac (lexic, GCRY_MD_MD2);
}

References nasl_hmac().

Here is the call graph for this function:

nasl_hmac_md5()

tree_cell* nasl_hmac_md5

(

lex_ctxt *

)

Definition at line 219 of file nasl_crypto.c.

{
  return nasl_hmac (lexic, GCRY_MD_MD5);
}

References nasl_hmac().

Here is the call graph for this function:

nasl_hmac_ripemd160()

tree_cell* nasl_hmac_ripemd160

(

lex_ctxt *

)

Definition at line 237 of file nasl_crypto.c.

{
  return nasl_hmac (lexic, GCRY_MD_RMD160);
}

References nasl_hmac().

Here is the call graph for this function:

nasl_hmac_sha1()

tree_cell* nasl_hmac_sha1

(

lex_ctxt *

)

Definition at line 225 of file nasl_crypto.c.

{
  return nasl_hmac (lexic, GCRY_MD_SHA1);
}

References nasl_hmac().

Here is the call graph for this function:

nasl_hmac_sha256()

tree_cell* nasl_hmac_sha256

(

lex_ctxt *

)

Definition at line 270 of file nasl_crypto.c.

{
  void *key, *data, *signature;
  int keylen, datalen;
  tree_cell *retc;
 
  key = get_str_var_by_name (lexic, "key");
  data = get_str_var_by_name (lexic, "data");
  datalen = get_var_size_by_name (lexic, "data");
  keylen = get_var_size_by_name (lexic, "key");
  if (!key || !data || keylen <= 0 || datalen <= 0)
    {
      nasl_perror (lexic, "Syntax : hmac_sha256(data:<b>, key:<k>)\n");
      return NULL;
    }
  signature = hmac_sha256 (key, keylen, data, datalen);
 
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = 32;
  retc->x.str_val = (char *) signature;
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_str_var_by_name(), get_var_size_by_name(), hmac_sha256(), nasl_perror(), TC::size, TC::str_val, and TC::x.

Here is the call graph for this function:

nasl_hmac_sha384()

tree_cell* nasl_hmac_sha384

(

lex_ctxt *

)

Definition at line 231 of file nasl_crypto.c.

{
  return nasl_hmac (lexic, GCRY_MD_SHA384);
}

References nasl_hmac().

Here is the call graph for this function:

nasl_hmac_sha512()

tree_cell* nasl_hmac_sha512

(

lex_ctxt *

)

Definition at line 489 of file nasl_crypto.c.

{
  return nasl_hmac (lexic, GCRY_MD_SHA512);
}

References nasl_hmac().

Here is the call graph for this function:

nasl_insert_hexzeros()

tree_cell* nasl_insert_hexzeros

(

lex_ctxt *

lexic

)

Definition at line 740 of file nasl_crypto.c.

{
  const uchar *in = (uchar *) get_str_var_by_name (lexic, "in");
  int in_len = get_var_size_by_name (lexic, "in");
  char *src;
  smb_ucs2_t *out, *dst, val;
  int i;
  size_t byte_len;
  tree_cell *retc;
  if (in_len < 0 || in == NULL)
    {
      nasl_perror (lexic, "Syntax : insert_hexzeros(in:<i>)\n");
      return NULL;
    }
 
  byte_len = sizeof (smb_ucs2_t) * (strlen ((char *) in) + 1);
  out = g_malloc0 (byte_len);
  dst = out;
  src = (char *) in;
 
  for (i = 0; i < in_len; i++)
    {
      val = *src;
      *dst = val;
      dst++;
      src++;
      if (val == 0)
        break;
    }
 
  /* We don't want null termination */
  byte_len = byte_len - 2;
 
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = byte_len;
  retc->x.str_val = (char *) out;
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_str_var_by_name(), get_var_size_by_name(), nasl_perror(), TC::size, TC::str_val, uchar, val, and TC::x.

Here is the call graph for this function:

nasl_keyexchg()

tree_cell* nasl_keyexchg

(

lex_ctxt *

lexic

)

Definition at line 630 of file nasl_crypto.c.

{
  char *cryptkey = (char *) get_str_var_by_name (lexic, "cryptkey");
  uint8_t *session_key = (uint8_t *) get_str_var_by_name (lexic, "session_key");
  unsigned char *nt_hash =
    (unsigned char *) get_str_var_by_name (lexic, "nt_hash");
 
  if (cryptkey == NULL || session_key == NULL || nt_hash == NULL)
    {
      nasl_perror (
        lexic,
        "Syntax : key_exchange(cryptkey:<c>, session_key:<s>, nt_hash:<n> )\n");
      return NULL;
    }
  uint8_t new_sess_key[16];
  tree_cell *retc;
  uint8_t *encrypted_session_key = NULL;
  encrypted_session_key = ntlmssp_genauth_keyexchg (
    session_key, cryptkey, nt_hash, (uint8_t *) &new_sess_key);
  int len = 16 + 16;
  char *ret = g_malloc0 (len);
  memcpy (ret, new_sess_key, 16);
  memcpy (ret + 16, encrypted_session_key, 16);
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = len;
  retc->x.str_val = ret;
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_str_var_by_name(), len, nasl_perror(), ntlmssp_genauth_keyexchg(), TC::size, TC::str_val, and TC::x.

Here is the call graph for this function:

nasl_lm_owf_gen()

tree_cell* nasl_lm_owf_gen

(

lex_ctxt *

)

Definition at line 711 of file nasl_crypto.c.

{
  char *pass = get_str_var_by_num (lexic, 0);
  int pass_len = get_var_size_by_num (lexic, 0);
  tree_cell *retc;
  uchar pwd[15];
  uchar p16[16];
  unsigned int i;
 
  if (pass_len < 0 || pass == NULL)
    {
      nasl_perror (lexic, "Syntax : nt_lm_gen(password:<p>)\n");
      return NULL;
    }
 
  bzero (pwd, sizeof (pwd));
  strncpy ((char *) pwd, pass, sizeof (pwd) - 1);
  for (i = 0; i < sizeof (pwd); i++)
    pwd[i] = toupper (pwd[i]);
 
  E_P16 (pwd, p16);
 
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = 16;
  retc->x.str_val = g_memdup2 (p16, 16);
  return retc;
}

References alloc_typed_cell(), CONST_DATA, E_P16(), get_str_var_by_num(), get_var_size_by_num(), nasl_perror(), TC::size, TC::str_val, uchar, and TC::x.

Here is the call graph for this function:

nasl_md2()

tree_cell* nasl_md2

(

lex_ctxt *

)

Definition at line 113 of file nasl_crypto.c.

{
  return nasl_hash (lexic, GCRY_MD_MD2);
}

References nasl_hash().

Here is the call graph for this function:

nasl_md4()

tree_cell* nasl_md4

(

lex_ctxt *

)

Definition at line 119 of file nasl_crypto.c.

{
  return nasl_hash (lexic, GCRY_MD_MD4);
}

References nasl_hash().

Here is the call graph for this function:

nasl_md5()

tree_cell* nasl_md5

(

lex_ctxt *

)

Definition at line 125 of file nasl_crypto.c.

{
  return nasl_hash (lexic, GCRY_MD_MD5);
}

References nasl_hash().

Here is the call graph for this function:

nasl_nt_owf_gen()

tree_cell* nasl_nt_owf_gen

(

lex_ctxt *

)

Definition at line 692 of file nasl_crypto.c.

{
  char *pass = get_str_var_by_num (lexic, 0);
  gunichar2 *upass;
  glong upass_len;
  tree_cell *ret;
 
  if (!pass)
    {
      nasl_perror (lexic, "Syntax : nt_owf_gen(<password>)\n");
      return NULL;
    }
  upass = g_utf8_to_utf16 (pass, -1, NULL, &upass_len, NULL);
  ret = nasl_gcrypt_hash (lexic, GCRY_MD_MD4, upass, upass_len * 2, NULL, 0);
  g_free (upass);
  return ret;
}

References get_str_var_by_num(), nasl_gcrypt_hash(), and nasl_perror().

Here is the call graph for this function:

nasl_ntlm2_response()

tree_cell* nasl_ntlm2_response

(

lex_ctxt *

lexic

)

Definition at line 557 of file nasl_crypto.c.

{
  char *cryptkey = (char *) get_str_var_by_name (lexic, "cryptkey");
  char *password = get_str_var_by_name (lexic, "password");
  uint8_t pass_len = get_var_size_by_name (lexic, "password");
  void *nt_hash = get_str_var_by_name (lexic, "nt_hash");
  int hash_len = get_var_size_by_name (lexic, "nt_hash");
 
  if (!cryptkey || !password || !nt_hash || hash_len < 16)
    {
      nasl_perror (lexic, "Syntax : ntlm2_response(cryptkey:<c>, password:<p>, "
                          "nt_hash:<n[16]>)\n");
      return NULL;
    }
 
  uint8_t lm_response[24];
  uint8_t nt_response[24];
  uint8_t session_key[16];
 
  tree_cell *retc;
  ntlmssp_genauth_ntlm2 (password, pass_len, lm_response, nt_response,
                         session_key, cryptkey, nt_hash);
  int len = sizeof (lm_response) + sizeof (nt_response) + sizeof (session_key);
  char *ret = g_malloc0 (len);
  memcpy (ret, lm_response, sizeof (lm_response));
  memcpy (ret + sizeof (lm_response), nt_response, sizeof (nt_response));
  memcpy (ret + sizeof (lm_response) + sizeof (nt_response), session_key,
          sizeof (session_key));
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = len;
  retc->x.str_val = ret;
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_str_var_by_name(), get_var_size_by_name(), len, nasl_perror(), ntlmssp_genauth_ntlm2(), TC::size, TC::str_val, and TC::x.

Here is the call graph for this function:

nasl_ntlm_response()

tree_cell* nasl_ntlm_response

(

lex_ctxt *

lexic

)

Definition at line 592 of file nasl_crypto.c.

{
  char *cryptkey = (char *) get_str_var_by_name (lexic, "cryptkey");
  char *password = get_str_var_by_name (lexic, "password");
  uint8_t pass_len = (uint8_t) get_var_size_by_name (lexic, "password");
  void *nt_hash = get_str_var_by_name (lexic, "nt_hash");
  int hash_len = get_var_size_by_name (lexic, "nt_hash");
  int neg_flags = get_int_var_by_name (lexic, "neg_flags", -1);
 
  if (!cryptkey || !password || !nt_hash || hash_len < 16 || neg_flags < 0)
    {
      nasl_perror (lexic, "Syntax : ntlm_response(cryptkey:<c>, password:<p>, "
                          "nt_hash:<n[16]>, neg_flags:<nf>)\n");
      return NULL;
    }
 
  uint8_t lm_response[24];
  uint8_t nt_response[24];
  uint8_t session_key[16];
 
  tree_cell *retc;
 
  ntlmssp_genauth_ntlm (password, pass_len, lm_response, nt_response,
                        session_key, cryptkey, nt_hash, neg_flags);
 
  int len = sizeof (lm_response) + sizeof (nt_response) + sizeof (session_key);
  char *ret = g_malloc0 (len);
  memcpy (ret, lm_response, sizeof (lm_response));
  memcpy (ret + sizeof (lm_response), nt_response, sizeof (nt_response));
  memcpy (ret + sizeof (lm_response) + sizeof (nt_response), session_key,
          sizeof (session_key));
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = len;
  retc->x.str_val = ret;
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_int_var_by_name(), get_str_var_by_name(), get_var_size_by_name(), len, nasl_perror(), ntlmssp_genauth_ntlm(), TC::size, TC::str_val, and TC::x.

Here is the call graph for this function:

nasl_ntlmv1_hash()

tree_cell* nasl_ntlmv1_hash

(

lex_ctxt *

)

Definition at line 660 of file nasl_crypto.c.

{
  const uchar *cryptkey = (uchar *) get_str_var_by_name (lexic, "cryptkey");
  char *password = get_str_var_by_name (lexic, "passhash");
  int pass_len = get_var_size_by_name (lexic, "passhash");
  unsigned char p21[21];
  tree_cell *retc;
  uchar *ret;
 
  if (cryptkey == NULL || password == NULL)
    {
      nasl_perror (lexic, "Syntax : ntlmv1_hash(cryptkey:<c>, passhash:<p>)\n");
      return NULL;
    }
 
  if (pass_len < 16)
    pass_len = 16;
 
  bzero (p21, sizeof (p21));
  memcpy (p21, password, pass_len);
 
  ret = g_malloc0 (24);
 
  E_P24 (p21, cryptkey, ret);
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = 24;
  retc->x.str_val = (char *) ret;
 
  return retc;
}

References alloc_typed_cell(), CONST_DATA, E_P24(), get_str_var_by_name(), get_var_size_by_name(), nasl_perror(), TC::size, TC::str_val, uchar, and TC::x.

Here is the call graph for this function:

nasl_ntlmv2_hash()

tree_cell* nasl_ntlmv2_hash

(

lex_ctxt *

)

Definition at line 868 of file nasl_crypto.c.

{
  const uchar *server_chal = (uchar *) get_str_var_by_name (lexic, "cryptkey");
  int sc_len = get_var_size_by_name (lexic, "cryptkey");
  const uchar *ntlm_v2_hash = (uchar *) get_str_var_by_name (lexic, "passhash");
  int hash_len = get_var_size_by_name (lexic, "passhash");
  int client_chal_length = get_int_var_by_name (lexic, "length", -1);
  tree_cell *retc;
  unsigned char ntlmv2_response[16];
  unsigned char *ntlmv2_client_data = NULL;
  unsigned char *final_response;
  int i;
 
  if (sc_len < 0 || server_chal == NULL || hash_len < 0 || ntlm_v2_hash == NULL
      || client_chal_length < 0)
    {
      nasl_perror (
        lexic,
        "Syntax : ntlmv2_hash(cryptkey:<c>, passhash:<p>, length:<l>)\n");
      return NULL;
    }
 
  /* NTLMv2 */
 
  /* We also get to specify some random data */
  ntlmv2_client_data = g_malloc0 (client_chal_length);
  for (i = 0; i < client_chal_length; i++)
    ntlmv2_client_data[i] = rand () % 256;
 
  assert (hash_len == 16);
  /* Given that data, and the challenge from the server, generate a response */
  SMBOWFencrypt_ntv2_ntlmssp (ntlm_v2_hash, server_chal, 8, ntlmv2_client_data,
                              client_chal_length, ntlmv2_response);
 
  /* put it into nt_response, for the code below to put into the packet */
  final_response = g_malloc0 (client_chal_length + sizeof (ntlmv2_response));
  memcpy (final_response, ntlmv2_response, sizeof (ntlmv2_response));
  /* after the first 16 bytes is the random data we generated above, so the
   * server can verify us with it */
  memcpy (final_response + sizeof (ntlmv2_response), ntlmv2_client_data,
          client_chal_length);
 
  g_free (ntlmv2_client_data);
 
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = client_chal_length + sizeof (ntlmv2_response);
  retc->x.str_val = (char *) final_response;
 
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_int_var_by_name(), get_str_var_by_name(), get_var_size_by_name(), nasl_perror(), TC::size, SMBOWFencrypt_ntv2_ntlmssp(), TC::str_val, uchar, and TC::x.

Here is the call graph for this function:

nasl_ntlmv2_response()

tree_cell* nasl_ntlmv2_response

(

lex_ctxt *

lexic

)

Definition at line 513 of file nasl_crypto.c.

{
  char *cryptkey = (char *) get_str_var_by_name (lexic, "cryptkey");
  char *user = (char *) get_str_var_by_name (lexic, "user");
  char *domain = (char *) get_str_var_by_name (lexic, "domain");
  unsigned char *ntlmv2_hash =
    (unsigned char *) get_str_var_by_name (lexic, "ntlmv2_hash");
  char *address_list = get_str_var_by_name (lexic, "address_list");
  int address_list_len = get_int_var_by_name (lexic, "address_list_len", -1);
 
  if (cryptkey == NULL || user == NULL || domain == NULL || ntlmv2_hash == NULL
      || address_list == NULL || address_list_len < 0)
    {
      nasl_perror (
        lexic, "Syntax : ntlmv2_response(cryptkey:<c>, user:<u>, domain:<d>, "
               "ntlmv2_hash:<n>, address_list:<a>, address_list_len:<len>)\n");
      return NULL;
    }
  uint8_t lm_response[24];
  uint8_t nt_response[16 + 28 + address_list_len];
  uint8_t session_key[16];
  bzero (lm_response, sizeof (lm_response));
  bzero (nt_response, sizeof (nt_response));
  bzero (session_key, sizeof (session_key));
 
  ntlmssp_genauth_ntlmv2 (user, domain, address_list, address_list_len,
                          cryptkey, lm_response, nt_response, session_key,
                          ntlmv2_hash);
  tree_cell *retc;
  int lm_response_len = 24;
  int nt_response_len = 16 + 28 + address_list_len;
  int len = lm_response_len + nt_response_len + sizeof (session_key);
  char *ret = g_malloc0 (len);
  memcpy (ret, lm_response, lm_response_len);
  memcpy (ret + lm_response_len, session_key, sizeof (session_key));
  memcpy (ret + lm_response_len + sizeof (session_key), nt_response,
          nt_response_len);
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = len;
  retc->x.str_val = ret;
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_int_var_by_name(), get_str_var_by_name(), len, nasl_perror(), ntlmssp_genauth_ntlmv2(), TC::size, TC::str_val, and TC::x.

Here is the call graph for this function:

nasl_ntv2_owf_gen()

tree_cell* nasl_ntv2_owf_gen

(

lex_ctxt *

)

Definition at line 781 of file nasl_crypto.c.

{
  const uchar *owf_in = (uchar *) get_str_var_by_name (lexic, "owf");
  int owf_in_len = get_var_size_by_name (lexic, "owf");
  char *user_in = get_str_var_by_name (lexic, "login");
  int user_in_len = get_var_size_by_name (lexic, "login");
  char *domain_in = get_str_var_by_name (lexic, "domain");
  int domain_len = get_var_size_by_name (lexic, "domain");
  char *src_user, *src_domain;
  smb_ucs2_t *user, *dst_user, val_user;
  smb_ucs2_t *domain, *dst_domain, val_domain;
  int i;
  size_t user_byte_len;
  size_t domain_byte_len;
  tree_cell *retc;
  uchar *kr_buf;
  HMACMD5Context ctx;
 
  if (owf_in_len < 0 || owf_in == NULL || user_in_len < 0 || user_in == NULL
      || domain_len < 0 || domain_in == NULL)
    {
      nasl_perror (lexic,
                   "Syntax : ntv2_owf_gen(owf:<o>, login:<l>, domain:<d>)\n");
      return NULL;
    }
 
  assert (owf_in_len == 16);
 
  user_byte_len = sizeof (smb_ucs2_t) * (strlen (user_in) + 1);
  user = g_malloc0 (user_byte_len);
  dst_user = user;
  src_user = user_in;
 
  for (i = 0; i < user_in_len; i++)
    {
      val_user = *src_user;
      *dst_user = val_user;
      dst_user++;
      src_user++;
      if (val_user == 0)
        break;
    }
 
  domain_byte_len = sizeof (smb_ucs2_t) * (strlen (domain_in) + 1);
  domain = g_malloc0 (domain_byte_len);
  dst_domain = domain;
  src_domain = domain_in;
 
  for (i = 0; i < domain_len; i++)
    {
      val_domain = *src_domain;
      *dst_domain = val_domain;
 
      dst_domain++;
      src_domain++;
      if (val_domain == 0)
        break;
    }
 
  strupper_w (user);
  strupper_w (domain);
 
  assert (user_byte_len >= 2);
  assert (domain_byte_len >= 2);
 
  /* We don't want null termination */
  user_byte_len = user_byte_len - 2;
  domain_byte_len = domain_byte_len - 2;
 
  kr_buf = g_malloc0 (16);
 
  hmac_md5_init_limK_to_64 (owf_in, 16, &ctx);
  hmac_md5_update ((const unsigned char *) user, user_byte_len, &ctx);
  hmac_md5_update ((const unsigned char *) domain, domain_byte_len, &ctx);
  hmac_md5_final (kr_buf, &ctx);
 
  g_free (user);
  g_free (domain);
 
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = 16;
  retc->x.str_val = (char *) kr_buf;
 
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_str_var_by_name(), get_var_size_by_name(), hmac_md5_final(), hmac_md5_init_limK_to_64(), hmac_md5_update(), nasl_perror(), TC::size, TC::str_val, strupper_w(), uchar, and TC::x.

Here is the call graph for this function:

nasl_prf_sha256()

tree_cell* nasl_prf_sha256

(

lex_ctxt *

)

Definition at line 471 of file nasl_crypto.c.

{
  return nasl_prf (lexic, 0);
}

References nasl_prf().

Here is the call graph for this function:

nasl_prf_sha384()

tree_cell* nasl_prf_sha384

(

lex_ctxt *

)

Definition at line 477 of file nasl_crypto.c.

{
  return nasl_prf (lexic, 1);
}

References nasl_prf().

Here is the call graph for this function:

nasl_ripemd160()

tree_cell* nasl_ripemd160

(

lex_ctxt *

)

Definition at line 149 of file nasl_crypto.c.

{
  return nasl_hash (lexic, GCRY_MD_RMD160);
}

References nasl_hash().

Here is the call graph for this function:

nasl_sha()

tree_cell* nasl_sha

(

lex_ctxt *

)

nasl_sha1()

tree_cell* nasl_sha1

(

lex_ctxt *

)

Definition at line 131 of file nasl_crypto.c.

{
  return nasl_hash (lexic, GCRY_MD_SHA1);
}

References nasl_hash().

Here is the call graph for this function:

nasl_sha256()

tree_cell* nasl_sha256

(

lex_ctxt *

)

Definition at line 137 of file nasl_crypto.c.

{
  return nasl_hash (lexic, GCRY_MD_SHA256);
}

References nasl_hash().

Here is the call graph for this function:

nasl_sha512()

tree_cell* nasl_sha512

(

lex_ctxt *

)

Definition at line 143 of file nasl_crypto.c.

{
  return nasl_hash (lexic, GCRY_MD_SHA512);
}

References nasl_hash().

Here is the call graph for this function:

nasl_smb_cmac_aes_sign()

tree_cell* nasl_smb_cmac_aes_sign

(

lex_ctxt *

lexic

)

Definition at line 501 of file nasl_crypto.c.

{
  return nasl_smb_sign (GCRY_MAC_CMAC_AES, lexic);
}

References nasl_smb_sign().

Here is the call graph for this function:

nasl_smb_gmac_aes_sign()

tree_cell* nasl_smb_gmac_aes_sign

(

lex_ctxt *

lexic

)

Definition at line 507 of file nasl_crypto.c.

{
  return nasl_smb_sign (GCRY_MAC_GMAC_AES, lexic);
}

References nasl_smb_sign().

Here is the call graph for this function:

nasl_tls1_prf()

tree_cell* nasl_tls1_prf

(

lex_ctxt *

)

Definition at line 483 of file nasl_crypto.c.

{
  return nasl_prf (lexic, 2);
}

References nasl_prf().

Here is the call graph for this function: