nasl_crypto2.h File Reference

#include "nasl_lex_ctxt.h"

Include dependency graph for nasl_crypto2.h:

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

Go to the source code of this file.

Functions
tree_cell *	nasl_bn_random (lex_ctxt *)
tree_cell *	nasl_dh_generate_key (lex_ctxt *)
tree_cell *	nasl_bn_cmp (lex_ctxt *)
tree_cell *	nasl_dh_compute_key (lex_ctxt *)
tree_cell *	nasl_rsa_public_encrypt (lex_ctxt *)
tree_cell *	nasl_rsa_private_decrypt (lex_ctxt *)
tree_cell *	nasl_open_rc4_cipher (lex_ctxt *)
	Nasl function to open RC4 cipher to encrypt a stream of data. The handler can be used to encrypt stream data. Open cipher must be close with close_stream_cipher() when it is not useful anymore.
tree_cell *	nasl_close_stream_cipher (lex_ctxt *)
	Nasl function to delete a cipher item from the cipher table.
tree_cell *	nasl_rsa_public_decrypt (lex_ctxt *)
tree_cell *	nasl_bf_cbc_encrypt (lex_ctxt *)
tree_cell *	nasl_bf_cbc_decrypt (lex_ctxt *)
tree_cell *	nasl_dsa_do_verify (lex_ctxt *lexic)
tree_cell *	nasl_pem_to_rsa (lex_ctxt *lexic)
tree_cell *	nasl_pem_to_dsa (lex_ctxt *lexic)
tree_cell *	nasl_rsa_sign (lex_ctxt *lexic)
tree_cell *	nasl_dsa_do_sign (lex_ctxt *lexic)
tree_cell *	nasl_rc4_encrypt (lex_ctxt *lexic)
	Nasl function to encrypt data with a RC4 cipher. If an hd param exist in the lexix context, it will use this handler to encrypt the data as part of a stream data. e.g.: rc4_encrypt(data: data, hd: hd).
tree_cell *	nasl_aes128_cbc_encrypt (lex_ctxt *lexic)
tree_cell *	nasl_aes_mac_cbc (lex_ctxt *lexic)
tree_cell *	nasl_aes_mac_gcm (lex_ctxt *lexic)
tree_cell *	nasl_aes256_cbc_encrypt (lex_ctxt *lexic)
tree_cell *	nasl_aes128_ctr_encrypt (lex_ctxt *lexic)
tree_cell *	nasl_aes256_ctr_encrypt (lex_ctxt *lexic)
tree_cell *	nasl_des_ede_cbc_encrypt (lex_ctxt *lexic)
tree_cell *	nasl_aes128_gcm_encrypt (lex_ctxt *lexic)
tree_cell *	nasl_aes128_gcm_encrypt_auth (lex_ctxt *lexic)
tree_cell *	nasl_aes128_gcm_decrypt (lex_ctxt *lexic)
tree_cell *	nasl_aes128_gcm_decrypt_auth (lex_ctxt *lexic)
tree_cell *	nasl_aes256_gcm_encrypt (lex_ctxt *lexic)
tree_cell *	nasl_aes256_gcm_encrypt_auth (lex_ctxt *lexic)
tree_cell *	nasl_aes256_gcm_decrypt (lex_ctxt *lexic)
tree_cell *	nasl_aes256_gcm_decrypt_auth (lex_ctxt *lexic)
tree_cell *	nasl_aes128_ccm_encrypt (lex_ctxt *lexic)
tree_cell *	nasl_aes128_ccm_encrypt_auth (lex_ctxt *lexic)
tree_cell *	nasl_aes128_ccm_decrypt (lex_ctxt *lexic)
tree_cell *	nasl_aes128_ccm_decrypt_auth (lex_ctxt *lexic)
tree_cell *	nasl_aes256_ccm_encrypt (lex_ctxt *lexic)
tree_cell *	nasl_aes256_ccm_encrypt_auth (lex_ctxt *lexic)
tree_cell *	nasl_aes256_ccm_decrypt (lex_ctxt *lexic)
tree_cell *	nasl_aes256_ccm_decrypt_auth (lex_ctxt *lexic)
tree_cell *	nasl_smb3kdf (lex_ctxt *lexic)
	Add the SMB3KDF as specified in [SP800-108] section 5.1.
int	generate_script_signature (char *)

Function Documentation

generate_script_signature()

int generate_script_signature

(

char *

)

nasl_aes128_cbc_encrypt()

tree_cell * nasl_aes128_cbc_encrypt

(

lex_ctxt *

lexic

)

Definition at line 1962 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CBC,
                     NASL_ENCRYPT);
}

References crypt_data(), and NASL_ENCRYPT.

Here is the call graph for this function:

nasl_aes128_ccm_decrypt()

tree_cell * nasl_aes128_ccm_decrypt

(

lex_ctxt *

lexic

)

Definition at line 2064 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CCM,
                     NASL_DECRYPT);
}

References crypt_data(), and NASL_DECRYPT.

Here is the call graph for this function:

nasl_aes128_ccm_decrypt_auth()

tree_cell * nasl_aes128_ccm_decrypt_auth

(

lex_ctxt *

lexic

)

Definition at line 2071 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CCM,
                     NASL_AAD | NASL_DECRYPT);
}

References crypt_data(), NASL_AAD, and NASL_DECRYPT.

Here is the call graph for this function:

nasl_aes128_ccm_encrypt()

tree_cell * nasl_aes128_ccm_encrypt

(

lex_ctxt *

lexic

)

Definition at line 2051 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CCM,
                     NASL_ENCRYPT);
}

References crypt_data(), and NASL_ENCRYPT.

Here is the call graph for this function:

nasl_aes128_ccm_encrypt_auth()

