diff --git a/Makefile.am b/Makefile.am
index e9a1c365..872c0b02 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -166,6 +166,7 @@ unittest_sources = \
 	tests/unittests/test_cmd_disconnect.c tests/unittests/test_cmd_disconnect.h \
 	tests/unittests/test_callbacks.c tests/unittests/test_callbacks.h \
 	tests/unittests/test_plugins_disco.c tests/unittests/test_plugins_disco.h \
+	tests/unittests/test_forced_encryption.c tests/unittests/test_forced_encryption.h \
 	tests/unittests/unittests.c
 
 functionaltest_sources = \
diff --git a/src/command/cmd_ac.c b/src/command/cmd_ac.c
index 62faf705..0caba5ba 100644
--- a/src/command/cmd_ac.c
+++ b/src/command/cmd_ac.c
@@ -136,6 +136,7 @@ static char* _mood_autocomplete(ProfWin* window, const char* const input, gboole
 static char* _strophe_autocomplete(ProfWin* window, const char* const input, gboolean previous);
 static char* _adhoc_cmd_autocomplete(ProfWin* window, const char* const input, gboolean previous);
 static char* _vcard_autocomplete(ProfWin* window, const char* const input, gboolean previous);
+static char* _force_encryption_autocomplete(ProfWin* window, const char* const input, gboolean previous);
 
 static char* _script_autocomplete_func(const char* const prefix, gboolean previous, void* context);
 
@@ -296,6 +297,8 @@ static Autocomplete vcard_name_ac;
 static Autocomplete vcard_set_param_ac;
 static Autocomplete vcard_togglable_param_ac;
 static Autocomplete vcard_address_type_ac;
+static Autocomplete force_encryption_ac;
+static Autocomplete force_encryption_policy_ac;
 
 static Autocomplete* all_acs[] = {
     &commands_ac,
@@ -448,6 +451,8 @@ static Autocomplete* all_acs[] = {
     &vcard_set_param_ac,
     &vcard_togglable_param_ac,
     &vcard_address_type_ac,
+    &force_encryption_ac,
+    &force_encryption_policy_ac
 };
 
 static GHashTable* ac_funcs = NULL;
@@ -1343,6 +1348,13 @@ cmd_ac_init(void)
     autocomplete_add(vcard_address_type_ac, "domestic");
     autocomplete_add(vcard_address_type_ac, "international");
 
+    autocomplete_add(force_encryption_ac, "on");
+    autocomplete_add(force_encryption_ac, "off");
+    autocomplete_add(force_encryption_ac, "policy");
+
+    autocomplete_add(force_encryption_policy_ac, "block");
+    autocomplete_add(force_encryption_policy_ac, "resend-to-confirm");
+
     if (ac_funcs != NULL)
         g_hash_table_destroy(ac_funcs);
     ac_funcs = g_hash_table_new(g_str_hash, g_str_equal);
@@ -1415,6 +1427,7 @@ cmd_ac_init(void)
     g_hash_table_insert(ac_funcs, "/win", _win_autocomplete);
     g_hash_table_insert(ac_funcs, "/wins", _wins_autocomplete);
     g_hash_table_insert(ac_funcs, "/wintitle", _wintitle_autocomplete);
+    g_hash_table_insert(ac_funcs, "/force-encryption", _force_encryption_autocomplete);
 }
 
 void
@@ -4406,3 +4419,17 @@ _vcard_autocomplete(ProfWin* window, const char* const input, gboolean previous)
 
     return result;
 }
+
+static char*
+_force_encryption_autocomplete(ProfWin* window, const char* const input, gboolean previous)
+{
+    char* result = NULL;
+
+    result = autocomplete_param_with_ac(input, "/force-encryption policy", force_encryption_policy_ac, TRUE, previous);
+    if (result) {
+        return result;
+    }
+
+    result = autocomplete_param_with_ac(input, "/force-encryption", force_encryption_ac, TRUE, previous);
+    return result;
+}
\ No newline at end of file
diff --git a/src/command/cmd_defs.c b/src/command/cmd_defs.c
index e5fb3cf0..00879725 100644
--- a/src/command/cmd_defs.c
+++ b/src/command/cmd_defs.c
@@ -2729,6 +2729,7 @@ static const struct cmd_t command_defs[] = {
               { "os on|off", "Choose whether to include the OS name if a user asks for software information (XEP-0092)." }
               )
       CMD_EXAMPLES(
+              "/privacy",
               "/privacy logging off",
               "/privacy os off")
     },
