27 #include <gnutls/gnutls.h> 28 #include <gnutls/x509.h> 30 #include "../misc/openvas_logging.h" 44 #define INTBLOB_LEN 20 45 #define SIGBLOB_LEN (2*INTBLOB_LEN) 66 nasl_perror (lexic,
"%s failed: %s/%s\n",
function, gcry_strsource (
err),
83 mpi_from_string (
lex_ctxt * lexic, gcry_mpi_t * dest,
void *data,
size_t len,
84 const char *parameter,
const char *
function)
87 unsigned char *buffer = data;
89 err = gcry_mpi_scan (dest, GCRYMPI_FMT_USG, buffer, len, NULL);
92 nasl_perror (lexic,
"%s(): gcry_mpi_scan failed for %s: %s/%s\n",
93 function, parameter, gcry_strsource (
err),
112 mpi_from_named_parameter (
lex_ctxt * lexic, gcry_mpi_t * dest,
113 const char *parameter,
const char *
function)
124 return mpi_from_string (lexic, dest, s, size, parameter,
function);
146 set_mpi_retc (
tree_cell * retc, gcry_mpi_t mpi)
148 unsigned char *buffer = NULL;
151 gcry_mpi_aprint (GCRYMPI_FMT_USG, &buffer, &size, mpi);
156 memcpy (retc->
x.
str_val, buffer, size);
176 gcry_mpi_t key1 = NULL, key2 = NULL;
183 if (mpi_from_named_parameter (lexic, &key1,
"key1",
"nasl_bn_cmp") < 0)
185 if (mpi_from_named_parameter (lexic, &key2,
"key2",
"nasl_bn_cmp") < 0)
188 retc->
x.
i_val = gcry_mpi_cmp (key1, key2);
197 gcry_mpi_release (key1);
198 gcry_mpi_release (key2);
213 gcry_mpi_t key = NULL;
222 key = gcry_mpi_new (0);
226 gcry_mpi_randomize (key, need, GCRY_STRONG_RANDOM);
228 if (set_mpi_retc (retc, key) >= 0)
235 gcry_mpi_release (key);
249 static gnutls_x509_privkey_t
250 nasl_load_privkey_param (
lex_ctxt * lexic,
const char *priv_name,
251 const char *passphrase_name)
253 char *priv = NULL, *passphrase = NULL;
255 gnutls_x509_privkey_t privkey = NULL;
265 pem.data = (
unsigned char *) priv;
268 err = gnutls_x509_privkey_init (&privkey);
275 if (passphrase && !*passphrase)
277 err = gnutls_x509_privkey_import2
278 (privkey, &pem, GNUTLS_X509_FMT_PEM, passphrase,
279 passphrase ? 0 : GNUTLS_PKCS_PLAIN);
288 gnutls_x509_privkey_deinit (privkey);
299 gnutls_x509_privkey_t privkey = NULL;
300 gcry_mpi_t key = NULL;
306 privkey = nasl_load_privkey_param (lexic,
"priv",
"passphrase");
312 gnutls_datum_t m, e, d, p, q, u;
314 gnutls_x509_privkey_export_rsa_raw (privkey, &m, &e, &d, &p, &q, &u);
322 mpi_from_string (lexic, &key, d.data, d.size,
"rsa d",
"nasl_pem_to");
323 gnutls_free (m.data);
324 gnutls_free (e.data);
325 gnutls_free (d.data);
326 gnutls_free (p.data);
327 gnutls_free (q.data);
328 gnutls_free (u.data);
335 gnutls_datum_t p, q, g, y, x;
336 err = gnutls_x509_privkey_export_dsa_raw (privkey, &p, &q, &g, &y, &x);
344 mpi_from_string (lexic, &key, x.data, x.size,
"dsa x",
"nasl_pem_to");
346 gnutls_free (p.data);
347 gnutls_free (q.data);
348 gnutls_free (g.data);
349 gnutls_free (y.data);
350 gnutls_free (x.data);
356 if (set_mpi_retc (retc, key) >= 0)
363 gcry_mpi_release (key);
364 gnutls_x509_privkey_deinit (privkey);
415 calc_dh_public (gcry_mpi_t g, gcry_mpi_t prime, gcry_mpi_t priv)
419 e = gcry_mpi_new (gcry_mpi_get_nbits (prime));
425 gcry_mpi_powm (e, g, priv, prime);
442 calc_dh_key (gcry_mpi_t pub, gcry_mpi_t prime, gcry_mpi_t priv)
446 e = gcry_mpi_new (gcry_mpi_get_nbits (prime));
452 gcry_mpi_powm (e, pub, priv, prime);
470 gcry_mpi_t p = NULL, g = NULL, priv = NULL, pub_mpi = NULL;
475 if (mpi_from_named_parameter (lexic, &p,
"p",
"nasl_dh_generate_key") < 0)
477 if (mpi_from_named_parameter (lexic, &g,
"g",
"nasl_dh_generate_key") < 0)
479 if (mpi_from_named_parameter (lexic, &priv,
"priv",
"nasl_dh_generate_key") <
483 pub_mpi = calc_dh_public (g, p, priv);
487 if (set_mpi_retc (retc, pub_mpi) >= 0)
494 gcry_mpi_release (p);
495 gcry_mpi_release (g);
496 gcry_mpi_release (priv);
497 gcry_mpi_release (pub_mpi);
516 gcry_mpi_t p = NULL, g = NULL, dh_server_pub = NULL;
517 gcry_mpi_t pub_key = NULL, priv_key = NULL;
518 gcry_mpi_t shared = NULL;
523 if (mpi_from_named_parameter (lexic, &p,
"p",
"nasl_dh_compute_key") < 0)
525 if (mpi_from_named_parameter (lexic, &g,
"g",
"nasl_dh_compute_key") < 0)
527 if (mpi_from_named_parameter
528 (lexic, &dh_server_pub,
"dh_server_pub",
"nasl_dh_compute_key") < 0)
530 if (mpi_from_named_parameter
531 (lexic, &pub_key,
"pub_key",
"nasl_dh_compute_key") < 0)
533 if (mpi_from_named_parameter
534 (lexic, &priv_key,
"priv_key",
"nasl_dh_compute_key") < 0)
537 shared = calc_dh_key (dh_server_pub, p, priv_key);
539 if (set_mpi_retc (retc, shared) >= 0)
546 gcry_mpi_release (p);
547 gcry_mpi_release (g);
548 gcry_mpi_release (dh_server_pub);
549 gcry_mpi_release (priv_key);
550 gcry_mpi_release (pub_key);
551 gcry_mpi_release (shared);
564 extract_mpi_from_sexp (gcry_sexp_t sexp,
const char *token)
566 gcry_sexp_t child = NULL;
567 gcry_mpi_t mpi = NULL;
569 child = gcry_sexp_find_token (sexp, token, strlen (token));
577 mpi = gcry_sexp_nth_mpi (child, 1, GCRYMPI_FMT_USG);
580 gcry_sexp_release (child);
595 set_retc_from_sexp (
tree_cell * retc, gcry_sexp_t sexp,
const char *token)
598 gcry_mpi_t mpi = extract_mpi_from_sexp (sexp, token);
601 ret = set_mpi_retc (retc, mpi);
603 gcry_mpi_release (mpi);
628 if (p[0] == 1 || p[0] == 2)
634 while (i < retc->size && p[i])
640 int rest = retc->
size - i;
641 temp = g_malloc0 (rest);
642 memcpy (temp, p + i, rest);
666 gcry_mpi_t e = NULL, n = NULL, dt = NULL;
667 gcry_sexp_t key = NULL, data = NULL, encrypted = NULL;
674 "Syntax : rsa_public_encrypt(data:<d>," 675 "n:<n>, e:<e>, pad:<pad>)");
681 if (mpi_from_named_parameter (lexic, &dt,
"data",
"nasl_rsa_public_encrypt") <
684 if (mpi_from_named_parameter (lexic, &e,
"e",
"nasl_rsa_public_encrypt") < 0)
686 if (mpi_from_named_parameter (lexic, &n,
"n",
"nasl_rsa_public_encrypt") < 0)
689 err = gcry_sexp_build (&key, NULL,
"(public-key (rsa (n %m) (e %m)))", n, e);
696 if (strcmp (pad,
"TRUE") == 0)
697 err = gcry_sexp_build (&data, NULL,
"(data (flags pkcs1) (value %m))", dt);
699 err = gcry_sexp_build (&data, NULL,
"(data (flags raw) (value %m))", dt);
706 err = gcry_pk_encrypt (&encrypted, data, key);
713 if (strcmp (pad,
"TRUE") == 0)
715 if (set_retc_from_sexp (retc, encrypted,
"a") >= 0 &&
716 strip_pkcs1_padding (retc) >= 0)
721 if (set_retc_from_sexp (retc, encrypted,
"a") >= 0)
729 gcry_sexp_release (encrypted);
730 gcry_sexp_release (key);
731 gcry_sexp_release (data);
732 gcry_mpi_release (dt);
733 gcry_mpi_release (e);
734 gcry_mpi_release (n);
750 gcry_mpi_t e = NULL, n = NULL, d = NULL, dt = NULL;
751 gcry_sexp_t key = NULL, data = NULL, decrypted = NULL;
758 "Syntax : rsa_public_encrypt(data:<d>," 759 "n:<n>, d:<d>, e:<e>, pad:<pad>)");
765 if (mpi_from_named_parameter (lexic, &dt,
"data",
766 "nasl_rsa_private_decrypt") < 0)
768 if (mpi_from_named_parameter (lexic, &e,
"e",
"nasl_rsa_private_decrypt") < 0)
770 if (mpi_from_named_parameter (lexic, &n,
"n",
"nasl_rsa_private_decrypt") < 0)
772 if (mpi_from_named_parameter (lexic, &d,
"d",
"nasl_rsa_private_decrypt") < 0)
775 err = gcry_sexp_build (&key, NULL,
"(private-key (rsa (n %m) (e %m) (d %m)))",
783 if (strcmp (pad,
"TRUE") == 0)
784 err = gcry_sexp_build (&data, NULL,
"(enc-val (flags pkcs1) (rsa (a %m)))",
787 err = gcry_sexp_build (&data, NULL,
"(enc-val (flags raw) (rsa (a %m)))",
795 err = gcry_pk_decrypt (&decrypted, data, key);
802 if (strcmp (pad,
"TRUE") == 0)
804 if (set_retc_from_sexp (retc, decrypted,
"value") >= 0 &&
805 strip_pkcs1_padding (retc) >= 0)
810 if (set_retc_from_sexp (retc, decrypted,
"value") >= 0)
818 gcry_sexp_release (decrypted);
819 gcry_sexp_release (key);
820 gcry_sexp_release (data);
821 gcry_mpi_release (dt);
822 gcry_mpi_release (e);
823 gcry_mpi_release (n);
824 gcry_mpi_release (d);
841 gcry_mpi_t e = NULL, n = NULL, s = NULL;
842 gcry_sexp_t key = NULL, sig = NULL, decrypted = NULL;
848 if (mpi_from_named_parameter (lexic, &s,
"sig",
"nasl_rsa_public_decrypt") <
851 if (mpi_from_named_parameter (lexic, &e,
"e",
"nasl_rsa_public_decrypt") < 0)
853 if (mpi_from_named_parameter (lexic, &n,
"n",
"nasl_rsa_public_decrypt") < 0)
856 err = gcry_sexp_build (&key, NULL,
"(public-key (rsa (n %m) (e %m)))", n, e);
862 err = gcry_sexp_build (&sig, NULL,
"(data (flags raw) (value %m))", s);
871 err = gcry_pk_encrypt (&decrypted, sig, key);
878 if (set_retc_from_sexp (retc, decrypted,
"a") >= 0
879 && strip_pkcs1_padding (retc) >= 0)
886 gcry_sexp_release (decrypted);
887 gcry_sexp_release (key);
888 gcry_sexp_release (sig);
889 gcry_mpi_release (s);
890 gcry_mpi_release (e);
891 gcry_mpi_release (n);
898 #define NUM_RSA_PARAMS 6 900 nasl_sexp_from_privkey (
lex_ctxt * lexic, gnutls_x509_privkey_t privkey)
904 gcry_sexp_t key = NULL;
911 datums[i].data = NULL;
916 gnutls_x509_privkey_export_rsa_raw (privkey, datums + 0, datums + 1,
917 datums + 2, datums + 3, datums + 4,
928 mpi_from_string (lexic, mpis + i, datums[i].data, datums[i].size,
929 "rsa parameter",
"nasl_sexp_from_privkey");
935 if (gcry_mpi_cmp (mpis[3], mpis[4]) > 0)
937 gcry_mpi_swap (mpis[3], mpis[4]);
938 gcry_mpi_invm (mpis[5], mpis[3], mpis[4]);
942 gcry_sexp_build (&key, NULL,
943 "(private-key (rsa (n %m) (e %m) (d %m)" 944 " (p %m) (q %m) (u %m)))", mpis[0], mpis[1], mpis[2],
945 mpis[3], mpis[4], mpis[5]);
955 gnutls_free (datums[i].data);
956 gcry_mpi_release (mpis[i]);
985 gcry_sexp_t ssig = NULL, sdata = NULL, skey = NULL;
986 gnutls_x509_privkey_t priv_key = NULL;
997 priv_key = nasl_load_privkey_param (lexic,
"priv",
"passphrase");
1002 gcry_sexp_build (&sdata, NULL,
"(data (flags pkcs1) (hash sha1 %b))",
1010 skey = nasl_sexp_from_privkey (lexic, priv_key);
1015 err = gcry_pk_sign (&ssig, sdata, skey);
1022 if (set_retc_from_sexp (retc, ssig,
"s") >= 0)
1029 gcry_sexp_release (ssig);
1030 gcry_sexp_release (sdata);
1031 gcry_sexp_release (skey);
1032 gnutls_x509_privkey_deinit (priv_key);
1051 gcry_mpi_t p = NULL, g = NULL, q = NULL, pub = NULL, data = NULL;
1052 gcry_mpi_t r = NULL, s = NULL;
1053 gcry_sexp_t ssig = NULL, skey = NULL, sdata = NULL;
1061 if (mpi_from_named_parameter (lexic, &p,
"p",
"nasl_dsa_do_sign") < 0)
1063 if (mpi_from_named_parameter (lexic, &g,
"g",
"nasl_dsa_do_sign") < 0)
1065 if (mpi_from_named_parameter (lexic, &q,
"q",
"nasl_dsa_do_sign") < 0)
1067 if (mpi_from_named_parameter (lexic, &pub,
"pub",
"nasl_dsa_do_sign") < 0)
1069 if (mpi_from_named_parameter (lexic, &r,
"r",
"nasl_dsa_do_sign") < 0)
1071 if (mpi_from_named_parameter (lexic, &s,
"s",
"nasl_dsa_do_sign") < 0)
1073 if (mpi_from_named_parameter (lexic, &data,
"data",
"nasl_dsa_do_sign") < 0)
1076 err = gcry_sexp_build (&sdata, NULL,
"(data (flags raw) (value %m))", data);
1084 gcry_sexp_build (&skey, NULL,
1085 "(public-key (dsa (p %m) (q %m) (g %m) (y %m)))", p, q, g,
1093 err = gcry_sexp_build (&ssig, NULL,
"(sig-val (dsa (r %m) (s %m)))", r, s);
1100 err = gcry_pk_verify (ssig, sdata, skey);
1103 else if (gcry_err_code (
err) == GPG_ERR_BAD_SIGNATURE)
1112 gcry_mpi_release (p);
1113 gcry_mpi_release (g);
1114 gcry_mpi_release (q);
1115 gcry_mpi_release (pub);
1116 gcry_mpi_release (r);
1117 gcry_mpi_release (s);
1118 gcry_mpi_release (data);
1119 gcry_sexp_release (ssig);
1120 gcry_sexp_release (skey);
1121 gcry_sexp_release (sdata);
1141 gcry_mpi_t p = NULL, g = NULL, q = NULL, pub = NULL, priv = NULL, data = NULL;
1142 gcry_mpi_t r = NULL, s = NULL;
1143 gcry_sexp_t ssig = NULL, skey = NULL, sdata = NULL;
1145 unsigned char *sigblob = NULL;
1153 if (mpi_from_named_parameter (lexic, &p,
"p",
"nasl_dsa_do_sign") < 0)
1155 if (mpi_from_named_parameter (lexic, &g,
"g",
"nasl_dsa_do_sign") < 0)
1157 if (mpi_from_named_parameter (lexic, &q,
"q",
"nasl_dsa_do_sign") < 0)
1159 if (mpi_from_named_parameter (lexic, &pub,
"pub",
"nasl_dsa_do_sign") < 0)
1161 if (mpi_from_named_parameter (lexic, &priv,
"priv",
"nasl_dsa_do_sign") < 0)
1163 if (mpi_from_named_parameter (lexic, &data,
"data",
"nasl_dsa_do_sign") < 0)
1166 err = gcry_sexp_build (&sdata, NULL,
"(data (flags raw) (value %m))", data);
1174 gcry_sexp_build (&skey, NULL,
1175 "(private-key (dsa (p %m) (q %m) (g %m) (y %m) (x %m)))",
1176 p, q, g, pub, priv);
1183 err = gcry_pk_sign (&ssig, sdata, skey);
1190 r = extract_mpi_from_sexp (ssig,
"r");
1191 s = extract_mpi_from_sexp (ssig,
"s");
1195 rlen = (gcry_mpi_get_nbits (r) + 7) / 8;
1196 slen = (gcry_mpi_get_nbits (s) + 7) / 8;
1199 nasl_perror (lexic,
"rlen (%d) or slen (%d) > INTBLOB_LEN (%d)\n", rlen,
1208 gcry_mpi_print (GCRYMPI_FMT_USG,
1210 rlen), rlen, NULL, r);
1217 gcry_mpi_print (GCRYMPI_FMT_USG,
1218 (
unsigned char *) (sigblob +
SIGBLOB_LEN - slen), rlen,
1226 retc->
x.
str_val = (
char *) sigblob;
1231 gcry_mpi_release (p);
1232 gcry_mpi_release (g);
1233 gcry_mpi_release (q);
1234 gcry_mpi_release (pub);
1235 gcry_mpi_release (priv);
1236 gcry_mpi_release (data);
1237 gcry_mpi_release (r);
1238 gcry_mpi_release (s);
1239 gcry_sexp_release (ssig);
1240 gcry_sexp_release (skey);
1241 gcry_sexp_release (sdata);
1254 char *enckey = NULL, *iv = NULL, *data = NULL, *out = NULL;
1255 long enckeylen, ivlen, datalen;
1256 gcry_cipher_hd_t hd = NULL;
1276 if (enckey == NULL || data == NULL || iv == NULL)
1283 "nasl_bf_cbc: unexpected enckeylen = %d; must be >= 16\n",
1288 else if (enckeylen > 16)
1295 "nasl_bf_cbc: unexpected enckeylen = %d;" 1296 " will only use the first 16 bytes\n", enckeylen);
1301 nasl_perror (lexic,
"nasl_bf_cbc: unexpected ivlen = %d; must >= 8\n",
1307 nasl_perror (lexic,
"nasl_bf_cbc: unexpected datalen = %d; must >= 8\n",
1312 err = gcry_cipher_open (&hd, GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_CBC, 0);
1322 err = gcry_cipher_setkey (hd, enckey, 16);
1331 err = gcry_cipher_setiv (hd, iv, 8);
1338 out = g_malloc0 (datalen);
1343 err = gcry_cipher_encrypt (hd, out, datalen, data, datalen);
1345 err = gcry_cipher_decrypt (hd, out, datalen, data, datalen);
1368 v.
v.
v_str.
s_val = (
unsigned char *) ((enc ? out : data) + datalen - 8);
1380 gcry_cipher_close (hd);
1428 encrypt_data (
lex_ctxt *lexic,
int cipher,
int mode)
1430 gcry_cipher_hd_t hd;
1432 void *result, *data, *key, *tmp, *iv;
1433 size_t resultlen, datalen, keylen, tmplen, ivlen;
1443 if (!data || datalen <= 0 || !key || keylen <= 0)
1445 nasl_perror (lexic,
"Syntax: encrypt_data: Missing data or key argument");
1449 if ((error = gcry_cipher_open (&hd, cipher, mode, 0)))
1451 nasl_perror (lexic,
"gcry_cipher_open: %s", gcry_strerror (error));
1452 gcry_cipher_close (hd);
1455 if ((error = gcry_cipher_setkey (hd, key, keylen)))
1457 nasl_perror (lexic,
"gcry_cipher_setkey: %s", gcry_strerror (error));
1458 gcry_cipher_close (hd);
1462 if (cipher == GCRY_CIPHER_ARCFOUR)
1464 resultlen = datalen;
1465 tmp = g_memdup (data, datalen);
1468 else if (cipher == GCRY_CIPHER_3DES)
1470 if (datalen % 8 == 0)
1471 resultlen = datalen;
1473 resultlen = ((datalen / 8) + 1) * 8;
1474 tmp = g_malloc0 (resultlen);
1476 memcpy (tmp, data, datalen);
1478 else if (cipher == GCRY_CIPHER_AES128)
1480 if (datalen % 16 == 0)
1481 resultlen = datalen;
1483 resultlen = ((datalen / 16) + 1) * 16;
1484 tmp = g_malloc0 (resultlen);
1486 memcpy (tmp, data, datalen);
1488 else if (cipher == GCRY_CIPHER_AES256)
1490 if (datalen % 32 == 0)
1491 resultlen = datalen;
1493 resultlen = ((datalen / 32) + 1) * 32;
1494 tmp = g_malloc0 (resultlen);
1496 memcpy (tmp, data, datalen);
1500 nasl_perror (lexic,
"encrypt_data: Unknown cipher %d", cipher);
1501 gcry_cipher_close (hd);
1507 if ((error = gcry_cipher_setiv (hd, iv, ivlen)))
1509 nasl_perror (lexic,
"gcry_cipher_setiv: %s", gcry_strerror (error));
1514 result = g_malloc0 (resultlen);
1515 if ((error = gcry_cipher_encrypt (hd, result, resultlen, tmp, tmplen)))
1518 gcry_cipher_close (hd);
1525 gcry_cipher_close (hd);
1529 retc->
size = resultlen;
1536 return encrypt_data (lexic, GCRY_CIPHER_ARCFOUR, GCRY_CIPHER_MODE_STREAM);
1542 return encrypt_data (lexic, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CBC);
1548 return encrypt_data (lexic, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC);
1554 return encrypt_data (lexic, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CTR);
1560 return encrypt_data (lexic, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CTR);
1566 return encrypt_data (lexic, GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CBC);
1572 return encrypt_data (lexic, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_GCM);
1578 return encrypt_data (lexic, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_GCM);
tree_cell * nasl_rsa_public_decrypt(lex_ctxt *lexic)
tree_cell * nasl_bn_random(lex_ctxt *lexic)
tree_cell * nasl_bf_cbc_encrypt(lex_ctxt *lexic)
tree_cell * nasl_aes128_cbc_encrypt(lex_ctxt *lexic)
#define NUM_RSA_PARAMS
Creates a libgcryt s-expression from a GnuTLS private RSA key.
union st_a_nasl_var::@9 v
tree_cell * nasl_aes128_ctr_encrypt(lex_ctxt *lexic)
tree_cell * nasl_dsa_do_verify(lex_ctxt *lexic)
tree_cell * nasl_aes128_gcm_encrypt(lex_ctxt *lexic)
void log_legacy_write(const char *format,...)
Legacy function to write a log message.
long int get_int_local_var_by_name(lex_ctxt *, const char *, int)
char * get_str_local_var_by_name(lex_ctxt *, const char *)
char * get_str_var_by_name(lex_ctxt *, const char *)
void print_tls_error(lex_ctxt *lexic, char *txt, int err)
Prints a GnuTLS error.
tree_cell * nasl_rsa_sign(lex_ctxt *lexic)
int add_var_to_list(nasl_array *a, int i, const anon_nasl_var *v)
tree_cell * nasl_dh_compute_key(lex_ctxt *lexic)
tree_cell * nasl_bn_cmp(lex_ctxt *lexic)
void print_gcrypt_error(lex_ctxt *lexic, char *function, int err)
Prints a libgcrypt error.
tree_cell * nasl_bf_cbc_decrypt(lex_ctxt *lexic)
tree_cell * nasl_rc4_encrypt(lex_ctxt *lexic)
tree_cell * nasl_aes256_gcm_encrypt(lex_ctxt *lexic)
tree_cell * nasl_dsa_do_sign(lex_ctxt *lexic)
tree_cell * nasl_rsa_private_decrypt(lex_ctxt *lexic)
tree_cell * nasl_aes256_cbc_encrypt(lex_ctxt *lexic)
void nasl_perror(lex_ctxt *lexic, char *msg,...)
tree_cell * nasl_rsa_public_encrypt(lex_ctxt *lexic)
tree_cell * nasl_dh_generate_key(lex_ctxt *lexic)
tree_cell * nasl_pem_to_dsa(lex_ctxt *lexic)
tree_cell * alloc_tree_cell(int lnb, char *s)
tree_cell * nasl_pem_to_rsa(lex_ctxt *lexic)
tree_cell * nasl_des_ede_cbc_encrypt(lex_ctxt *lexic)
tree_cell * nasl_aes256_ctr_encrypt(lex_ctxt *lexic)
int get_var_size_by_name(lex_ctxt *, const char *)
tree_cell * nasl_pem_to(lex_ctxt *lexic, int type)
Implements the nasl functions pem_to_rsa and pem_to_dsa.
tree_cell * nasl_bf_cbc(lex_ctxt *lexic, int enc)
Implements the nasl functions bf_cbc_encrypt and bf_cbc_decrypt.