tree_cell * nasl_aes128_ccm_encrypt_auth

(

lex_ctxt *

lexic

)

Definition at line 2058 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CCM, NASL_AAD);
}

References crypt_data(), and NASL_AAD.

Here is the call graph for this function:

nasl_aes128_ctr_encrypt()

tree_cell * nasl_aes128_ctr_encrypt

(

lex_ctxt *

lexic

)

Definition at line 1976 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CTR,
                     NASL_ENCRYPT);
}

References crypt_data(), and NASL_ENCRYPT.

Here is the call graph for this function:

nasl_aes128_gcm_decrypt()

tree_cell * nasl_aes128_gcm_decrypt

(

lex_ctxt *

lexic

)

Definition at line 2010 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_GCM,
                     NASL_DECRYPT);
}

References crypt_data(), and NASL_DECRYPT.

Here is the call graph for this function:

nasl_aes128_gcm_decrypt_auth()

tree_cell * nasl_aes128_gcm_decrypt_auth

(

lex_ctxt *

lexic

)

Definition at line 2017 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_GCM,
                     NASL_AAD | NASL_DECRYPT);
}

References crypt_data(), NASL_AAD, and NASL_DECRYPT.

Here is the call graph for this function:

nasl_aes128_gcm_encrypt()

tree_cell * nasl_aes128_gcm_encrypt

(

lex_ctxt *

lexic

)

Definition at line 1997 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_GCM,
                     NASL_ENCRYPT);
}

References crypt_data(), and NASL_ENCRYPT.

Here is the call graph for this function:

nasl_aes128_gcm_encrypt_auth()

tree_cell * nasl_aes128_gcm_encrypt_auth

(

lex_ctxt *

lexic

)

Definition at line 2004 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_GCM, NASL_AAD);
}

References crypt_data(), and NASL_AAD.

Here is the call graph for this function:

nasl_aes256_cbc_encrypt()

tree_cell * nasl_aes256_cbc_encrypt

(

lex_ctxt *

lexic

)

Definition at line 1969 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC,
                     NASL_ENCRYPT);
}

References crypt_data(), and NASL_ENCRYPT.

Here is the call graph for this function:

nasl_aes256_ccm_decrypt()

tree_cell * nasl_aes256_ccm_decrypt

(

lex_ctxt *

lexic

)

Definition at line 2091 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CCM,
                     NASL_DECRYPT);
}

References crypt_data(), and NASL_DECRYPT.

Here is the call graph for this function:

nasl_aes256_ccm_decrypt_auth()

tree_cell * nasl_aes256_ccm_decrypt_auth

(

lex_ctxt *

lexic

)

Definition at line 2098 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CCM,
                     NASL_AAD | NASL_DECRYPT);
}

References crypt_data(), NASL_AAD, and NASL_DECRYPT.

Here is the call graph for this function:

nasl_aes256_ccm_encrypt()

tree_cell * nasl_aes256_ccm_encrypt

(

lex_ctxt *

lexic

)

Definition at line 2078 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CCM,
                     NASL_ENCRYPT);
}

References crypt_data(), and NASL_ENCRYPT.

Here is the call graph for this function:

nasl_aes256_ccm_encrypt_auth()

tree_cell * nasl_aes256_ccm_encrypt_auth

(

lex_ctxt *

lexic

)

Definition at line 2085 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CCM, NASL_AAD);
}

References crypt_data(), and NASL_AAD.

Here is the call graph for this function:

nasl_aes256_ctr_encrypt()

tree_cell * nasl_aes256_ctr_encrypt

(

lex_ctxt *

lexic

)

Definition at line 1983 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CTR,
                     NASL_ENCRYPT);
}

References crypt_data(), and NASL_ENCRYPT.

Here is the call graph for this function:

nasl_aes256_gcm_decrypt()

tree_cell * nasl_aes256_gcm_decrypt

(

lex_ctxt *

lexic

)

Definition at line 2037 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_GCM,
                     NASL_DECRYPT);
}

References crypt_data(), and NASL_DECRYPT.

Here is the call graph for this function:

nasl_aes256_gcm_decrypt_auth()

tree_cell * nasl_aes256_gcm_decrypt_auth

(

lex_ctxt *

lexic

)

Definition at line 2044 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_GCM,
                     NASL_AAD | NASL_DECRYPT);
}

References crypt_data(), NASL_AAD, and NASL_DECRYPT.

Here is the call graph for this function:

nasl_aes256_gcm_encrypt()

tree_cell * nasl_aes256_gcm_encrypt

(

lex_ctxt *

lexic

)

Definition at line 2024 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_GCM,
                     NASL_ENCRYPT);
}

References crypt_data(), and NASL_ENCRYPT.

Here is the call graph for this function:

nasl_aes256_gcm_encrypt_auth()

tree_cell * nasl_aes256_gcm_encrypt_auth

(

lex_ctxt *

lexic

)

Definition at line 2031 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_GCM, NASL_AAD);
}

References crypt_data(), and NASL_AAD.

Here is the call graph for this function:

nasl_aes_mac_cbc()

tree_cell * nasl_aes_mac_cbc

(

lex_ctxt *

lexic

)

Definition at line 1730 of file nasl_crypto2.c.

{
  return nasl_mac (lexic, GCRY_MAC_CMAC_AES, GCRY_MAC_FLAG_SECURE);
}

References nasl_mac().

Here is the call graph for this function:

nasl_aes_mac_gcm()

tree_cell * nasl_aes_mac_gcm

(

lex_ctxt *

lexic

)

Definition at line 1736 of file nasl_crypto2.c.

{
  return nasl_mac (lexic, GCRY_MAC_GMAC_AES, GCRY_MAC_FLAG_SECURE);
}