@@ -2744,6 +2745,31 @@ static const struct cmd_t command_defs[] = {
               "Redraw user interface. Can be used when some other program interrupted profanity or wrote to the same terminal and the interface looks \"broken\"." )
     },
 
+    { CMD_PREAMBLE("/force-encryption",
+                   parse_args, 1, 3, &cons_encryption_setting)
+      CMD_MAINFUNC(cmd_force_encryption)
+      CMD_TAGS(
+              CMD_TAG_CHAT)
+      CMD_SYN(
+              "/force-encryption",
+              "/force-encryption on|off",
+              "/force-encryption policy resend-to-confirm|block")
+      CMD_DESC(
+              "Configure forced encryption for outgoing messages in CProof. "
+              "When enabled, restricts sending unencrypted messages based on the specified policy. "
+              "Run without arguments to display current settings.")
+      CMD_ARGS(
+              { "on|off", "Enable or disable forced encryption. When enabled, restricts unencrypted messages per the policy. When disabled, allows sending unencrypted messages without restrictions." },
+              { "policy resend-to-confirm|block", "Set the policy for unencrypted messages when forced encryption is enabled. 'resend-to-confirm' requires pressing Enter again to confirm sending an unencrypted message (default). 'block' prevents sending unencrypted messages entirely." }
+              )
+      CMD_EXAMPLES(
+              "/force-encryption",
+              "/force-encryption on",
+              "/force-encryption off",
+              "/force-encryption policy resend-to-confirm",
+              "/force-encryption policy block")
+    },
+
     // NEXT-COMMAND (search helper)
 };
 
diff --git a/src/command/cmd_funcs.c b/src/command/cmd_funcs.c
index d444f3c8..e1ac8d37 100644
--- a/src/command/cmd_funcs.c
+++ b/src/command/cmd_funcs.c
@@ -10633,3 +10633,22 @@ cmd_vcard_save(ProfWin* window, const char* const command, gchar** args)
     cons_show("User vCard uploaded");
     return TRUE;
 }
+
+gboolean
+cmd_force_encryption(ProfWin* window, const char* const command, gchar** args)
+{
+    if (g_strv_length(args) == 1 && (g_strcmp0(args[0], "on") == 0 || g_strcmp0(args[0], "off") == 0)) {
+        _cmd_set_boolean_preference(args[0], "Forces encryption", PREF_FORCE_ENCRYPTION);
+    } else if (g_strv_length(args) == 2 && g_strcmp0(args[0], "policy") == 0) {
+        if (g_strcmp0(args[1], "resend-to-confirm") != 0 && g_strcmp0(args[1], "block") != 0) {
+            cons_show_error("Invalid policy: \"%s\". See '/help force-encryption' for details.", args[1]);
+            return TRUE;
+        }
+        prefs_set_string(PREF_FORCE_ENCRYPTION_MODE, args[1]);
+        cons_show("Force encryption policy has been set to \"%s\".", args[1]);
+    } else {
+        cons_bad_cmd_usage(command);
+    }
+
+    return TRUE;
+}
\ No newline at end of file
diff --git a/src/command/cmd_funcs.h b/src/command/cmd_funcs.h
index 5da0a6c7..b8b74e3c 100644
--- a/src/command/cmd_funcs.h
+++ b/src/command/cmd_funcs.h
@@ -269,5 +269,6 @@ gboolean cmd_vcard_photo(ProfWin* window, const char* const command, gchar** arg
 gboolean cmd_vcard_refresh(ProfWin* window, const char* const command, gchar** args);
 gboolean cmd_vcard_set(ProfWin* window, const char* const command, gchar** args);
 gboolean cmd_vcard_save(ProfWin* window, const char* const command, gchar** args);
+gboolean cmd_force_encryption(ProfWin* window, const char* const command, gchar** args);
 
 #endif
diff --git a/src/config/preferences.c b/src/config/preferences.c
index d306066b..bad809c8 100644
--- a/src/config/preferences.c
+++ b/src/config/preferences.c
@@ -1792,6 +1792,8 @@ _get_group(preference_t pref)
     case PREF_OUTGOING_STAMP:
     case PREF_INCOMING_STAMP:
     case PREF_MOOD:
+    case PREF_FORCE_ENCRYPTION:
+    case PREF_FORCE_ENCRYPTION_MODE:
         return PREF_GROUP_UI;
     case PREF_STATES:
     case PREF_OUTTYPE:
@@ -2150,6 +2152,10 @@ _get_key(preference_t pref)
         return "strophe.sm.enabled";
     case PREF_STROPHE_SM_RESEND:
         return "strophe.sm.resend";
+    case PREF_FORCE_ENCRYPTION:
+        return "force-encryption.enabled";
+    case PREF_FORCE_ENCRYPTION_MODE:
+        return "force-encryption.policy";
     default:
         return NULL;
     }
