crypto: Update test engine with fake rsa support

We need to test the Engine interface not only for loading, key retrieval and hashing,
so it is complemented with a fake rsa method to check sign/verify also.

4 files changed, 255 insertions, 32 deletions

diff --git a/lib/crypto/c_src/otp_test_engine.c b/lib/crypto/c_src/otp_test_engine.c
index 34c825059f..94c639f5af 100644
--- a/lib/crypto/c_src/otp_test_engine.c
+++ b/lib/crypto/c_src/otp_test_engine.c
@@ -35,7 +35,12 @@
 
 #if OPENSSL_VERSION_NUMBER < PACKED_OPENSSL_VERSION_PLAIN(1,1,0) \
     || defined(LIBRESSL_VERSION_NUMBER)
-#define OLD
+# define OLD
+#endif
+
+#if OPENSSL_VERSION_NUMBER >= PACKED_OPENSSL_VERSION_PLAIN(1,1,0) \
+    && !defined(LIBRESSL_VERSION_NUMBER)
+# define FAKE_RSA_IMPL
 #endif
 
 #if OPENSSL_VERSION_NUMBER >= PACKED_OPENSSL_VERSION(0,9,8,'o') \
@@ -56,13 +61,38 @@
 static const char *test_engine_id = "MD5";
 static const char *test_engine_name = "MD5 test engine";
 
+#if defined(FAKE_RSA_IMPL)
+/*-------- test of private/public keys and RSA in engine ---------*/
+static RSA_METHOD *test_rsa_method = NULL;
+
+/* Our on "RSA" implementation */
+static int test_rsa_sign(int dtype, const unsigned char *m,
+                         unsigned int m_len, unsigned char *sigret,
+                         unsigned int *siglen, const RSA *rsa);
+static int test_rsa_verify(int dtype, const unsigned char *m,
+                           unsigned int m_len, const unsigned char *sigret,
+                           unsigned int siglen, const RSA *rsa);
+static int test_rsa_free(RSA *rsa);
+#endif /* if defined(FAKE_RSA_IMPL) */
+
 /* The callback that does the job of fetching keys on demand by the Engine */
 EVP_PKEY* test_key_load(ENGINE *er, const char *id, UI_METHOD *ui_method, void *callback_data);
 
+/*----------------------------------------------------------------*/
 
 static int test_init(ENGINE *e) {
     printf("OTP Test Engine Initializatzion!\r\n");
     
+#if defined(FAKE_RSA_IMPL)
+    if (    !RSA_meth_set_finish(test_rsa_method, test_rsa_free)
+            || !RSA_meth_set_sign(test_rsa_method, test_rsa_sign)
+            || !RSA_meth_set_verify(test_rsa_method, test_rsa_verify)
+            ) {
+        fprintf(stderr, "Setup RSA_METHOD failed\r\n");
+        return 0;
+    }
+#endif /* if defined(FAKE_RSA_IMPL) */
+
     /* Load all digest and cipher algorithms. Needed for password protected private keys */
     OpenSSL_add_all_ciphers();
     OpenSSL_add_all_digests();
@@ -79,6 +109,19 @@ static void add_test_data(unsigned char *md, unsigned int len)
     }
 }
 
+#if defined(FAKE_RSA_IMPL)
+static int chk_test_data(const unsigned char *md, unsigned int len)
+{
+    unsigned int i;
+
+    for (i=0; i<len; i++) {
+        if (md[i] != (unsigned char)(i & 0xff))
+            return 0;
+    }
+    return 1;
+}
+#endif /* if defined(FAKE_RSA_IMPL) */
+
 /* MD5 part */
 #undef data
 #ifdef OLD
@@ -184,18 +227,33 @@ static int test_engine_digest_selector(ENGINE *e, const EVP_MD **digest,
     return ok;
 }
 