References nasl_mac().

Here is the call graph for this function:

nasl_bf_cbc_decrypt()

tree_cell * nasl_bf_cbc_decrypt

(

lex_ctxt *

lexic

)

nasl function

bf_cbc_decrypt(key:key, iv:iv, data:data)

Decrypt the cipher text data using the blowfish algorithm in CBC mode with the key key and the initialization vector iv. The key must be 16 bytes long. The iv must be at least 8 bytes long. data must be a multiple of 8 bytes long.

The return value is an array a with a[0] being the plaintext data and a[1] the new initialization vector to use for the next part of the data.

Definition at line 1514 of file nasl_crypto2.c.

{
  return nasl_bf_cbc (lexic, 0);
}

References nasl_bf_cbc().

Here is the call graph for this function:

nasl_bf_cbc_encrypt()

tree_cell * nasl_bf_cbc_encrypt

(

lex_ctxt *

lexic

)

nasl function

bf_cbc_encrypt(key:key, iv:iv, data:data)

Encrypt the plaintext data using the blowfish algorithm in CBC mode with the key key and the initialization vector iv. The key must be 16 bytes long. The iv must be at least 8 bytes long. data must be a multiple of 8 bytes long.

The return value is an array a with a[0] being the encrypted data and a[1] the new initialization vector to use for the next part of the data.

Definition at line 1494 of file nasl_crypto2.c.

{
  return nasl_bf_cbc (lexic, 1);
}

References nasl_bf_cbc().

Here is the call graph for this function:

nasl_bn_cmp()

tree_cell * nasl_bn_cmp

(

lex_ctxt *

lexic

)

nasl function

bn_cmp(key1:MPI1, key2:MPI2)

Compares the MPIs key1 and key2 (given as binary strings). Returns -1 if key1 < key2, 0 if key1 == key2 and +1 if key1 > key2.

Definition at line 281 of file nasl_crypto2.c.

{
  tree_cell *retc = NULL;
  gcry_mpi_t key1 = NULL, key2 = NULL;
 
  retc = g_malloc0 (sizeof (tree_cell));
  retc->ref_count = 1;
  retc->type = CONST_INT;
  retc->x.i_val = 1;
 
  if (mpi_from_named_parameter (lexic, &key1, "key1", "nasl_bn_cmp") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &key2, "key2", "nasl_bn_cmp") < 0)
    goto fail;
 
  retc->x.i_val = gcry_mpi_cmp (key1, key2);
 
  /* make sure the return value is one of -1, 0, +1 */
  if (retc->x.i_val > 0)
    retc->x.i_val = 1;
  if (retc->x.i_val < 0)
    retc->x.i_val = -1;
 
fail:
  gcry_mpi_release (key1);
  gcry_mpi_release (key2);
  return retc;
}

References CONST_INT, TC::i_val, mpi_from_named_parameter(), TC::ref_count, TC::type, and TC::x.

Here is the call graph for this function:

nasl_bn_random()

tree_cell * nasl_bn_random

(

lex_ctxt *

lexic

)

nasl function

bn_random(need:numBits)

Returns

An MPI as a string with need bits of random data.

Definition at line 318 of file nasl_crypto2.c.

{
  tree_cell *retc = NULL;
  gcry_mpi_t key = NULL;
  long need;
 
  retc = alloc_typed_cell (CONST_DATA);
 
  /* number of random bits */
  need = get_int_var_by_name (lexic, "need", 0);
 
  key = gcry_mpi_new (0);
  if (!key)
    goto fail;
 
  gcry_mpi_randomize (key, need, GCRY_STRONG_RANDOM);
 
  if (set_mpi_retc (retc, key) >= 0)
    goto ret;
 
fail:
  retc->size = 0;
  retc->x.str_val = g_malloc0 (1);
ret:
  gcry_mpi_release (key);
  return retc;
}

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

Here is the call graph for this function:

nasl_close_stream_cipher()

tree_cell * nasl_close_stream_cipher

(

lex_ctxt *

lexic

)

Nasl function to delete a cipher item from the cipher table.

Parameters

[in]

cipher_id

The cipher id to close

Returns

Returns zero on success. Otherwise NULL.

Definition at line 1675 of file nasl_crypto2.c.

{
  tree_cell *retc;
  int cipher_id;
  gcry_cipher_hd_t hd;
 
  cipher_id = get_int_var_by_name (lexic, "hd", 0);
 
  hd = verify_cipher_id (lexic, cipher_id);
  if (hd == NULL)
    return NULL;
 
  delete_cipher_item (cipher_id);
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = 0;
  return retc;
}

References alloc_typed_cell(), CONST_INT, delete_cipher_item(), get_int_var_by_name(), cipher_table_item::hd, TC::i_val, verify_cipher_id(), and TC::x.

Here is the call graph for this function:

nasl_des_ede_cbc_encrypt()

tree_cell * nasl_des_ede_cbc_encrypt

(

lex_ctxt *

lexic

)

Definition at line 1990 of file nasl_crypto2.c.

{
  return crypt_data (lexic, GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CBC,
                     NASL_ENCRYPT);
}

References crypt_data(), and NASL_ENCRYPT.

Here is the call graph for this function:

nasl_dh_compute_key()

tree_cell * nasl_dh_compute_key

(

lex_ctxt *

lexic

)

nasl function

dh_compute_key(p:mpi_p, g:mpi_g, dh_server_pub:mpi_server_pub, pub_key:mpi_client_pub, priv_key:mpi_client_priv)

Computes the Diffie-Hellman shared secret key from the shared parameters p and g, the server's public key dh_server_pub and the client's public and private keys pub_key an priv_key. The return value is the shared secret key as an MPI.

Definition at line 615 of file nasl_crypto2.c.