@@ -2204,6 +2210,7 @@ _get_default_boolean(preference_t pref)
     case PREF_STROPHE_SM_RESEND:
         return TRUE;
     case PREF_PGP_PUBKEY_AUTOIMPORT:
+    case PREF_FORCE_ENCRYPTION:
     default:
         return FALSE;
     }
@@ -2310,6 +2317,8 @@ _get_default_string(preference_t pref)
         return "0";
     case PREF_DBLOG:
         return "on";
+    case PREF_FORCE_ENCRYPTION_MODE:
+        return "resend-to-confirm";
     default:
         return NULL;
     }
diff --git a/src/config/preferences.h b/src/config/preferences.h
index e5904149..750a87ee 100644
--- a/src/config/preferences.h
+++ b/src/config/preferences.h
@@ -187,6 +187,8 @@ typedef enum {
     PREF_STROPHE_SM_RESEND,
     PREF_VCARD_PHOTO_CMD,
     PREF_STATUSBAR_TABMODE,
+    PREF_FORCE_ENCRYPTION,
+    PREF_FORCE_ENCRYPTION_MODE
 } preference_t;
 
 typedef struct prof_alias_t
diff --git a/src/event/client_events.c b/src/event/client_events.c
index 3250160b..7b68bdc1 100644
--- a/src/event/client_events.c
+++ b/src/event/client_events.c
@@ -42,9 +42,11 @@
 #include "log.h"
 #include "chatlog.h"
 #include "database.h"
+#include "client_events.h"
 #include "config/preferences.h"
 #include "event/common.h"
 #include "plugins/plugins.h"
+#include "ui/inputwin.h"
 #include "ui/window_list.h"
 #include "xmpp/chat_session.h"
 #include "xmpp/session.h"
