15 files changed, 236 insertions, 194 deletions

diff --git a/lib/crypto/c_src/aead.c b/lib/crypto/c_src/aead.c
index 4ed16615a5..ab0e609130 100644
--- a/lib/crypto/c_src/aead.c
+++ b/lib/crypto/c_src/aead.c
@@ -22,36 +22,65 @@
 #include "aes.h"
 #include "cipher.h"
 
-ERL_NIF_TERM aead_encrypt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
-{/* (Type,Key,Iv,AAD,In) */
+
+
+ERL_NIF_TERM aead_cipher(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{/*
+   (Type,Key,Iv,AAD,In,TagLen,true)
+   (Type,Key,Iv,AAD,In,Tag,false)
+ */
 #if defined(HAVE_AEAD)
     const struct cipher_type_t *cipherp;
     EVP_CIPHER_CTX *ctx = NULL;
     const EVP_CIPHER *cipher = NULL;
-    ErlNifBinary key, iv, aad, in;
+    ErlNifBinary key, iv, aad, in, tag;
     unsigned int tag_len;
-    unsigned char *outp, *tagp;
-    ERL_NIF_TERM type, out, out_tag, ret;
-    int len, ctx_ctrl_set_ivlen, ctx_ctrl_get_tag, ctx_ctrl_set_tag;
+    unsigned char *outp, *tagp, *tag_data;
+    ERL_NIF_TERM type, out, out_tag, ret, encflg_arg;
+    int len, encflg;
+
+    encflg_arg = argv[6];
+
+    /* Fetch the flag telling if we are going to encrypt (=true) or decrypt (=false) */
+    if (encflg_arg == atom_true)
+        encflg = 1;
+    else if (encflg_arg == atom_false)
+        encflg = 0;
+    else if (encflg_arg == atom_undefined)
+        /* For compat funcs in crypto.erl */
+        encflg = -1;
+    else
+        {
+            ret = EXCP_BADARG(env, "Bad enc flag");
+            goto done;
+        }
 
     type = argv[0];
 
-    ASSERT(argc == 6);
-
     if (!enif_is_atom(env, type))
         {ret = EXCP_BADARG(env, "non-atom cipher type"); goto done;}
     if (!enif_inspect_iolist_as_binary(env, argv[1], &key))
         {ret = EXCP_BADARG(env, "non-binary key"); goto done;}
-    if (!enif_inspect_binary(env, argv[2], &iv))
+    if (!enif_inspect_iolist_as_binary(env, argv[2], &iv))
         {ret = EXCP_BADARG(env, "non-binary iv"); goto done;}
-    if (!enif_inspect_iolist_as_binary(env, argv[3], &aad))
-        {ret = EXCP_BADARG(env, "non-binary AAD"); goto done;}
-    if (!enif_inspect_iolist_as_binary(env, argv[4], &in))
+    if (!enif_inspect_iolist_as_binary(env, argv[3], &in))
         {ret = EXCP_BADARG(env, "non-binary text"); goto done;}
-    if (!enif_get_uint(env, argv[5], &tag_len))
-        {ret = EXCP_BADARG(env, ""); goto done;}
+    if (!enif_inspect_iolist_as_binary(env, argv[4], &aad))
+        {ret = EXCP_BADARG(env, "non-binary AAD"); goto done;}
+
+    if (encflg) {
+        if (!enif_get_uint(env, argv[5], &tag_len))
+            {ret = EXCP_BADARG(env, "Bad Tag length"); goto done;}
+        tag_data = NULL;
+    } else {
+        if (!enif_inspect_iolist_as_binary(env, argv[5], &tag))
+            {ret = EXCP_BADARG(env, "non-binary Tag"); goto done;}
+        tag_len = tag.size;
+        tag_data = tag.data;
+    }
 
     if (tag_len > INT_MAX
+        || key.size > INT_MAX
         || iv.size > INT_MAX
         || in.size > INT_MAX
         || aad.size > INT_MAX)
@@ -66,167 +95,88 @@ ERL_NIF_TERM aead_encrypt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
     if ((cipher = cipherp->cipher.p) == NULL)
         {ret = EXCP_NOTSUP(env, "Cipher not supported in this libcrypto version"); goto done;}
 
-    ctx_ctrl_set_ivlen = cipherp->extra.aead.ctx_ctrl_set_ivlen;
-    ctx_ctrl_get_tag =  cipherp->extra.aead.ctx_ctrl_get_tag;
-    ctx_ctrl_set_tag =  cipherp->extra.aead.ctx_ctrl_set_tag;
-    
+#if defined(HAVE_GCM_EVP_DECRYPT_BUG)
+    if ( !encflg && (cipherp->flags & GCM_MODE))
+        return aes_gcm_decrypt_NO_EVP(env, argc, argv);
+#endif
+
     if ((ctx = EVP_CIPHER_CTX_new()) == NULL)
-        {ret = EXCP_ERROR(env, ""); goto done;}
+        {ret = EXCP_ERROR(env, "Can't allocate ctx"); goto done;}
 
-    if (EVP_EncryptInit_ex(ctx, cipher, NULL, NULL, NULL) != 1)
-        {ret = EXCP_ERROR(env, ""); goto done;}
-    if (EVP_CIPHER_CTX_ctrl(ctx, ctx_ctrl_set_ivlen, (int)iv.size, NULL) != 1)
-        {ret = EXCP_ERROR(env, ""); goto done;}
+    if (EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, encflg) != 1)
+        {ret = EXCP_ERROR(env, "CipherInit failed"); goto done;}
+    if (EVP_CIPHER_CTX_ctrl(ctx, cipherp->extra.aead.ctx_ctrl_set_ivlen, (int)iv.size, NULL) != 1)
+        {ret = EXCP_BADARG(env, "Bad IV length"); goto done;}
 
 #if defined(HAVE_CCM)
-    if (type == atom_aes_ccm) {
-        if (EVP_CIPHER_CTX_ctrl(ctx, ctx_ctrl_set_tag, (int)tag_len, NULL) != 1)
-            {ret = EXCP_ERROR(env, ""); goto done;}
-        if (EVP_EncryptInit_ex(ctx, NULL, NULL, key.data, iv.data) != 1)
-            {ret = EXCP_ERROR(env, ""); goto done;}
-        if (EVP_EncryptUpdate(ctx, NULL, &len, NULL, (int)in.size) != 1)
-            {ret = EXCP_ERROR(env, ""); goto done;}
+    if (cipherp->flags & CCM_MODE) {
+        if (EVP_CIPHER_CTX_ctrl(ctx, cipherp->extra.aead.ctx_ctrl_set_tag, (int)tag_len, tag_data) != 1)
+            {ret = EXCP_BADARG(env, "Can't set tag"); goto done;}
+        if (EVP_CipherInit_ex(ctx, NULL, NULL, key.data, iv.data, -1) != 1)
+            {ret = EXCP_BADARG(env, "Can't set key or iv"); goto done;}
+        if (EVP_CipherUpdate(ctx, NULL, &len, NULL, (int)in.size) != 1)
+            {ret = EXCP_BADARG(env, "Can't set text size"); goto done;}
     } else
 #endif
         {
-            if (EVP_EncryptInit_ex(ctx, NULL, NULL, key.data, iv.data) != 1)
-                {ret = EXCP_ERROR(env, ""); goto done;}
+            if (EVP_CipherInit_ex(ctx, NULL, NULL, key.data, iv.data, -1) != 1)
+                {ret = EXCP_BADARG(env, "Can't set key or iv"); goto done;}
         }
 
-    if (EVP_EncryptUpdate(ctx, NULL, &len, aad.data, (int)aad.size) != 1)
-        {ret = EXCP_ERROR(env, ""); goto done;}
+    if (EVP_CipherUpdate(ctx, NULL, &len, aad.data, (int)aad.size) != 1)
+        {ret = EXCP_BADARG(env, "Can't set AAD"); goto done;}
 
     if ((outp = enif_make_new_binary(env, in.size, &out)) == NULL)
-        {ret = EXCP_ERROR(env, ""); goto done;}
-
-    if (EVP_EncryptUpdate(ctx, outp, &len, in.data, (int)in.size) != 1)
-        {ret = EXCP_ERROR(env, ""); goto done;}
-    if (EVP_EncryptFinal_ex(ctx, outp/*+len*/, &len) != 1)
-        {ret = EXCP_ERROR(env, ""); goto done;}
-
-    if ((tagp = enif_make_new_binary(env, tag_len, &out_tag)) == NULL)
-        {ret = EXCP_ERROR(env, ""); goto done;}
+        {ret = EXCP_ERROR(env, "Can't make 'Out' binary"); goto done;}
 
-    if (EVP_CIPHER_CTX_ctrl(ctx, ctx_ctrl_get_tag, (int)tag_len, tagp) != 1)
-        {ret = EXCP_ERROR(env, ""); goto done;}
-
-    CONSUME_REDS(env, in);
-    ret = enif_make_tuple2(env, out, out_tag);
-
- done:
-    if (ctx)
-        EVP_CIPHER_CTX_free(ctx);
-    return ret;
-
-#else
-    return EXCP_NOTSUP(env, "");
-#endif
-}
-
-ERL_NIF_TERM aead_decrypt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
-{/* (Type,Key,Iv,AAD,In,Tag) */
-#if defined(HAVE_AEAD)
-    const struct cipher_type_t *cipherp;
-    EVP_CIPHER_CTX *ctx = NULL;
-    const EVP_CIPHER *cipher = NULL;
-    ErlNifBinary key, iv, aad, in, tag;
-    unsigned char *outp;
-    ERL_NIF_TERM type, out, ret;
-    int len, ctx_ctrl_set_ivlen, ctx_ctrl_set_tag;
-
-    ASSERT(argc == 6);
-
-    type = argv[0];
-#if defined(HAVE_GCM_EVP_DECRYPT_BUG)
-    if (type == atom_aes_gcm)
-        return aes_gcm_decrypt_NO_EVP(env, argc, argv);
-#endif
-
-    if (!enif_is_atom(env, type))
-        {ret = EXCP_BADARG(env, "non-atom cipher type"); goto done;}
-    if (!enif_inspect_iolist_as_binary(env, argv[1], &key))
-        {ret = EXCP_BADARG(env, "non-binary key"); goto done;}
-    if (!enif_inspect_binary(env, argv[2], &iv))
-        {ret = EXCP_BADARG(env, "non-binary iv"); goto done;}
-    if (!enif_inspect_iolist_as_binary(env, argv[3], &aad))
-        {ret = EXCP_BADARG(env, "non-binary AAD"); goto done;}
-    if (!enif_inspect_iolist_as_binary(env, argv[4], &in))
-        {ret = EXCP_BADARG(env, ""); goto done;}
-    if (!enif_inspect_iolist_as_binary(env, argv[5], &tag))
-        {ret = EXCP_BADARG(env, "non-binary text"); goto done;}
-
-    if (tag.size > INT_MAX
-        || key.size > INT_MAX
-        || iv.size > INT_MAX
-        || in.size > INT_MAX
-        || aad.size > INT_MAX)
-        {ret = EXCP_BADARG(env, "binary too long"); goto done;}
-
-    if ((cipherp = get_cipher_type(type, key.size)) == NULL)
-        {ret = EXCP_BADARG(env, "Unknown cipher"); goto done;}
-    if (cipherp->flags & NON_EVP_CIPHER)
-        {ret = EXCP_BADARG(env, "Bad cipher"); goto done;}
-    if ( !(cipherp->flags & AEAD_CIPHER) )
-        {ret = EXCP_BADARG(env, "Not aead cipher"); goto done;}
-    if ((cipher = cipherp->cipher.p) == NULL)
-        {ret = EXCP_NOTSUP(env, "Cipher not supported in this libcrypto version"); goto done;}
+    if (EVP_CipherUpdate(ctx, outp, &len, in.data, (int)in.size) != 1)
+        {
+            if (encflg)
+                ret = EXCP_BADARG(env, "Can't set in-text");
+            else
+                /* Decrypt error */
+                ret = atom_error;
+            goto done;
+        }
 
-    ctx_ctrl_set_ivlen = cipherp->extra.aead.ctx_ctrl_set_ivlen;
-    ctx_ctrl_set_tag =  cipherp->extra.aead.ctx_ctrl_set_tag;
+    if (encflg)
+        {
+            if (EVP_CipherFinal_ex(ctx, outp/*+len*/, &len) != 1)
+                {ret = EXCP_ERROR(env, "Encrypt error"); goto done;}
 
-    if ((outp = enif_make_new_binary(env, in.size, &out)) == NULL)
-        {ret = EXCP_ERROR(env, ""); goto done;}
+            if ((tagp = enif_make_new_binary(env, tag_len, &out_tag)) == NULL)
+                {ret = EXCP_ERROR(env, "Can't make 'Out' binary"); goto done;}
 
-    if ((ctx = EVP_CIPHER_CTX_new()) == NULL)
-        {ret = EXCP_ERROR(env, ""); goto done;}
-    if (EVP_DecryptInit_ex(ctx, cipher, NULL, NULL, NULL) != 1)
-        {ret = EXCP_ERROR(env, ""); goto done;}
-    if (EVP_CIPHER_CTX_ctrl(ctx,  ctx_ctrl_set_ivlen, (int)iv.size, NULL) != 1)
-        {ret = EXCP_ERROR(env, ""); goto done;}
+            if (EVP_CIPHER_CTX_ctrl(ctx, cipherp->extra.aead.ctx_ctrl_get_tag, (int)tag_len, tagp) != 1)
+                {ret = EXCP_ERROR(env, "Can't get Tag"); goto done;}
 
-#if defined(HAVE_CCM)
-    if (type == atom_aes_ccm) {
-        if (EVP_CIPHER_CTX_ctrl(ctx, ctx_ctrl_set_tag, (int)tag.size, tag.data) != 1)
-            {ret = EXCP_ERROR(env, ""); goto done;}
-        if (EVP_DecryptInit_ex(ctx, NULL, NULL, key.data, iv.data) != 1)
-            {ret = EXCP_ERROR(env, ""); goto done;}
-        if (EVP_DecryptUpdate(ctx, NULL, &len, NULL, (int)in.size) != 1)
-            {ret = EXCP_ERROR(env, ""); goto done;}
-    }
+            ret = enif_make_tuple2(env, out, out_tag);
+        }
     else
-#endif
         {
-            if (EVP_DecryptInit_ex(ctx, NULL, NULL, key.data, iv.data) != 1)
-                {ret = EXCP_ERROR(env, ""); goto done;}
-        }
-
-    if (EVP_DecryptUpdate(ctx, NULL, &len, aad.data, (int)aad.size) != 1)
-        {ret = EXCP_ERROR(env, ""); goto done;}
-    if (EVP_DecryptUpdate(ctx, outp, &len, in.data, (int)in.size) != 1)
-        {ret = EXCP_ERROR(env, ""); goto done;}
-
 #if defined(HAVE_GCM)
-    if (type == atom_aes_gcm) {
-        if (EVP_CIPHER_CTX_ctrl(ctx, ctx_ctrl_set_tag, (int)tag.size, tag.data) != 1)
-            goto err;
-        if (EVP_DecryptFinal_ex(ctx, outp+len, &len) != 1)
-            goto err;
-    }
+            if (cipherp->flags & GCM_MODE) {
+                if (EVP_CIPHER_CTX_ctrl(ctx, cipherp->extra.aead.ctx_ctrl_set_tag, (int)tag_len, tag.data) != 1)
+                    /* Decrypt error */
+                    {ret = atom_error; goto done;}
+                if (EVP_DecryptFinal_ex(ctx, outp+len, &len) != 1)
+                    /* Decrypt error */
+                    {ret = atom_error; goto done;}
+            }
 #endif
-    CONSUME_REDS(env, in);
-    ret = out;
-    goto done;
+            ret = out;
+        }
 
- err:
-    /* Decrypt failed, that is, wrong tag */
-    ret = atom_error;
+    CONSUME_REDS(env, in);
 
- done:
+done:
     if (ctx)
         EVP_CIPHER_CTX_free(ctx);
     return ret;
 
 #else
-    return EXCP_NOTSUP(env, "");
+    return EXCP_NOTSUP(env, "Unsupported Cipher");
 #endif
 }
+
+
diff --git a/lib/crypto/c_src/aead.h b/lib/crypto/c_src/aead.h
index 54c0711535..2ec7a8a930 100644
--- a/lib/crypto/c_src/aead.h
+++ b/lib/crypto/c_src/aead.h
@@ -23,7 +23,6 @@
 
 #include "common.h"
 
-ERL_NIF_TERM aead_encrypt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
-ERL_NIF_TERM aead_decrypt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM aead_cipher(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 
 #endif /* E_AEAD_H__ */
diff --git a/lib/crypto/c_src/algorithms.c b/lib/crypto/c_src/algorithms.c
index 1d45ed9df2..20707c0531 100644
--- a/lib/crypto/c_src/algorithms.c
+++ b/lib/crypto/c_src/algorithms.c
@@ -80,8 +80,12 @@ void init_algorithms_types(ErlNifEnv* env)
 
     algo_pubkey_cnt = 0;
     algo_pubkey[algo_pubkey_cnt++] = enif_make_atom(env, "rsa");
+#ifdef HAVE_DSA
     algo_pubkey[algo_pubkey_cnt++] = enif_make_atom(env, "dss");
+#endif
+#ifdef HAVE_DH
     algo_pubkey[algo_pubkey_cnt++] = enif_make_atom(env, "dh");
+#endif
 #if defined(HAVE_EC)
 #if !defined(OPENSSL_NO_EC2M)
     algo_pubkey[algo_pubkey_cnt++] = enif_make_atom(env, "ec_gf2m");
diff --git a/lib/crypto/c_src/api_ng.c b/lib/crypto/c_src/api_ng.c
index 5d063c3ae4..3408ba1b88 100644
--- a/lib/crypto/c_src/api_ng.c
+++ b/lib/crypto/c_src/api_ng.c
@@ -27,7 +27,7 @@
  *
  */
 ERL_NIF_TERM ng_crypto_update(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
-ERL_NIF_TERM ng_crypto_one_shot(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM ng_crypto_one_time(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 
 #ifdef HAVE_ECB_IVEC_BUG
     /* <= 0.9.8l returns faulty ivec length */
@@ -93,6 +93,13 @@ static int get_init_args(ErlNifEnv* env,
             goto err;
         }
 
+    if ((*cipherp)->flags &  AEAD_CIPHER)
+        {
+            *return_term = EXCP_BADARG(env, "Missing arguments for this cipher");
+            goto err;
+        }
+
+
     if (FORBIDDEN_IN_FIPS(*cipherp))
         {
             *return_term = EXCP_NOTSUP(env, "Forbidden in FIPS");
@@ -413,13 +420,15 @@ int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in)
 ERL_NIF_TERM ng_crypto_update(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {/* (Context, Data [, IV]) */
     struct evp_cipher_ctx *ctx_res;
+    struct evp_cipher_ctx ctx_res_copy;
     ERL_NIF_TERM ret;
 
+    ctx_res_copy.ctx = NULL;
+
     if (!enif_get_resource(env, argv[0], (ErlNifResourceType*)evp_cipher_ctx_rtype, (void**)&ctx_res))
         return EXCP_BADARG(env, "Bad 1:st arg");
     
     if (argc == 3) {
-        struct evp_cipher_ctx ctx_res_copy;
         ErlNifBinary ivec_bin;
 
         memcpy(&ctx_res_copy, ctx_res, sizeof ctx_res_copy);
@@ -474,6 +483,9 @@ ERL_NIF_TERM ng_crypto_update(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[
         get_update_args(env, ctx_res, argv[1], &ret);
 
  err:
+    if (ctx_res_copy.ctx)
+        EVP_CIPHER_CTX_free(ctx_res_copy.ctx);
+
     return ret; /* Both success and error */
 }
 
@@ -504,12 +516,17 @@ ERL_NIF_TERM ng_crypto_update_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM a
 /* One shot                                                              */
 /*************************************************************************/
 
-ERL_NIF_TERM ng_crypto_one_shot(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+ERL_NIF_TERM ng_crypto_one_time(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {/* (Cipher, Key, IVec, Data, Encrypt) */
     struct evp_cipher_ctx ctx_res;
     const struct cipher_type_t *cipherp;
     ERL_NIF_TERM ret;
 
+    ctx_res.ctx = NULL;
+#if !defined(HAVE_EVP_AES_CTR)
+    ctx_res.env = NULL;
+#endif
+
     if (!get_init_args(env, &ctx_res, argv[0], argv[1], argv[2], argv[4], &cipherp, &ret))
         goto ret;
 
@@ -518,10 +535,17 @@ ERL_NIF_TERM ng_crypto_one_shot(ErlNifEnv* env, int argc, const ERL_NIF_TERM arg
  ret:
     if (ctx_res.ctx)
         EVP_CIPHER_CTX_free(ctx_res.ctx);
+
+#if !defined(HAVE_EVP_AES_CTR)
+    if (ctx_res.env)
+         enif_free_env(ctx_res.env);
+#endif
+
     return ret;
 }
 
-ERL_NIF_TERM ng_crypto_one_shot_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+
+ERL_NIF_TERM ng_crypto_one_time_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {/* (Cipher, Key, IVec, Data, Encrypt)  % if no IV for the Cipher, set IVec = <<>>
   */
     ErlNifBinary   data_bin;
@@ -536,10 +560,10 @@ ERL_NIF_TERM ng_crypto_one_shot_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM
 
     /* Run long jobs on a dirty scheduler to not block the current emulator thread */
     if (data_bin.size > MAX_BYTES_TO_NIF) {
-        return enif_schedule_nif(env, "ng_crypto_one_shot",
+        return enif_schedule_nif(env, "ng_crypto_one_time",
                                  ERL_NIF_DIRTY_JOB_CPU_BOUND,
-                                 ng_crypto_one_shot, argc, argv);
+                                 ng_crypto_one_time, argc, argv);
     }
 
-    return ng_crypto_one_shot(env, argc, argv);
+    return ng_crypto_one_time(env, argc, argv);
 }
diff --git a/lib/crypto/c_src/api_ng.h b/lib/crypto/c_src/api_ng.h
index 5c7d9af3c5..aaf67524ae 100644
--- a/lib/crypto/c_src/api_ng.h
+++ b/lib/crypto/c_src/api_ng.h
@@ -25,6 +25,6 @@
 
 ERL_NIF_TERM ng_crypto_init_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 ERL_NIF_TERM ng_crypto_update_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
-ERL_NIF_TERM ng_crypto_one_shot_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM ng_crypto_one_time_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 
 #endif /* E_AES_H__ */
diff --git a/lib/crypto/c_src/cipher.c b/lib/crypto/c_src/cipher.c
index 2652e1db4e..8f0c93c5db 100644
--- a/lib/crypto/c_src/cipher.c
+++ b/lib/crypto/c_src/cipher.c
@@ -20,10 +20,10 @@
 
 #include "cipher.h"
 
-#ifdef OPENSSL_NO_DES
-#define COND_NO_DES_PTR(Ptr) (NULL)
-#else
+#ifdef HAVE_DES
 #define COND_NO_DES_PTR(Ptr) (Ptr)
+#else
+#define COND_NO_DES_PTR(Ptr) (NULL)
 #endif
 
 static struct cipher_type_t cipher_types[] =
@@ -50,10 +50,17 @@ static struct cipher_type_t cipher_types[] =
     {{"des_ede3_cfb"}, {NULL}, 0, 0},
 #endif
 
+#ifdef HAVE_BF
     {{"blowfish_cbc"}, {&EVP_bf_cbc}, 0, NO_FIPS_CIPHER},
     {{"blowfish_cfb64"}, {&EVP_bf_cfb64}, 0, NO_FIPS_CIPHER},
     {{"blowfish_ofb64"}, {&EVP_bf_ofb}, 0, NO_FIPS_CIPHER},
     {{"blowfish_ecb"}, {&EVP_bf_ecb}, 0, NO_FIPS_CIPHER | ECB_BUG_0_9_8L},
+#else
+    {{"blowfish_cbc"}, {NULL}, 0, 0},
+    {{"blowfish_cfb64"}, {NULL}, 0, 0},
+    {{"blowfish_ofb64"}, {NULL}, 0, 0},
+    {{"blowfish_ecb"}, {NULL}, 0, 0},
+#endif
 
     {{"aes_cbc"}, {&EVP_aes_128_cbc}, 16, 0},
     {{"aes_cbc"}, {&EVP_aes_192_cbc}, 24, 0},
@@ -117,31 +124,31 @@ static struct cipher_type_t cipher_types[] =
 #endif
 
 #if defined(HAVE_GCM)
-    {{"aes_gcm"},     {&EVP_aes_128_gcm}, 16, AEAD_CIPHER, {{EVP_CTRL_GCM_SET_IVLEN,EVP_CTRL_GCM_GET_TAG,EVP_CTRL_GCM_SET_TAG}}},
-    {{"aes_gcm"},     {&EVP_aes_192_gcm}, 24, AEAD_CIPHER, {{EVP_CTRL_GCM_SET_IVLEN,EVP_CTRL_GCM_GET_TAG,EVP_CTRL_GCM_SET_TAG}}},
-    {{"aes_gcm"},     {&EVP_aes_256_gcm}, 32, AEAD_CIPHER, {{EVP_CTRL_GCM_SET_IVLEN,EVP_CTRL_GCM_GET_TAG,EVP_CTRL_GCM_SET_TAG}}},
-    {{"aes_128_gcm"}, {&EVP_aes_128_gcm}, 16, AEAD_CIPHER, {{EVP_CTRL_GCM_SET_IVLEN,EVP_CTRL_GCM_GET_TAG,EVP_CTRL_GCM_SET_TAG}}},
-    {{"aes_192_gcm"}, {&EVP_aes_192_gcm}, 24, AEAD_CIPHER, {{EVP_CTRL_GCM_SET_IVLEN,EVP_CTRL_GCM_GET_TAG,EVP_CTRL_GCM_SET_TAG}}},
-    {{"aes_256_gcm"}, {&EVP_aes_256_gcm}, 32, AEAD_CIPHER, {{EVP_CTRL_GCM_SET_IVLEN,EVP_CTRL_GCM_GET_TAG,EVP_CTRL_GCM_SET_TAG}}},
+    {{"aes_gcm"},     {&EVP_aes_128_gcm}, 16, AEAD_CIPHER|GCM_MODE, {{EVP_CTRL_GCM_SET_IVLEN,EVP_CTRL_GCM_GET_TAG,EVP_CTRL_GCM_SET_TAG}}},
+    {{"aes_gcm"},     {&EVP_aes_192_gcm}, 24, AEAD_CIPHER|GCM_MODE, {{EVP_CTRL_GCM_SET_IVLEN,EVP_CTRL_GCM_GET_TAG,EVP_CTRL_GCM_SET_TAG}}},
+    {{"aes_gcm"},     {&EVP_aes_256_gcm}, 32, AEAD_CIPHER|GCM_MODE, {{EVP_CTRL_GCM_SET_IVLEN,EVP_CTRL_GCM_GET_TAG,EVP_CTRL_GCM_SET_TAG}}},
+    {{"aes_128_gcm"}, {&EVP_aes_128_gcm}, 16, AEAD_CIPHER|GCM_MODE, {{EVP_CTRL_GCM_SET_IVLEN,EVP_CTRL_GCM_GET_TAG,EVP_CTRL_GCM_SET_TAG}}},
+    {{"aes_192_gcm"}, {&EVP_aes_192_gcm}, 24, AEAD_CIPHER|GCM_MODE, {{EVP_CTRL_GCM_SET_IVLEN,EVP_CTRL_GCM_GET_TAG,EVP_CTRL_GCM_SET_TAG}}},
+    {{"aes_256_gcm"}, {&EVP_aes_256_gcm}, 32, AEAD_CIPHER|GCM_MODE, {{EVP_CTRL_GCM_SET_IVLEN,EVP_CTRL_GCM_GET_TAG,EVP_CTRL_GCM_SET_TAG}}},
 #else
-    {{"aes_gcm"},     {NULL},  0, AEAD_CIPHER, {{0,0,0}}},
-    {{"aes_128_gcm"}, {NULL}, 16, AEAD_CIPHER, {{0,0,0}}},
-    {{"aes_192_gcm"}, {NULL}, 24, AEAD_CIPHER, {{0,0,0}}},
-    {{"aes_256_gcm"}, {NULL}, 32, AEAD_CIPHER, {{0,0,0}}},
+    {{"aes_gcm"},     {NULL},  0, AEAD_CIPHER|GCM_MODE, {{0,0,0}}},
+    {{"aes_128_gcm"}, {NULL}, 16, AEAD_CIPHER|GCM_MODE, {{0,0,0}}},
+    {{"aes_192_gcm"}, {NULL}, 24, AEAD_CIPHER|GCM_MODE, {{0,0,0}}},
+    {{"aes_256_gcm"}, {NULL}, 32, AEAD_CIPHER|GCM_MODE, {{0,0,0}}},
 #endif
 
 #if defined(HAVE_CCM)
-    {{"aes_ccm"},     {&EVP_aes_128_ccm}, 16, AEAD_CIPHER, {{EVP_CTRL_CCM_SET_IVLEN,EVP_CTRL_CCM_GET_TAG,EVP_CTRL_CCM_SET_TAG}}},
-    {{"aes_ccm"},     {&EVP_aes_192_ccm}, 24, AEAD_CIPHER, {{EVP_CTRL_CCM_SET_IVLEN,EVP_CTRL_CCM_GET_TAG,EVP_CTRL_CCM_SET_TAG}}},
-    {{"aes_ccm"},     {&EVP_aes_256_ccm}, 32, AEAD_CIPHER, {{EVP_CTRL_CCM_SET_IVLEN,EVP_CTRL_CCM_GET_TAG,EVP_CTRL_CCM_SET_TAG}}},
-    {{"aes_128_ccm"}, {&EVP_aes_128_ccm}, 16, AEAD_CIPHER, {{EVP_CTRL_CCM_SET_IVLEN,EVP_CTRL_CCM_GET_TAG,EVP_CTRL_CCM_SET_TAG}}},
-    {{"aes_192_ccm"}, {&EVP_aes_192_ccm}, 24, AEAD_CIPHER, {{EVP_CTRL_CCM_SET_IVLEN,EVP_CTRL_CCM_GET_TAG,EVP_CTRL_CCM_SET_TAG}}},
-    {{"aes_256_ccm"}, {&EVP_aes_256_ccm}, 32, AEAD_CIPHER, {{EVP_CTRL_CCM_SET_IVLEN,EVP_CTRL_CCM_GET_TAG,EVP_CTRL_CCM_SET_TAG}}},
+    {{"aes_ccm"},     {&EVP_aes_128_ccm}, 16, AEAD_CIPHER|CCM_MODE, {{EVP_CTRL_CCM_SET_IVLEN,EVP_CTRL_CCM_GET_TAG,EVP_CTRL_CCM_SET_TAG}}},
+    {{"aes_ccm"},     {&EVP_aes_192_ccm}, 24, AEAD_CIPHER|CCM_MODE, {{EVP_CTRL_CCM_SET_IVLEN,EVP_CTRL_CCM_GET_TAG,EVP_CTRL_CCM_SET_TAG}}},
+    {{"aes_ccm"},     {&EVP_aes_256_ccm}, 32, AEAD_CIPHER|CCM_MODE, {{EVP_CTRL_CCM_SET_IVLEN,EVP_CTRL_CCM_GET_TAG,EVP_CTRL_CCM_SET_TAG}}},
+    {{"aes_128_ccm"}, {&EVP_aes_128_ccm}, 16, AEAD_CIPHER|CCM_MODE, {{EVP_CTRL_CCM_SET_IVLEN,EVP_CTRL_CCM_GET_TAG,EVP_CTRL_CCM_SET_TAG}}},
+    {{"aes_192_ccm"}, {&EVP_aes_192_ccm}, 24, AEAD_CIPHER|CCM_MODE, {{EVP_CTRL_CCM_SET_IVLEN,EVP_CTRL_CCM_GET_TAG,EVP_CTRL_CCM_SET_TAG}}},
+    {{"aes_256_ccm"}, {&EVP_aes_256_ccm}, 32, AEAD_CIPHER|CCM_MODE, {{EVP_CTRL_CCM_SET_IVLEN,EVP_CTRL_CCM_GET_TAG,EVP_CTRL_CCM_SET_TAG}}},
 #else
-    {{"aes_ccm"},     {NULL},  0, AEAD_CIPHER, {{0,0,0}}},
-    {{"aes_128_ccm"}, {NULL}, 16, AEAD_CIPHER, {{0,0,0}}},
-    {{"aes_192_ccm"}, {NULL}, 24, AEAD_CIPHER, {{0,0,0}}},
-    {{"aes_256_ccm"}, {NULL}, 32, AEAD_CIPHER, {{0,0,0}}},
+    {{"aes_ccm"},     {NULL},  0, AEAD_CIPHER|CCM_MODE, {{0,0,0}}},
+    {{"aes_128_ccm"}, {NULL}, 16, AEAD_CIPHER|CCM_MODE, {{0,0,0}}},
+    {{"aes_192_ccm"}, {NULL}, 24, AEAD_CIPHER|CCM_MODE, {{0,0,0}}},
+    {{"aes_256_ccm"}, {NULL}, 32, AEAD_CIPHER|CCM_MODE, {{0,0,0}}},
 #endif
 
     /*==== Specialy handled ciphers, only for inclusion in algorithm's list ====*/
diff --git a/lib/crypto/c_src/cipher.h b/lib/crypto/c_src/cipher.h
index b94873940f..0e51c410eb 100644
--- a/lib/crypto/c_src/cipher.h
+++ b/lib/crypto/c_src/cipher.h
@@ -46,6 +46,8 @@ struct cipher_type_t {
 #define AEAD_CIPHER 8
 #define NON_EVP_CIPHER 16
 #define AES_CTR_COMPAT 32
+#define CCM_MODE 64
+#define GCM_MODE 128
 
 
 #ifdef FIPS_SUPPORT
diff --git a/lib/crypto/c_src/common.h b/lib/crypto/c_src/common.h
index 0bf7f09f4f..a7e59d5d01 100644
--- a/lib/crypto/c_src/common.h
+++ b/lib/crypto/c_src/common.h
@@ -38,8 +38,11 @@
 
 /* All nif functions return a valid value or throws an exception */
 #define EXCP(Env, Id, Str)  enif_raise_exception((Env), \
-                                enif_make_tuple2((Env), \
+                                enif_make_tuple3((Env), \
                                                  (Id),  \
+                                                 enif_make_tuple2((Env), \
+                                                                  enif_make_string((Env),__FILE__,(ERL_NIF_LATIN1)), \
+                                                                  enif_make_int((Env), __LINE__)), \
                                                  enif_make_string((Env),(Str),(ERL_NIF_LATIN1)) ))
 
 #define EXCP_NOTSUP(Env, Str) EXCP((Env), atom_notsup, (Str))
diff --git a/lib/crypto/c_src/crypto.c b/lib/crypto/c_src/crypto.c
index 4aed06a489..a8014745c8 100644
--- a/lib/crypto/c_src/crypto.c
+++ b/lib/crypto/c_src/crypto.c
@@ -81,7 +81,7 @@ static ErlNifFunc nif_funcs[] = {
     {"ng_crypto_init_nif", 4, ng_crypto_init_nif, 0},
     {"ng_crypto_update_nif", 2, ng_crypto_update_nif, 0},
     {"ng_crypto_update_nif", 3, ng_crypto_update_nif, 0},
-    {"ng_crypto_one_shot_nif", 5, ng_crypto_one_shot_nif, 0},
+    {"ng_crypto_one_time_nif", 5, ng_crypto_one_time_nif, 0},
     {"strong_rand_bytes_nif", 1, strong_rand_bytes_nif, 0},
     {"strong_rand_range_nif", 1, strong_rand_range_nif, 0},
     {"rand_uniform_nif", 2, rand_uniform_nif, 0},
@@ -105,8 +105,7 @@ static ErlNifFunc nif_funcs[] = {
 
     {"rand_seed_nif", 1, rand_seed_nif, 0},
 
-    {"aead_encrypt", 6, aead_encrypt, 0},
-    {"aead_decrypt", 6, aead_decrypt, 0},
+    {"aead_cipher", 7, aead_cipher, 0},
 
     {"poly1305_nif", 2, poly1305_nif, 0},
 
diff --git a/lib/crypto/c_src/dh.c b/lib/crypto/c_src/dh.c
index 38eb534d99..13a2336f25 100644
--- a/lib/crypto/c_src/dh.c
+++ b/lib/crypto/c_src/dh.c
@@ -23,6 +23,7 @@
 
 ERL_NIF_TERM dh_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {/* (PrivKey|undefined, DHParams=[P,G], Mpint, Len|0) */
+#ifdef HAVE_DH
     DH *dh_params = NULL;
     unsigned int mpint; /* 0 or 4 */
     ERL_NIF_TERM head, tail;
@@ -187,10 +188,14 @@ ERL_NIF_TERM dh_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM ar
 #endif
 
     return ret;
+#else
+    return enif_raise_exception(env, atom_notsup);
+#endif
 }
 
 ERL_NIF_TERM dh_compute_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {/* (OthersPublicKey, MyPrivateKey, DHParams=[P,G]) */
+#ifdef HAVE_DH
     BIGNUM *other_pub_key = NULL;
     BIGNUM *dh_p = NULL;
     BIGNUM *dh_g = NULL;
@@ -291,4 +296,7 @@ ERL_NIF_TERM dh_compute_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM arg
         DH_free(dh_priv);
 
     return ret;
+#else
+    return enif_raise_exception(env, atom_notsup);
+#endif
 }
diff --git a/lib/crypto/c_src/dss.c b/lib/crypto/c_src/dss.c
index 9bf8eb3ce0..63268f0f2b 100644
--- a/lib/crypto/c_src/dss.c
+++ b/lib/crypto/c_src/dss.c
@@ -21,6 +21,8 @@
 #include "dss.h"
 #include "bn.h"
 
+#ifdef HAVE_DSA
+
 int get_dss_private_key(ErlNifEnv* env, ERL_NIF_TERM key, DSA *dsa)
 {
     /* key=[P,Q,G,KEY] */
@@ -142,3 +144,5 @@ int get_dss_public_key(ErlNifEnv* env, ERL_NIF_TERM key, DSA *dsa)
         BN_free(dsa_y);
     return 0;
 }
+
+#endif
diff --git a/lib/crypto/c_src/dss.h b/lib/crypto/c_src/dss.h
index 3275657e98..07e28ca7c5 100644
--- a/lib/crypto/c_src/dss.h
+++ b/lib/crypto/c_src/dss.h
@@ -23,7 +23,9 @@
 
 #include "common.h"
 
+#ifdef HAVE_DSA
 int get_dss_private_key(ErlNifEnv* env, ERL_NIF_TERM key, DSA *dsa);
 int get_dss_public_key(ErlNifEnv* env, ERL_NIF_TERM key, DSA *dsa);
+#endif
 
 #endif /* E_DSS_H__ */
diff --git a/lib/crypto/c_src/openssl_config.h b/lib/crypto/c_src/openssl_config.h
index f926f8af13..339eb5b8f4 100644
--- a/lib/crypto/c_src/openssl_config.h
+++ b/lib/crypto/c_src/openssl_config.h
@@ -25,9 +25,8 @@
 #include <openssl/opensslconf.h>
 
 #include <openssl/crypto.h>
-#ifndef OPENSSL_NO_DES
 #include <openssl/des.h>
-#endif /* #ifndef OPENSSL_NO_DES */
+
 /* #include <openssl/idea.h> This is not supported on the openssl OTP requires */
 #include <openssl/dsa.h>
 #include <openssl/rsa.h>
@@ -166,6 +165,22 @@
 # define HAVE_BLAKE2
 #endif
 
+#ifndef OPENSSL_NO_BF
+# define HAVE_BF
+#endif
+
+#ifndef OPENSSL_NO_DES
+# define HAVE_DES
+#endif
+
+#ifndef OPENSSL_NO_DH
+# define HAVE_DH
+#endif
+
+#ifndef OPENSSL_NO_DSA
+# define HAVE_DSA
+#endif
+
 #ifndef OPENSSL_NO_MD4
 # define HAVE_MD4
 #endif
diff --git a/lib/crypto/c_src/otp_test_engine.c b/lib/crypto/c_src/otp_test_engine.c
index fd26b7cb5d..c3bd9dfb55 100644
--- a/lib/crypto/c_src/otp_test_engine.c
+++ b/lib/crypto/c_src/otp_test_engine.c
@@ -160,7 +160,7 @@ static int test_engine_md5_update(EVP_MD_CTX *ctx,const void *data, size_t count
 
 static int test_engine_md5_final(EVP_MD_CTX *ctx,unsigned char *md) {
 #ifdef OLD
-    fprintf(stderr, "MD5 final size of EVP_MD: %lu\r\n", sizeof(EVP_MD));
+    fprintf(stderr, "MD5 final size of EVP_MD: %lu\r\n", (unsigned long)sizeof(EVP_MD));
     if (!MD5_Final(md, data(ctx)))
         goto err;
 
@@ -404,7 +404,7 @@ int test_rsa_sign(int dtype,
     } */
 
     if ((sizeof(fake_flag) == m_len)
-        && bcmp(m,fake_flag,m_len) == 0) {
+        && memcmp(m,fake_flag,m_len) == 0) {
         int slen;
 
         printf("To be faked\r\n");
@@ -432,7 +432,7 @@ int test_rsa_verify(int dtype,
     printf("test_rsa_verify (dtype=%i) called m_len=%u siglen=%u\r\n", dtype, m_len, siglen);
 
     if ((sizeof(fake_flag) == m_len)
-        && bcmp(m,fake_flag,m_len) == 0) {
+        && memcmp(m,fake_flag,m_len) == 0) {
         int size;
 
         if ((size = RSA_size(rsa)) < 0)
diff --git a/lib/crypto/c_src/pkey.c b/lib/crypto/c_src/pkey.c
index 638bb588fa..a1e2677b34 100644
--- a/lib/crypto/c_src/pkey.c
+++ b/lib/crypto/c_src/pkey.c
@@ -254,7 +254,9 @@ static int get_pkey_private_key(ErlNifEnv *env, ERL_NIF_TERM algorithm, ERL_NIF_
 {
     EVP_PKEY *result = NULL;
     RSA *rsa = NULL;
+#ifdef HAVE_DSA
     DSA *dsa = NULL;
+#endif
 #if defined(HAVE_EC)
     EC_KEY *ec = NULL;
 #endif
@@ -327,6 +329,7 @@ static int get_pkey_private_key(ErlNifEnv *env, ERL_NIF_TERM algorithm, ERL_NIF_
             return PKEY_NOTSUP;
 #endif
     } else if (algorithm == atom_dss) {
+#ifdef HAVE_DSA
         if ((dsa = DSA_new()) == NULL)
             goto err;
         if (!get_dss_private_key(env, key, dsa))
@@ -340,9 +343,9 @@ static int get_pkey_private_key(ErlNifEnv *env, ERL_NIF_TERM algorithm, ERL_NIF_
         dsa = NULL;
 
     } else {
+#endif
 	return PKEY_BADARG;
     }
-
     goto done;
 
  err:
@@ -357,8 +360,10 @@ static int get_pkey_private_key(ErlNifEnv *env, ERL_NIF_TERM algorithm, ERL_NIF_
         enif_free(id);
     if (rsa)
         RSA_free(rsa);
+#ifdef HAVE_DSA
     if (dsa)
         DSA_free(dsa);
+#endif
 #ifdef HAVE_EC
     if (ec)
         EC_KEY_free(ec);
@@ -377,7 +382,9 @@ static int get_pkey_public_key(ErlNifEnv *env, ERL_NIF_TERM algorithm, ERL_NIF_T
 {
     EVP_PKEY *result = NULL;
     RSA *rsa = NULL;
+#ifdef HAVE_DSA
     DSA *dsa = NULL;
+#endif
 #if defined(HAVE_EC)
     EC_KEY *ec = NULL;
 #endif
@@ -449,6 +456,7 @@ static int get_pkey_public_key(ErlNifEnv *env, ERL_NIF_TERM algorithm, ERL_NIF_T
 	return PKEY_NOTSUP;
 #endif
     } else if (algorithm == atom_dss) {
+#ifdef HAVE_DSA
         if ((dsa = DSA_new()) == NULL)
             goto err;
 
@@ -461,7 +469,9 @@ static int get_pkey_public_key(ErlNifEnv *env, ERL_NIF_TERM algorithm, ERL_NIF_T
             goto err;
         /* On success, result owns dsa */
         dsa = NULL;
-
+#else
+        return PKEY_NOTSUP;
+#endif
     } else {
 	return PKEY_BADARG;
     }
@@ -480,8 +490,10 @@ static int get_pkey_public_key(ErlNifEnv *env, ERL_NIF_TERM algorithm, ERL_NIF_T
         enif_free(id);
     if (rsa)
         RSA_free(rsa);
+#ifdef HAVE_DSA
     if (dsa)
         DSA_free(dsa);
+#endif
 #ifdef HAVE_EC
     if (ec)
         EC_KEY_free(ec);
@@ -518,7 +530,9 @@ ERL_NIF_TERM pkey_sign_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
     unsigned char *tbs; /* data to be signed */
     size_t tbslen;
     RSA *rsa = NULL;
+#ifdef HAVE_DSA
     DSA *dsa = NULL;
+#endif
 #if defined(HAVE_EC)
     EC_KEY *ec = NULL;
 #endif
@@ -706,8 +720,10 @@ enif_get_atom(env,argv[1],buf,1024,ERL_NIF_LATIN1); printf("hash=%s ",buf);
         enif_release_binary(&sig_bin);
     if (rsa)
         RSA_free(rsa);
+#ifdef HAVE_DSA
     if (dsa)
         DSA_free(dsa);
+#endif
 #ifdef HAVE_EC
     if (ec)
         EC_KEY_free(ec);
@@ -744,7 +760,9 @@ ERL_NIF_TERM pkey_verify_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]
     size_t tbslen;
     ERL_NIF_TERM ret;
     RSA *rsa = NULL;
+#ifdef HAVE_DSA
     DSA *dsa = NULL;
+#endif
 #ifdef HAVE_EC
     EC_KEY *ec = NULL;
 #endif
@@ -890,8 +908,10 @@ ERL_NIF_TERM pkey_verify_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]
         EVP_PKEY_free(pkey);
     if (rsa)
         RSA_free(rsa);
+#ifdef HAVE_DSA
     if (dsa)
         DSA_free(dsa);
+#endif
 #ifdef HAVE_EC
     if (ec)
         EC_KEY_free(ec);
@@ -1358,7 +1378,9 @@ ERL_NIF_TERM privkey_to_pubkey_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM
     ERL_NIF_TERM ret;
     EVP_PKEY *pkey = NULL;
     RSA *rsa = NULL;
+#ifdef HAVE_DSA
     DSA *dsa = NULL;
+#endif
     ERL_NIF_TERM result[8];
 
     ASSERT(argc == 2);
@@ -1383,6 +1405,7 @@ ERL_NIF_TERM privkey_to_pubkey_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM
 
         ret = enif_make_list_from_array(env, result, 2);
 
+#ifdef HAVE_DSA
     } else if (argv[0] == atom_dss) {
         const BIGNUM *p = NULL, *q = NULL, *g = NULL, *pub_key = NULL;
 
@@ -1402,7 +1425,7 @@ ERL_NIF_TERM privkey_to_pubkey_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM
             goto err;
 
         ret = enif_make_list_from_array(env, result, 4);
-
+#endif
     } else if (argv[0] == atom_ecdsa) {
 #if defined(HAVE_EC)
         /* not yet implemented
@@ -1452,8 +1475,10 @@ ERL_NIF_TERM privkey_to_pubkey_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM
  done:
     if (rsa)
         RSA_free(rsa);
+#ifdef HAVE_DSA
     if (dsa)
         DSA_free(dsa);
+#endif
     if (pkey)
         EVP_PKEY_free(pkey);