{
  tree_cell *retc = NULL;
  gcry_mpi_t p = NULL, g = NULL, dh_server_pub = NULL;
  gcry_mpi_t pub_key = NULL, priv_key = NULL;
  gcry_mpi_t shared = NULL;
 
  retc = alloc_typed_cell (CONST_DATA);
 
  if (mpi_from_named_parameter (lexic, &p, "p", "nasl_dh_compute_key") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &g, "g", "nasl_dh_compute_key") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &dh_server_pub, "dh_server_pub",
                                "nasl_dh_compute_key")
      < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &pub_key, "pub_key",
                                "nasl_dh_compute_key")
      < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &priv_key, "priv_key",
                                "nasl_dh_compute_key")
      < 0)
    goto fail;
 
  shared = calc_dh_key (dh_server_pub, p, priv_key);
 
  if (set_mpi_retc (retc, shared) >= 0)
    goto ret;
 
fail:
  retc->size = 0;
  retc->x.str_val = g_malloc0 (1);
ret:
  gcry_mpi_release (p);
  gcry_mpi_release (g);
  gcry_mpi_release (dh_server_pub);
  gcry_mpi_release (priv_key);
  gcry_mpi_release (pub_key);
  gcry_mpi_release (shared);
  return retc;
}

References alloc_typed_cell(), calc_dh_key(), CONST_DATA, mpi_from_named_parameter(), set_mpi_retc(), TC::size, TC::str_val, and TC::x.

Here is the call graph for this function:

nasl_dh_generate_key()

tree_cell * nasl_dh_generate_key

(

lex_ctxt *

lexic

)

nasl function

dh_generate_key(p:mpi_p, g:mpi_g, priv:mpi_priv)

Generates a Diffie-Hellman public key from the shared parameters p and g and the private parameter priv. The return value is the public key as an MPI.

Definition at line 570 of file nasl_crypto2.c.

{
  tree_cell *retc = NULL;
  gcry_mpi_t p = NULL, g = NULL, priv = NULL, pub_mpi = NULL;
 
  retc = alloc_typed_cell (CONST_DATA);
 
  if (mpi_from_named_parameter (lexic, &p, "p", "nasl_dh_generate_key") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &g, "g", "nasl_dh_generate_key") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &priv, "priv", "nasl_dh_generate_key")
      < 0)
    goto fail;
 
  pub_mpi = calc_dh_public (g, p, priv);
  if (pub_mpi == NULL)
    goto fail;
 
  if (set_mpi_retc (retc, pub_mpi) >= 0)
    goto ret;
 
fail:
  retc->x.str_val = g_malloc0 (1);
  retc->size = 0;
ret:
  gcry_mpi_release (p);
  gcry_mpi_release (g);
  gcry_mpi_release (priv);
  gcry_mpi_release (pub_mpi);
  return retc;
}

References alloc_typed_cell(), calc_dh_public(), CONST_DATA, mpi_from_named_parameter(), set_mpi_retc(), TC::size, TC::str_val, and TC::x.

Here is the call graph for this function:

nasl_dsa_do_sign()

tree_cell * nasl_dsa_do_sign

(

lex_ctxt *

lexic

)

nasl function

dsa_do_sign(p:mpi_p, g:mpi_g, q:mpi_q, pub:mpi_pub, priv:mpi_priv, data:hash)

Computes the DSA signature of the hash in data using the private DSA key given by p, g, q, pub and priv. The return value is a 40 byte string encoding the two MPIs r and s of the DSA signature. The first 20 bytes are the value of r and the last 20 bytes are the value of s.

Definition at line 1247 of file nasl_crypto2.c.

{
  tree_cell *retc = NULL;
  gcry_mpi_t p = NULL, g = NULL, q = NULL, pub = NULL, priv = NULL, data = NULL;
  gcry_mpi_t r = NULL, s = NULL;
  gcry_sexp_t ssig = NULL, skey = NULL, sdata = NULL;
  long rlen, slen;
  unsigned char *sigblob = NULL;
  gcry_error_t err;
 
  retc = g_malloc0 (sizeof (tree_cell));
  retc->ref_count = 1;
  retc->type = CONST_DATA;
  retc->x.i_val = 0;
 
  if (mpi_from_named_parameter (lexic, &p, "p", "nasl_dsa_do_sign") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &g, "g", "nasl_dsa_do_sign") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &q, "q", "nasl_dsa_do_sign") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &pub, "pub", "nasl_dsa_do_sign") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &priv, "priv", "nasl_dsa_do_sign") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &data, "data", "nasl_dsa_do_sign") < 0)
    goto fail;
 
  err = gcry_sexp_build (&sdata, NULL, "(data (flags raw) (value %m))", data);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_sexp_build for data", err);
      goto fail;
    }
 
  err = gcry_sexp_build (
    &skey, NULL, "(private-key (dsa (p %m) (q %m) (g %m) (y %m) (x %m)))", p, q,
    g, pub, priv);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_sexp_build for private-key", err);
      goto fail;
    }
 
  err = gcry_pk_sign (&ssig, sdata, skey);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_pk_sign", err);
      goto fail;
    }
 
  r = extract_mpi_from_sexp (ssig, "r");
  s = extract_mpi_from_sexp (ssig, "s");
  if (!r || !s)
    goto fail;
 
  rlen = (gcry_mpi_get_nbits (r) + 7) / 8;
  slen = (gcry_mpi_get_nbits (s) + 7) / 8;
  if (rlen > INTBLOB_LEN || slen > INTBLOB_LEN)
    {
      nasl_perror (lexic, "rlen (%d) or slen (%d) > INTBLOB_LEN (%d)\n", rlen,
                   slen, INTBLOB_LEN);
      goto fail;
    }
 
  sigblob = g_malloc0 (SIGBLOB_LEN);
  memset (sigblob, 0, SIGBLOB_LEN);
 
  err = gcry_mpi_print (
    GCRYMPI_FMT_USG,
    (unsigned char *) (sigblob + SIGBLOB_LEN - INTBLOB_LEN - rlen), rlen, NULL,
    r);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_mpi_print(r)", err);
      goto fail;
    }
  err = gcry_mpi_print (GCRYMPI_FMT_USG,
                        (unsigned char *) (sigblob + SIGBLOB_LEN - slen), rlen,
                        NULL, s);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_mpi_print(s)", err);
      goto fail;
    }
 
  retc->x.str_val = (char *) sigblob;
  sigblob = NULL;
  retc->size = SIGBLOB_LEN;
 