@@ -177,7 +179,7 @@ cl_ev_send_msg_correct(ProfChatWin* chatwin, const char* const msg, const char*
 #ifdef HAVE_LIBOTR
         handled = otr_on_message_send(chatwin, message, request_receipt, replace_id);
 #endif
-        if (!handled) {
+        if (!handled && allow_unencrypted_message(chatwin, message)) {
             auto_char char* id = message_send_chat(chatwin->barejid, message, oob_url, request_receipt, replace_id);
             chat_log_msg_out(chatwin->barejid, message, NULL);
             log_database_add_outgoing_chat(id, chatwin->barejid, message, replace_id, PROF_MSG_ENC_NONE);
@@ -251,3 +253,34 @@ cl_ev_send_priv_msg(ProfPrivateWin* privwin, const char* const msg, const char*
         plugins_post_priv_message_send(privwin->fulljid, message);
     }
 }
+
+gboolean
+allow_unencrypted_message(ProfChatWin* chatwin, const char* const msg)
+{
+    if (!prefs_get_boolean(PREF_FORCE_ENCRYPTION)) {
+        return TRUE; // Encryption not enforced
+    }
+
+    auto_gchar gchar* force_enc_mode = prefs_get_string(PREF_FORCE_ENCRYPTION_MODE);
+
+    if (g_strcmp0(force_enc_mode, "block") == 0) {
+        win_println((ProfWin*)chatwin, THEME_ERROR, "-", "Message not sent: encryption required. Enable (omemo/pgp/otr) encryption or /force-encryption off.");
+        return FALSE;
+    }
+
+    if (g_strcmp0(force_enc_mode, "resend-to-confirm") == 0) {
+        // We do not use chatwin->last_message because it should be set only if it's sent.
+        guint msg_hash = g_str_hash(msg);
+        if (msg_hash == chatwin->last_attempted_msg_hash) {
+            chatwin->last_attempted_msg_hash = 0; // reset hash
+            return TRUE;
+        }
+        win_println((ProfWin*)chatwin, THEME_ERROR, "-", "Message not sent: encryption required. Enable (omemo/pgp/otr) encryption or press Enter again to send without encryption. Use /force-encryption off to disable this protection.");
+        chatwin->last_attempted_msg_hash = msg_hash;
+        inp_set_line(msg); // reset message to prevent the need to retype it
+        return FALSE;
+    }
+
+    win_println((ProfWin*)chatwin, THEME_ERROR, "-", "Message not sent: invalid encryption mode (%s). Use '/force-encryption policy resend-to-confirm'.", force_enc_mode);
+    return FALSE;
+}
diff --git a/src/event/client_events.h b/src/event/client_events.h
index a35e97b5..e5f638f9 100644
--- a/src/event/client_events.h
+++ b/src/event/client_events.h
@@ -52,4 +52,8 @@ void cl_ev_send_muc_msg_corrected(ProfMucWin* mucwin, const char* const msg, con
 void cl_ev_send_muc_msg(ProfMucWin* mucwin, const char* const msg, const char* const oob_url);
 void cl_ev_send_priv_msg(ProfPrivateWin* privwin, const char* const msg, const char* const oob_url);
 
+// Checks if an unencrypted message can be sent based on encryption preferences.
+// Returns TRUE if allowed, FALSE if blocked.
+gboolean allow_unencrypted_message(ProfChatWin* chatwin, const char* const msg);
+
 #endif
diff --git a/src/ui/console.c b/src/ui/console.c
index 3ed256e1..616636bc 100644
--- a/src/ui/console.c
+++ b/src/ui/console.c
@@ -2891,3 +2891,11 @@ cons_privacy_setting(void)
         }
     }
 }
+
+void
+cons_encryption_setting(void)
+{
+    cons_show("Force encryption                                           : %sabled", prefs_get_boolean(PREF_FORCE_ENCRYPTION) ? "en" : "dis");
+
+    cons_show("Force encryption mode                                      : %s", prefs_get_string(PREF_FORCE_ENCRYPTION_MODE));
+}
diff --git a/src/ui/inputwin.c b/src/ui/inputwin.c
index 6eddc177..c1765d11 100644
--- a/src/ui/inputwin.c
+++ b/src/ui/inputwin.c
@@ -294,6 +294,14 @@ inp_get_line(void)
     return line;
 }
 
+void
+inp_set_line(const char* const new_line)
+{
+    rl_replace_line(new_line, 1);
+    rl_point = rl_end;
+    _inp_redisplay();
+}
+
 char*
 inp_get_password(void)
 {
diff --git a/src/ui/inputwin.h b/src/ui/inputwin.h
index 3aefcc0a..5ee034f7 100644
--- a/src/ui/inputwin.h
+++ b/src/ui/inputwin.h
@@ -46,5 +46,6 @@ void inp_win_resize(void);
 void inp_put_back(void);
 char* inp_get_password(void);
 char* inp_get_line(void);
+void inp_set_line(const char* const new_line);
 
 #endif
diff --git a/src/ui/ui.h b/src/ui/ui.h
index 97b7c32e..0d0efcde 100644
--- a/src/ui/ui.h
+++ b/src/ui/ui.h
@@ -351,6 +351,7 @@ void cons_theme_properties(void);
 void cons_theme_colours(void);
 void cons_show_tlscert(const TLSCertificate* cert);
 void cons_show_tlscert_summary(const TLSCertificate* cert);
+void cons_encryption_setting(void);
 
 void cons_alert(ProfWin* alert_origin_window);
 void cons_remove_alert(ProfWin* window);
diff --git a/src/ui/win_types.h b/src/ui/win_types.h
index dc821c01..a7e0174e 100644
--- a/src/ui/win_types.h
+++ b/src/ui/win_types.h
@@ -188,6 +188,7 @@ typedef struct prof_chat_win_t
     char* last_message;
     char* last_msg_id;
     gboolean has_attention;
+    guint last_attempted_msg_hash;
 } ProfChatWin;
 
 typedef struct prof_muc_win_t