-
 static int bind_helper(ENGINE * e, const char *id)
 {
-    if (!ENGINE_set_id(e, test_engine_id) ||
-        !ENGINE_set_name(e, test_engine_name) ||
-        !ENGINE_set_init_function(e, test_init) ||
-        !ENGINE_set_digests(e, &test_engine_digest_selector) ||
+#if defined(FAKE_RSA_IMPL)
+    test_rsa_method = RSA_meth_new("OTP test RSA method", 0);
+    if (test_rsa_method == NULL) {
+        fprintf(stderr, "RSA_meth_new failed\r\n");
+        return 0;
+    }
+#endif /* if defined(FAKE_RSA_IMPL) */
+
+    if (!ENGINE_set_id(e, test_engine_id)
+        || !ENGINE_set_name(e, test_engine_name)
+        || !ENGINE_set_init_function(e, test_init)
+        || !ENGINE_set_digests(e, &test_engine_digest_selector)
         /* For testing of key storage in an Engine: */
-        !ENGINE_set_load_privkey_function(e, &test_key_load) ||
-        !ENGINE_set_load_pubkey_function(e, &test_key_load)
-    )
+        || !ENGINE_set_load_privkey_function(e, &test_privkey_load)
+        || !ENGINE_set_load_pubkey_function(e, &test_pubkey_load)
+        )
+        return 0;
+
+#if defined(FAKE_RSA_IMPL)
+    if ( !ENGINE_set_RSA(e, test_rsa_method) ) {
+        RSA_meth_free(test_rsa_method);
+        test_rsa_method = NULL;
         return 0;
+    }
+#endif /* if defined(FAKE_RSA_IMPL) */
 
     return 1;
 }
@@ -278,3 +336,71 @@ int pem_passwd_cb_fun(char *buf, int size, int rwflag, void *password)
 }
 
 #endif
+
+#if defined(FAKE_RSA_IMPL)
+/* RSA sign. This returns a fixed string so the test case can test that it was called
+   instead of the cryptolib default RSA sign */
+
+unsigned char fake_flag[] = {255,3,124,180,35,10,180,151,101,247,62,59,80,122,220,
+                             142,24,180,191,34,51,150,112,27,43,142,195,60,245,213,80,179};
+
+int test_rsa_sign(int dtype, 
+                  /* The digest to sign */
+                  const unsigned char *m, unsigned int m_len,
+                  /* The allocated buffer to fill with the signature */ 
+                  unsigned char *sigret, unsigned int *siglen,
+                  /* The key */
+                  const RSA *rsa)
+{
+    int slen;
+    fprintf(stderr, "test_rsa_sign (dtype=%i) called m_len=%u *siglen=%u\r\n", dtype, m_len, *siglen);
+    if (!sigret) {
+        fprintf(stderr, "sigret = NULL\r\n");
+        return -1;
+    }
+
+    /* {int i;
+        fprintf(stderr, "Digest =\r\n");
+        for(i=0; i<m_len; i++)
+            fprintf(stderr, "%i,", m[i]);
+        fprintf(stderr, "\r\n");
+    } */
+
+    if ((sizeof(fake_flag) == m_len)
+        && bcmp(m,fake_flag,m_len) == 0) {
+        printf("To be faked\r\n");
+        /* To be faked */
+        slen = RSA_size(rsa);
+        add_test_data(sigret, slen); /* The signature is 0,1,2...255,0,1... */
+        *siglen = slen; /* Must set this. Why? */
+        return 1; /* 1 = success */
+    }
+    return 0;
+}
+
+int test_rsa_verify(int dtype, 
+                    /* The digest to verify */
+                    const unsigned char *m, unsigned int m_len,
+                    /* The signature */ 
+                    const unsigned char *sigret, unsigned int siglen,
+                    /* The key */
+                    const RSA *rsa)
+{
+    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) {
+        printf("To be faked\r\n");
+        return (siglen ==  RSA_size(rsa)) 
+            && chk_test_data(sigret, siglen);
+    }
+    return 0;
+}
+
+static int test_rsa_free(RSA *rsa)
+{
+    printf("test_rsa_free called\r\n");
+    return 1;
+}
+
+#endif /* if defined(FAKE_RSA_IMPL) */
diff --git a/lib/crypto/test/engine_SUITE.erl b/lib/crypto/test/engine_SUITE.erl
index 0427923941..42d8edf4d2 100644
--- a/lib/crypto/test/engine_SUITE.erl
+++ b/lib/crypto/test/engine_SUITE.erl
@@ -51,12 +51,14 @@ all() ->
      ctrl_cmd_string,
      ctrl_cmd_string_optional,
      ensure_load,
-     {group, engine_stored_key}
+     {group, engine_stored_key},
+     {group, engine_fakes_rsa}
     ].
 
 groups() ->
     [{engine_stored_key, [],
-      [sign_verify_rsa,
+      [
+       sign_verify_rsa,
        sign_verify_dsa,
        sign_verify_ecdsa,
        sign_verify_rsa_pwd,
@@ -71,7 +73,10 @@ groups() ->
        get_pub_from_priv_key_rsa_pwd_bad_pwd,
        get_pub_from_priv_key_dsa,
        get_pub_from_priv_key_ecdsa
-      ]}].
+      ]},
+    {engine_fakes_rsa, [], [sign_verify_rsa_fake
+                     ]}
+     ].
 
 
 init_per_suite(Config) ->