fail:
  gcry_mpi_release (p);
  gcry_mpi_release (g);
  gcry_mpi_release (q);
  gcry_mpi_release (pub);
  gcry_mpi_release (priv);
  gcry_mpi_release (data);
  gcry_mpi_release (r);
  gcry_mpi_release (s);
  gcry_sexp_release (ssig);
  gcry_sexp_release (skey);
  gcry_sexp_release (sdata);
  g_free (sigblob);
 
  return retc;
}

References CONST_DATA, extract_mpi_from_sexp(), TC::i_val, INTBLOB_LEN, mpi_from_named_parameter(), nasl_perror(), print_gcrypt_error(), TC::ref_count, SIGBLOB_LEN, TC::size, TC::str_val, TC::type, and TC::x.

Here is the call graph for this function:

nasl_dsa_do_verify()

tree_cell * nasl_dsa_do_verify

(

lex_ctxt *

lexic

)

nasl function

dsa_do_verify(p:mpi_p, g:mpi_g, q:mpi_q, pub:mpi_pub, r:mpi_r, s:mpi_s, data:hash)

Verify that the DSA signature given by r and s matches the hash given in data using the public DSA key given by p, g, q and pub. Returns 1 if the signature is valid and 0 if it's invalid.

Definition at line 1158 of file nasl_crypto2.c.

{
  tree_cell *retc = NULL;
  gcry_mpi_t p = NULL, g = NULL, q = NULL, pub = NULL, data = NULL;
  gcry_mpi_t r = NULL, s = NULL;
  gcry_sexp_t ssig = NULL, skey = NULL, sdata = NULL;
  gcry_error_t err;
 
  retc = g_malloc0 (sizeof (tree_cell));
  retc->ref_count = 1;
  retc->type = CONST_INT;
  retc->x.i_val = 0;
 
  if (mpi_from_named_parameter (lexic, &p, "p", "nasl_dsa_do_sign") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &g, "g", "nasl_dsa_do_sign") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &q, "q", "nasl_dsa_do_sign") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &pub, "pub", "nasl_dsa_do_sign") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &r, "r", "nasl_dsa_do_sign") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &s, "s", "nasl_dsa_do_sign") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &data, "data", "nasl_dsa_do_sign") < 0)
    goto fail;
 
  err = gcry_sexp_build (&sdata, NULL, "(data (flags raw) (value %m))", data);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_sexp_build for data", err);
      goto fail;
    }
 
  err = gcry_sexp_build (&skey, NULL,
                         "(public-key (dsa (p %m) (q %m) (g %m) (y %m)))", p, q,
                         g, pub);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_sexp_build for private key", err);
      goto fail;
    }
 
  err = gcry_sexp_build (&ssig, NULL, "(sig-val (dsa (r %m) (s %m)))", r, s);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_sexp_build for signature", err);
      goto fail;
    }
 
  err = gcry_pk_verify (ssig, sdata, skey);
  if (err == 0)
    retc->x.i_val = 1;
  else if (gcry_err_code (err) == GPG_ERR_BAD_SIGNATURE)
    retc->x.i_val = 0;
  else
    {
      print_gcrypt_error (lexic, "gcry_pk_sign", err);
      goto fail;
    }
 
fail:
  gcry_mpi_release (p);
  gcry_mpi_release (g);
  gcry_mpi_release (q);
  gcry_mpi_release (pub);
  gcry_mpi_release (r);
  gcry_mpi_release (s);
  gcry_mpi_release (data);
  gcry_sexp_release (ssig);
  gcry_sexp_release (skey);
  gcry_sexp_release (sdata);
 
  return retc;
}

References CONST_INT, TC::i_val, mpi_from_named_parameter(), print_gcrypt_error(), TC::ref_count, TC::type, and TC::x.

Here is the call graph for this function:

nasl_open_rc4_cipher()

tree_cell * nasl_open_rc4_cipher

(

lex_ctxt *

lexic

)

Nasl function to open RC4 cipher to encrypt a stream of data. The handler can be used to encrypt stream data. Open cipher must be close with close_stream_cipher() when it is not useful anymore.

Returns

Returns the id of the cipher handler encrypted data on success. Otherwise NULL.

Definition at line 1955 of file nasl_crypto2.c.

{
  return nasl_open_stream_cipher (lexic, GCRY_CIPHER_ARCFOUR,
                                  GCRY_CIPHER_MODE_STREAM, "open_rc4_cipher");
}

References nasl_open_stream_cipher().

Here is the call graph for this function:

nasl_pem_to_dsa()

tree_cell * nasl_pem_to_dsa

(

lex_ctxt *

lexic

)

nasl function

pem_to_dsa(priv:PEM, passphrase:PASSPHRASE)

Reads the private key from the string priv which contains a private DSA key in PEM format. Passphrase is the passphrase needed to decrypt the private key. The function returns the parameter "x" of the DSA key as an MPI.

Definition at line 501 of file nasl_crypto2.c.