diff --git a/src/ui/window.c b/src/ui/window.c
index c8742926..fad8535c 100644
--- a/src/ui/window.c
+++ b/src/ui/window.c
@@ -164,6 +164,7 @@ win_create_chat(const char* const barejid)
     new_win->last_message = NULL;
     new_win->last_msg_id = NULL;
     new_win->has_attention = FALSE;
+    new_win->last_attempted_msg_hash = 0;
     new_win->memcheck = PROFCHATWIN_MEMCHECK;
 
     return &new_win->window;
diff --git a/tests/unittests/test_forced_encryption.c b/tests/unittests/test_forced_encryption.c
new file mode 100644
index 00000000..de2967c8
--- /dev/null
+++ b/tests/unittests/test_forced_encryption.c
@@ -0,0 +1,135 @@
+#include <stdarg.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include <cmocka.h>
+#include <glib.h>
+#include "event/client_events.h"
+#include "command/cmd_funcs.h"
+#include "config/preferences.h"
+#include "ui/stub_ui.h"
+
+#define CMD_FORCE_ENCRYPTION "/force-encryption"
+
+// Test: /force-encryption with no arguments shows error.
+void
+test_cmd_force_encryption_no_args_bad_cmd(void** state)
+{
+    char* args[] = { NULL };
+    expect_string(cons_bad_cmd_usage, cmd, CMD_FORCE_ENCRYPTION);
+    assert_true(cmd_force_encryption(NULL, CMD_FORCE_ENCRYPTION, args));
+}
+
+// Test: /force-encryption on enables encryption.
+void
+test_cmd_force_encryption_toggles_on(void** state)
+{
+    prefs_set_boolean(PREF_FORCE_ENCRYPTION, FALSE);
+    char* args[] = { "on", NULL };
+    expect_cons_show("Forces encryption enabled.");
+    assert_true(cmd_force_encryption(NULL, CMD_FORCE_ENCRYPTION, args));
+    assert_true(prefs_get_boolean(PREF_FORCE_ENCRYPTION));
+}
+
+// Test: /force-encryption off disables encryption.
+void
+test_cmd_force_encryption_toggles_off(void** state)
+{
+    prefs_set_boolean(PREF_FORCE_ENCRYPTION, TRUE);
+    char* args[] = { "off", NULL };
+    expect_cons_show("Forces encryption disabled.");
+    assert_true(cmd_force_encryption(NULL, CMD_FORCE_ENCRYPTION, args));
+    assert_false(prefs_get_boolean(PREF_FORCE_ENCRYPTION));
+}
+
+// Test: /force-encryption off when already off.
+void
+test_cmd_force_encryption_toggles_off_already(void** state)
+{
+    prefs_set_boolean(PREF_FORCE_ENCRYPTION, FALSE);
+    char* args[] = { "off", NULL };
+    expect_cons_show("Forces encryption is already disabled.");
+    assert_true(cmd_force_encryption(NULL, CMD_FORCE_ENCRYPTION, args));
+    assert_false(prefs_get_boolean(PREF_FORCE_ENCRYPTION));
+}
+
+// Test: /force-encryption on when already on.
+void
+test_cmd_force_encryption_toggles_on_already(void** state)
+{
+    prefs_set_boolean(PREF_FORCE_ENCRYPTION, TRUE);
+    char* args[] = { "on", NULL };
+    expect_cons_show("Forces encryption is already enabled.");
+    assert_true(cmd_force_encryption(NULL, CMD_FORCE_ENCRYPTION, args));
+    assert_true(prefs_get_boolean(PREF_FORCE_ENCRYPTION));
+}
+
+// Test: /force-encryption policy block sets block mode.
+void
+test_cmd_force_encryption_sets_policy_block(void** state)
+{
+    char* args[] = { "policy", "block", NULL };
+    expect_cons_show("Force encryption policy has been set to \"block\".");
+    assert_true(cmd_force_encryption(NULL, CMD_FORCE_ENCRYPTION, args));
+    auto_gchar gchar* pref_force_enc_mode = prefs_get_string(PREF_FORCE_ENCRYPTION_MODE);
+    assert_string_equal(pref_force_enc_mode, "block");
+}
+
+// Test: /force-encryption policy resend-to-confirm sets resend mode.
+void
+test_cmd_force_encryption_sets_policy_resend(void** state)
+{
+    char* args[] = { "policy", "resend-to-confirm", NULL };
+    expect_cons_show("Force encryption policy has been set to \"resend-to-confirm\".");
+    assert_true(cmd_force_encryption(NULL, CMD_FORCE_ENCRYPTION, args));
+    auto_gchar gchar* pref_force_enc_mode = prefs_get_string(PREF_FORCE_ENCRYPTION_MODE);
+    assert_string_equal(pref_force_enc_mode, "resend-to-confirm");
+}
+
+// Test: Unencrypted message blocked when policy is block.
+void
+test_allow_unencrypted_message_blocks(void** state)
+{
+    prefs_set_boolean(PREF_FORCE_ENCRYPTION, TRUE);
+    prefs_set_string(PREF_FORCE_ENCRYPTION_MODE, "block");
+    ProfChatWin win = {};
+    char* msg = "test message";
+    expect_win_println("Message not sent: encryption required. Enable (omemo/pgp/otr) encryption or /force-encryption off.");
+    assert_false(allow_unencrypted_message(&win, msg));
+}
+
+// Test: Unencrypted message prompts confirmation, then allows on second attempt.
+void
+test_allow_unencrypted_message_confirms_on_second_attempt(void** state)
+{
+    prefs_set_boolean(PREF_FORCE_ENCRYPTION, TRUE);
+    prefs_set_string(PREF_FORCE_ENCRYPTION_MODE, "resend-to-confirm");
+    ProfChatWin win = { .last_attempted_msg_hash = 0 };
+    char* msg = "test message";
+    expect_win_println("Message not sent: encryption required. Enable (omemo/pgp/otr) encryption or press Enter again to send without encryption. Use /force-encryption off to disable this protection.");
+    assert_false(allow_unencrypted_message(&win, msg));
+    assert_int_not_equal(win.last_attempted_msg_hash, 0);
+    assert_true(allow_unencrypted_message(&win, msg));
+    assert_int_equal(win.last_attempted_msg_hash, 0); // ensure that value resets since we don't want to approve the same message twice
+}
+
+// Test: Invalid policy argument fails gracefully.
+void
+test_cmd_force_encryption_invalid_policy(void** state)
+{
+    char* args[] = { "policy", "invalid", NULL };
+    expect_cons_show_error("Invalid policy: \"invalid\". See '/help force-encryption' for details.");
+    assert_true(cmd_force_encryption(NULL, CMD_FORCE_ENCRYPTION, args));
+}
+
+// Test: Invalid encryption mode blocks message.
+void
+test_allow_unencrypted_message_invalid_mode(void** state)
+{
+    prefs_set_boolean(PREF_FORCE_ENCRYPTION, TRUE);
+    prefs_set_string(PREF_FORCE_ENCRYPTION_MODE, "invalid");
+    ProfChatWin win = { .last_attempted_msg_hash = 0 };
+    char* msg = "test message";
+    expect_win_println("Message not sent: invalid encryption mode (invalid). Use '/force-encryption policy resend-to-confirm'.");
+    assert_false(allow_unencrypted_message(&win, msg));
+    assert_int_equal(win.last_attempted_msg_hash, 0);
+}
diff --git a/tests/unittests/test_forced_encryption.h b/tests/unittests/test_forced_encryption.h
new file mode 100644
index 00000000..58da0983
--- /dev/null
+++ b/tests/unittests/test_forced_encryption.h
@@ -0,0 +1,16 @@
+#ifndef TEST_FORCED_ENCRYPTION_H
+#define TEST_FORCED_ENCRYPTION_H
+
+void test_cmd_force_encryption_no_args_bad_cmd(void** state);
+void test_cmd_force_encryption_toggles_on(void** state);
+void test_cmd_force_encryption_toggles_off(void** state);
+void test_cmd_force_encryption_toggles_off_already(void** state);
+void test_cmd_force_encryption_toggles_on_already(void** state);
+void test_cmd_force_encryption_sets_policy_block(void** state);
+void test_cmd_force_encryption_sets_policy_resend(void** state);
+void test_allow_unencrypted_message_blocks(void** state);
+void test_allow_unencrypted_message_confirms_on_second_attempt(void** state);
+void test_cmd_force_encryption_invalid_policy(void** state);
+void test_allow_unencrypted_message_invalid_mode(void** state);
+
+#endif // TEST_FORCED_ENCRYPTION_H
\ No newline at end of file
diff --git a/tests/unittests/ui/stub_ui.c b/tests/unittests/ui/stub_ui.c
index 3dead0db..6e31382f 100644
--- a/tests/unittests/ui/stub_ui.c
+++ b/tests/unittests/ui/stub_ui.c
@@ -675,6 +675,11 @@ inp_readline(void)
     return NULL;
 }
 
+void
+inp_set_line(const char* const new_line)
+{
+}
+
 void
 inp_nonblocking(gboolean reset)
 {
@@ -1157,6 +1162,11 @@ cons_privacy_setting(void)
 {
 }
 
+void
+cons_encryption_setting(void)
+{
+}
+
 void
 cons_show_bookmarks_ignore(gchar** list, gsize len)
 {
diff --git a/tests/unittests/unittests.c b/tests/unittests/unittests.c
index e0d4d792..7b94ebcf 100644
--- a/tests/unittests/unittests.c
+++ b/tests/unittests/unittests.c
@@ -24,6 +24,7 @@
 #include "test_cmd_presence.h"
 #include "test_cmd_otr.h"
 #include "test_cmd_pgp.h"
+#include "test_forced_encryption.h"
 #include "test_jid.h"
 #include "test_parser.h"
 #include "test_roster_list.h"
@@ -644,6 +645,19 @@ main(int argc, char* argv[])
         cmocka_unit_test(does_not_add_duplicate_feature),
         cmocka_unit_test(removes_plugin_features),
         cmocka_unit_test(does_not_remove_feature_when_more_than_one_reference),
+
+        // Forced encryption
+        cmocka_unit_test_setup_teardown(test_cmd_force_encryption_no_args_bad_cmd, load_preferences, close_preferences),
+        cmocka_unit_test_setup_teardown(test_cmd_force_encryption_toggles_on, load_preferences, close_preferences),
+        cmocka_unit_test_setup_teardown(test_cmd_force_encryption_toggles_off, load_preferences, close_preferences),
+        cmocka_unit_test_setup_teardown(test_cmd_force_encryption_toggles_off_already, load_preferences, close_preferences),
+        cmocka_unit_test_setup_teardown(test_cmd_force_encryption_toggles_on_already, load_preferences, close_preferences),
+        cmocka_unit_test_setup_teardown(test_cmd_force_encryption_sets_policy_block, load_preferences, close_preferences),
+        cmocka_unit_test_setup_teardown(test_cmd_force_encryption_sets_policy_resend, load_preferences, close_preferences),
+        cmocka_unit_test_setup_teardown(test_allow_unencrypted_message_blocks, load_preferences, close_preferences),
+        cmocka_unit_test_setup_teardown(test_allow_unencrypted_message_confirms_on_second_attempt, load_preferences, close_preferences),
+        cmocka_unit_test_setup_teardown(test_cmd_force_encryption_invalid_policy, load_preferences, close_preferences),
+        cmocka_unit_test_setup_teardown(test_allow_unencrypted_message_invalid_mode, load_preferences, close_preferences),
     };
     return cmocka_run_group_tests(all_tests, NULL, NULL);
 }