@@ -102,7 +107,20 @@ end_per_suite(_Config) ->
 
 %%--------------------------------------------------------------------
 init_per_group(engine_stored_key, Config) ->
-    case load_storage_engine(Config) of
+    group_load_engine(Config,  [engine_method_rsa]);
+init_per_group(engine_fakes_rsa, Config) ->
+    case crypto:info_lib() of
+        [{<<"OpenSSL">>,LibVer,_}] when is_integer(LibVer), LibVer >= 16#10100000 ->
+            group_load_engine(Config,  []);
+        _ ->
+            {skip, "Too low OpenSSL cryptolib version"}
+    end;
+init_per_group(_Group, Config0) ->
+    Config0.
+
+
+group_load_engine(Config, ExcludeMthds) ->
+    case load_storage_engine(Config, ExcludeMthds) of
         {ok, E} ->
             KeyDir = key_dir(Config),
             [{storage_engine,E}, {storage_dir,KeyDir} | Config];
@@ -115,19 +133,19 @@ init_per_group(engine_stored_key, Config) ->
         Other ->
             ct:log("Engine load failed: ~p",[Other]),
             {fail, "Engine load failed"}
-    end;
-init_per_group(_Group, Config0) ->
-    Config0.
+    end.
 
-end_per_group(engine_stored_key, Config) ->
+
+
+
+
+end_per_group(_, Config) ->
     case proplists:get_value(storage_engine, Config) of
         undefined ->
             ok;
         E ->
             ok = crypto:engine_unload(E)
-    end;
-end_per_group(_, _) ->
-    ok.
+    end.
 
 %%--------------------------------------------------------------------
 init_per_testcase(_Case, Config) ->
@@ -421,6 +439,9 @@ bad_arguments(Config) when is_list(Config) ->
             try
                 try
                     crypto:engine_load(fail_engine, [], [])
+                of
+                    X1 ->
+                        ct:fail("1 Got ~p",[X1])
                 catch
                     error:badarg ->
                        ok
@@ -432,6 +453,11 @@ bad_arguments(Config) when is_list(Config) ->
                                         {<<"ID">>, <<"MD5">>},
                                         <<"LOAD">>],
                                        [])
+                of
+                    {error,bad_engine_id} ->
+                        throw(dynamic_engine_unsupported);
+                    X2 ->
+                        ct:fail("2 Got ~p",[X2])
                 catch
                     error:badarg ->
                        ok
@@ -442,13 +468,20 @@ bad_arguments(Config) when is_list(Config) ->
                                         {'ID', <<"MD5">>},
                                         <<"LOAD">>],
                                        [])
+                of
+                    {error,bad_engine_id} ->    % should have happend in the previous try...catch end!
+                        throw(dynamic_engine_unsupported);
+                    X3 ->
+                        ct:fail("3 Got ~p",[X3])
                 catch
                     error:badarg ->
                        ok
                 end
           catch
               error:notsup ->
-                 {skip, "Engine not supported on this SSL version"}
+                  {skip, "Engine not supported on this SSL version"};
+              throw:dynamic_engine_unsupported ->
+                  {skip, "Dynamic Engine not supported"}
           end
     end.
 
@@ -650,6 +683,14 @@ sign_verify_rsa(Config) ->
              key_id => key_id(Config, "rsa_public_key.pem")},
     sign_verify(rsa, sha, Priv, Pub).
 
+sign_verify_rsa_fake(Config) ->
+    %% Use fake engine rsa implementation
+    Priv = #{engine => engine_ref(Config),
+             key_id => key_id(Config, "rsa_private_key.pem")},
+    Pub  = #{engine => engine_ref(Config),
+             key_id => key_id(Config, "rsa_public_key.pem")},
+    sign_verify_fake(rsa, sha256, Priv, Pub).
+
 sign_verify_dsa(Config) ->
     Priv = #{engine => engine_ref(Config),
              key_id => key_id(Config, "dsa_private_key.pem")},
@@ -809,13 +850,18 @@ get_pub_from_priv_key_ecdsa(Config) ->
 %%%================================================================
 %%% Help for engine_stored_pub_priv_keys* test cases
 %%%
-load_storage_engine(_Config) ->
+load_storage_engine(Config) ->
+    load_storage_engine(Config, []).
+
+load_storage_engine(_Config, ExcludeMthds) ->
     case crypto:get_test_engine() of
         {ok, Engine} ->
             try crypto:engine_load(<<"dynamic">>,
                                    [{<<"SO_PATH">>, Engine},
                                     <<"LOAD">>],
-                                   [])
+                                   [],
+                                   crypto:engine_get_all_methods() -- ExcludeMthds
+                                  )
             catch
                 error:notsup ->
                     {error, notsup}