{
  return nasl_pem_to (lexic, 1);
}

References nasl_pem_to().

Here is the call graph for this function:

nasl_pem_to_rsa()

tree_cell * nasl_pem_to_rsa

(

lex_ctxt *

lexic

)

nasl function

pem_to_rsa(priv:PEM, passphrase:PASSPHRASE)

Reads the private key from the string priv which contains a private RSA key in PEM format. Passphrase is the passphrase needed to decrypt the private key. The function returns the parameter "d" of the RSA key as an MPI.

Definition at line 485 of file nasl_crypto2.c.

{
  return nasl_pem_to (lexic, 0);
}

References nasl_pem_to().

Here is the call graph for this function:

nasl_rc4_encrypt()

tree_cell * nasl_rc4_encrypt

(

lex_ctxt *

lexic

)

Nasl function to encrypt data with a RC4 cipher. If an hd param exist in the lexix context, it will use this handler to encrypt the data as part of a stream data. e.g.: rc4_encrypt(data: data, hd: hd).

Otherwise encrypts the data as block and the key is mandatory: e.g.: rc4_encrypt(data: data, key: key)

Returns

Returns the encrypted data on success. Otherwise NULL.

Definition at line 1928 of file nasl_crypto2.c.

{
  int cipher_id;
  gcry_cipher_hd_t hd;
  cipher_id = get_int_var_by_name (lexic, "hd", -1);
 
  if (cipher_id >= 0)
    {
      hd = verify_cipher_id (lexic, cipher_id);
      if (hd == NULL)
        return NULL;
      return encrypt_stream_data (lexic, GCRY_CIPHER_ARCFOUR, "rc4_encrypt");
    }
 
  return crypt_data (lexic, GCRY_CIPHER_ARCFOUR, GCRY_CIPHER_MODE_STREAM,
                     NASL_ENCRYPT);
}

References crypt_data(), encrypt_stream_data(), get_int_var_by_name(), cipher_table_item::hd, NASL_ENCRYPT, and verify_cipher_id().

Here is the call graph for this function:

nasl_rsa_private_decrypt()

tree_cell * nasl_rsa_private_decrypt

(

lex_ctxt *

lexic

)

nasl function

rsa_private_decrypt(data:data, d:mpi_d, e:mpi_e, n:mpi_n, pad:<TRUE:FALSE>)

Decrypt the provided data with the private RSA key given by its parameters d, e and n. The return value is the decrypted data in plaintext format.

TODO: In future releases, string support for padding should be removed

Definition at line 858 of file nasl_crypto2.c.

{
  tree_cell *retc = NULL;
  gcry_mpi_t e = NULL, n = NULL, d = NULL, dt = NULL;
  gcry_sexp_t key = NULL, data = NULL, decrypted = NULL;
  gcry_error_t err;
  int type = get_var_type_by_name (lexic, "pad");
  int pad = 0;
 
  if (type == VAR2_INT)
    pad = get_int_var_by_name (lexic, "pad", 0);
  else if (type == VAR2_STRING)
    {
      if (!strcmp (get_str_var_by_name (lexic, "pad"), "TRUE"))
        pad = 1;
    }
  else
    {
      nasl_perror (lexic, "Syntax : rsa_public_encrypt(data:<d>,"
                          "n:<n>, e:<e>, pad:<TRUE:FALSE>)");
      return NULL;
    }
 
  retc = alloc_typed_cell (CONST_DATA);
 
  if (mpi_from_named_parameter (lexic, &dt, "data", "nasl_rsa_private_decrypt")
      < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &e, "e", "nasl_rsa_private_decrypt") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &n, "n", "nasl_rsa_private_decrypt") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &d, "d", "nasl_rsa_private_decrypt") < 0)
    goto fail;
 
  err = gcry_sexp_build (&key, NULL, "(private-key (rsa (n %m) (e %m) (d %m)))",
                         n, e, d);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_sexp_build privkey", err);
      goto fail;
    }
 
  if (pad == 1)
    err =
      gcry_sexp_build (&data, NULL, "(enc-val (flags pkcs1) (rsa (a %m)))", dt);
  else
    err =
      gcry_sexp_build (&data, NULL, "(enc-val (flags raw) (rsa (a %m)))", dt);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_sexp_build data", err);
      goto fail;
    }
 
  err = gcry_pk_decrypt (&decrypted, data, key);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_pk_decrypt", err);
      goto fail;
    }
 
  if (pad == 1)
    {
      if (set_retc_from_sexp (retc, decrypted, "value") >= 0
          && strip_pkcs1_padding (retc) >= 0)
        goto ret;
    }
  else
    {
      if (set_retc_from_sexp (retc, decrypted, "value") >= 0)
        goto ret;
    }
 
fail:
  retc->size = 0;
  retc->x.str_val = g_malloc0 (1);
ret:
  gcry_sexp_release (decrypted);
  gcry_sexp_release (key);
  gcry_sexp_release (data);
  gcry_mpi_release (dt);
  gcry_mpi_release (e);
  gcry_mpi_release (n);
  gcry_mpi_release (d);
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_int_var_by_name(), get_str_var_by_name(), get_var_type_by_name(), mpi_from_named_parameter(), nasl_perror(), print_gcrypt_error(), set_retc_from_sexp(), TC::size, TC::str_val, strip_pkcs1_padding(), VAR2_INT, VAR2_STRING, and TC::x.

Here is the call graph for this function:

nasl_rsa_public_decrypt()

tree_cell * nasl_rsa_public_decrypt

(

lex_ctxt *

lexic

)

nasl function

rsa_public_decrypt(sig:signature, e:mpi_e, n:mpi_n)

Decrypt the data in signature (usually an rsa-encrypted hash) with the public RSA key given by its parameters e and n. The return value is the decrypted data.

Definition at line 957 of file nasl_crypto2.c.

{
  tree_cell *retc = NULL;
  gcry_mpi_t e = NULL, n = NULL, s = NULL;
  gcry_sexp_t key = NULL, sig = NULL, decrypted = NULL;
  gcry_error_t err;
 
  retc = alloc_typed_cell (CONST_DATA);
 
  if (mpi_from_named_parameter (lexic, &s, "sig", "nasl_rsa_public_decrypt")
      < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &e, "e", "nasl_rsa_public_decrypt") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &n, "n", "nasl_rsa_public_decrypt") < 0)
    goto fail;
 
  err = gcry_sexp_build (&key, NULL, "(public-key (rsa (n %m) (e %m)))", n, e);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_sexp_build pubkey", err);
      goto fail;
    }
  err = gcry_sexp_build (&sig, NULL, "(data (flags raw) (value %m))", s);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_sexp_build sig", err);
      goto fail;
    }
 
  /* gcry_pk_encrypt is equivalent to the public key decryption at least
   * for RSA keys. */
  err = gcry_pk_encrypt (&decrypted, sig, key);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_pk_encrypt", err);
      goto fail;
    }
 
  if (set_retc_from_sexp (retc, decrypted, "a") >= 0
      && strip_pkcs1_padding (retc) >= 0)
    goto ret;
 
fail:
  retc->size = 0;
  retc->x.str_val = g_malloc0 (1);
ret:
  gcry_sexp_release (decrypted);
  gcry_sexp_release (key);
  gcry_sexp_release (sig);
  gcry_mpi_release (s);
  gcry_mpi_release (e);
  gcry_mpi_release (n);
  return retc;
}

References alloc_typed_cell(), CONST_DATA, mpi_from_named_parameter(), print_gcrypt_error(), set_retc_from_sexp(), TC::size, TC::str_val, strip_pkcs1_padding(), and TC::x.

Here is the call graph for this function:

nasl_rsa_public_encrypt()

tree_cell * nasl_rsa_public_encrypt

(

lex_ctxt *

lexic

)

nasl function

rsa_public_encrypt(data:data, e:mpi_e, n:mpi_n, pad:<TRUE:FALSE>)

Encrypt the provided data with the public RSA key given by its parameters e and n. The return value is the encrypted data.

TODO: In future releases, string support for padding should be removed

Definition at line 766 of file nasl_crypto2.c.

{
  tree_cell *retc = NULL;
  gcry_mpi_t e = NULL, n = NULL, dt = NULL;
  gcry_sexp_t key = NULL, data = NULL, encrypted = NULL;
  gcry_error_t err;
  int type = get_var_type_by_name (lexic, "pad");
  int pad = 0;
 
  if (type == VAR2_INT)
    pad = get_int_var_by_name (lexic, "pad", 0);
  else if (type == VAR2_STRING)
    {
      if (!strcmp (get_str_var_by_name (lexic, "pad"), "TRUE"))
        pad = 1;
    }
  else
    {
      nasl_perror (lexic, "Syntax : rsa_public_encrypt(data:<d>,"
                          "n:<n>, e:<e>, pad:<TRUE:FALSE>)");
      return NULL;
    }
 
  retc = alloc_typed_cell (CONST_DATA);
 
  if (mpi_from_named_parameter (lexic, &dt, "data", "nasl_rsa_public_encrypt")
      < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &e, "e", "nasl_rsa_public_encrypt") < 0)
    goto fail;
  if (mpi_from_named_parameter (lexic, &n, "n", "nasl_rsa_public_encrypt") < 0)
    goto fail;
 
  err = gcry_sexp_build (&key, NULL, "(public-key (rsa (n %m) (e %m)))", n, e);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_sexp_build pubkey", err);
      goto fail;
    }
 
  if (pad == 1)
    err = gcry_sexp_build (&data, NULL, "(data (flags pkcs1) (value %m))", dt);
  else
    err = gcry_sexp_build (&data, NULL, "(data (flags raw) (value %m))", dt);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_sexp_build data", err);
      goto fail;
    }
 
  err = gcry_pk_encrypt (&encrypted, data, key);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_pk_encrypt", err);
      goto fail;
    }
 
  if (pad == 1)
    {
      if (set_retc_from_sexp (retc, encrypted, "a") >= 0
          && strip_pkcs1_padding (retc) >= 0)
        goto ret;
    }
  else
    {
      if (set_retc_from_sexp (retc, encrypted, "a") >= 0)
        goto ret;
    }
 
fail:
  retc->size = 0;
  retc->x.str_val = g_malloc0 (1);
ret:
  gcry_sexp_release (encrypted);
  gcry_sexp_release (key);
  gcry_sexp_release (data);
  gcry_mpi_release (dt);
  gcry_mpi_release (e);
  gcry_mpi_release (n);
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_int_var_by_name(), get_str_var_by_name(), get_var_type_by_name(), mpi_from_named_parameter(), nasl_perror(), print_gcrypt_error(), set_retc_from_sexp(), TC::size, TC::str_val, strip_pkcs1_padding(), VAR2_INT, VAR2_STRING, and TC::x.

Here is the call graph for this function:

nasl_rsa_sign()

tree_cell * nasl_rsa_sign

(

lex_ctxt *

lexic

)

nasl function

rsa_sign(data:hash, priv:pem, passphrase:passphrase)

Signs the data with the private RSA key priv given in PEM format. The passphrase is the passphrase needed to decrypt the private key. Returns the signed data.

In the OpenSSL based nasl, the key was not given in PEM form and with a passphrase. Instead it was given as the RSA parameters e, n and d. libgcrypt always requires all the parameters (including p, g, and u), so this function was changed to simply accept the full private key in PEM form. The one place where it was called had that the key available in that form.