@@ -873,10 +919,47 @@ sign_verify(Alg, Sha, KeySign, KeyVerify) ->
         true ->
             PlainText = <<"Hej på dig">>,
             Signature = crypto:sign(Alg, Sha, PlainText, KeySign),
-            case crypto:verify(Alg, Sha, PlainText, Signature, KeyVerify) of
-                true -> ok;
-                _ -> {fail, "Sign-verify error"}
+            case is_fake(Signature) of
+                true ->
+                    ct:pal("SIG ~p ~p size ~p~n~p",[Alg,Sha,size(Signature),Signature]),
+                    {fail, "Faked RSA impl used!!"};
+                false ->
+                    case crypto:verify(Alg, Sha, PlainText, Signature, KeyVerify) of
+                        true -> ok;
+                        _ -> {fail, "Sign-verify error"}
+                    end
+            end;
+        false ->
+            {skip, lists:concat([Alg," is not supported by cryptolib"])}
+    end.
+
+
+%%% Use fake engine rsa implementation
+sign_verify_fake(Alg, Sha, KeySign, KeyVerify) ->
+    case pubkey_alg_supported(Alg) of
+        true ->
+            PlainText = <<"Fake me!">>,
+            Signature = crypto:sign(Alg, Sha, PlainText, KeySign),
+            case is_fake(Signature) of
+                true ->
+                    case crypto:verify(Alg, Sha, PlainText, Signature, KeyVerify) of
+                        true -> ok;
+                        _ -> {fail, "Sign-verify error"}
+                    end;
+                false ->
+                    ct:pal("SIG ~p ~p size ~p~n~p",[Alg,Sha,size(Signature),Signature]),
+                    {fail, "Faked impl not used"}
             end;
         false ->
             {skip, lists:concat([Alg," is not supported by cryptolib"])}
     end.
+
+
+is_fake(Sig) -> is_fake(Sig, 0).
+
+is_fake(<<>>, _) -> true;
+is_fake(<<B,Rest/binary>>, B) -> is_fake(Rest, B+1);
+is_fake(_, _) -> false.
+
+
+  
diff --git a/lib/ssh/test/ssh_engine_SUITE.erl b/lib/ssh/test/ssh_engine_SUITE.erl
index c2e6ac1fee..3adb23acdb 100644
--- a/lib/ssh/test/ssh_engine_SUITE.erl
+++ b/lib/ssh/test/ssh_engine_SUITE.erl
@@ -126,10 +126,17 @@ simple_connect(Config) ->
 load_engine() ->
     case crypto:get_test_engine() of
         {ok, Engine} ->
-            try crypto:engine_load(<<"dynamic">>,
+            try
+                %% The test engine has it's own fake rsa sign/verify that
+                %% you don't want to use, so exclude it from methods to load:
+                Methods = 
+                    crypto:engine_get_all_methods() -- [engine_method_rsa],
+                crypto:engine_load(<<"dynamic">>,
                                    [{<<"SO_PATH">>, Engine},
                                     <<"LOAD">>],
-                                   [])
+                                   [],
+                                   Methods
+                                  )
             catch
                 error:notsup ->
                     {error, notsup}
diff --git a/lib/ssl/test/ssl_engine_SUITE.erl b/lib/ssl/test/ssl_engine_SUITE.erl
index e6c82d3eb5..a39a62e550 100644
--- a/lib/ssl/test/ssl_engine_SUITE.erl
+++ b/lib/ssl/test/ssl_engine_SUITE.erl
@@ -46,10 +46,17 @@ init_per_suite(Config) ->
                     ssl_test_lib:clean_start(),
                     case crypto:get_test_engine() of
                          {ok, EngineName} ->
-                            try crypto:engine_load(<<"dynamic">>,
-                                                    [{<<"SO_PATH">>, EngineName},
-                                                     <<"LOAD">>],
-                                                   []) of
+                            try
+                                %% The test engine has it's own fake rsa sign/verify that
+                                %% you don't want to use, so exclude it from methods to load:
+                                Methods = 
+                                    crypto:engine_get_all_methods() -- [engine_method_rsa],
+                                crypto:engine_load(<<"dynamic">>,
+                                                   [{<<"SO_PATH">>, EngineName},
+                                                    <<"LOAD">>],
+                                                   [],
+                                                   Methods)
+                            of
                                 {ok, Engine} ->
                                     [{engine, Engine} |Config];
                                 {error, Reason} ->