Definition at line 1094 of file nasl_crypto2.c.

{
  tree_cell *retc = NULL;
  char *data;
  size_t data_size;
  gcry_sexp_t ssig = NULL, sdata = NULL, skey = NULL;
  gnutls_x509_privkey_t priv_key = NULL;
  gcry_error_t err;
 
  retc = alloc_typed_cell (CONST_DATA);
 
  data = get_str_var_by_name (lexic, "data");
  data_size = get_var_size_by_name (lexic, "data");
  if (!data)
    goto fail;
 
  priv_key = nasl_load_privkey_param (lexic, "priv", "passphrase");
  if (!priv_key)
    goto fail;
 
  err = gcry_sexp_build (&sdata, NULL, "(data (flags pkcs1) (hash sha1 %b))",
                         data_size, data);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_sexp_build for data", err);
      goto fail;
    }
 
  skey = nasl_sexp_from_privkey (lexic, priv_key);
  if (!skey)
    goto fail;
 
  err = gcry_pk_sign (&ssig, sdata, skey);
  if (err)
    {
      print_gcrypt_error (lexic, "gcry_pk_sign", err);
      goto fail;
    }
 
  if (set_retc_from_sexp (retc, ssig, "s") >= 0)
    goto ret;
 
fail:
  retc->size = 0;
  retc->x.str_val = g_malloc0 (1);
ret:
  gcry_sexp_release (ssig);
  gcry_sexp_release (sdata);
  gcry_sexp_release (skey);
  gnutls_x509_privkey_deinit (priv_key);
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_str_var_by_name(), get_var_size_by_name(), nasl_load_privkey_param(), nasl_sexp_from_privkey(), print_gcrypt_error(), set_retc_from_sexp(), TC::size, TC::str_val, and TC::x.

Here is the call graph for this function:

nasl_smb3kdf()

tree_cell * nasl_smb3kdf

(

lex_ctxt *

lexic

)

Add the SMB3KDF as specified in [SP800-108] section 5.1.

Parameters

lexic

Returns

tree_cell*

Definition at line 2111 of file nasl_crypto2.c.

{
  gcry_mac_hd_t hd;
  gcry_error_t error;
  void *result, *key, *label, *context, *buf;
  u_char *tmp;
  size_t resultlen, keylen, labellen, contextlen, buflen, r = 4;
  u_int32_t lvalue;
  int i = 1;
  tree_cell *retc;
 
  key = get_str_var_by_name (lexic, "key");
  keylen = get_var_size_by_name (lexic, "key");
  label = get_str_var_by_name (lexic, "label");
  labellen = get_var_size_by_name (lexic, "label");
  context = get_str_var_by_name (lexic, "ctx");
  contextlen = get_var_size_by_name (lexic, "ctx");
  lvalue = (u_int32_t) get_int_var_by_name (lexic, "lvalue", 0);
 
  if (!key || keylen <= 0 || !label || labellen <= 0 || !context
      || contextlen <= 0)
    {
      nasl_perror (
        lexic, "Syntax: nasl_smb3kdf: Missing key, label or context argument");
      return NULL;
    }
 
  if (lvalue != 128 && lvalue != 256)
    {
      nasl_perror (lexic,
                   "nasl_smb3kdf: lvalue must have a value of 128 or 256");
      return NULL;
    }
 
  if ((error = gcry_mac_open (&hd, GCRY_MAC_HMAC_SHA256, 0, NULL)))
    {
      nasl_perror (lexic, "gcry_mac_open: %s", gcry_strerror (error));
      gcry_mac_close (hd);
      return NULL;
    }
 
  if ((error = gcry_mac_setkey (hd, key, keylen)))
    {
      nasl_perror (lexic, "gcry_mac_setkey: %s", gcry_strerror (error));
      gcry_mac_close (hd);
      return NULL;
    }
 
  resultlen = lvalue / 8;
 
  // Prepare buffer as in [SP800-108] section 5.1
  // [i]2 || Label || 0x00 || Context || [L]2
  // [i]2 is the binary presentation of the iteration. Allways 1
  // Label is given by caller
  // 0x00 is a byte set to 0
  // Context is given by caller
  // L is a integer set to 128 or 256 for smb3kdf
  buflen = r + labellen + 1 + contextlen + 4;
  buf = g_malloc0 (buflen);
  tmp = buf;
 
  // We need bytes in big endian, but they are currently stored as little endian
  i = htonl (i);
  memcpy (tmp, &i, r);
  tmp = tmp + r;
 
  memcpy (tmp, label, labellen);
  tmp = tmp + labellen;
  *tmp = 0;
  tmp = tmp + 1;
  memcpy (tmp, context, contextlen);
  tmp = tmp + contextlen;
 
  // We need bytes in big endian, but they are currently stored as little endian
  lvalue = htonl (lvalue);
  memcpy (tmp, &lvalue, 4);
 
  if ((error = gcry_mac_write (hd, buf, buflen)))
    {
      g_message ("gcry_mac_write: %s", gcry_strerror (error));
      gcry_mac_close (hd);
      g_free (buf);
      return NULL;
    }
 
  result = g_malloc0 (resultlen);
  if ((error = gcry_mac_read (hd, result, &resultlen)))
    {
      g_message ("gcry_mac_read: %s", gcry_strerror (error));
      gcry_mac_close (hd);
      g_free (buf);
      g_free (result);
      return NULL;
    }
 
  g_free (buf);
  gcry_mac_close (hd);
  retc = alloc_typed_cell (CONST_DATA);
  retc->x.str_val = result;
  retc->size = resultlen;
  return retc;
}

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

Here is the call graph for this function: