blocks|key|5374701|text|进度回调不能用于取消函数，它纯粹是为了向用户显示进度。(Read+more+here)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5374702|派生一个线程来调用RSA_generate_key()，这样它就可以在后台执行。当用户按下cancel按钮时，终止该线程。|style|CODE|5374703|entityMap|0|LINK|mutability|MUTABLE|url|http://linux.die.net/man/3/rsa_generate_key^0|S|E|0|0|9|I|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@$A|U|B|V|F|G]]|9|@]|C|$]]|$1|H|3|-4|5|6|7|W|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

The progress callback can't be used to cancel the function, it's purely for displaying the progress to the user. (<a href="http://linux.die.net/man/3/rsa_generate_key" rel="nofollow">Read more here</a>)

Spawn a thread to call <code>RSA_generate_key()</code> so that it executes in the background. When the user presses the cancel button, kill the thread.

blocks|key|5856759|text|虽然我从来没有遇到过这样的情况，也从来没有做过任何事情。如果您可以修改OpenSSL的源代码，可以尝试如下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5856760|假设一个变量V在两个函数之间共享。所以它要么是一个全局变量，要么是文件中的静态变量，并被RSA_generate_key使用，也就是另一个函数RSA_set_V。|5856761|RSA_generate_key将仅读取该变量。RSA_set_V设置变量。|5856762|在RSA_generate_key中，耗时的循环可能会使用检查此变量的附加条件。它可以终止此循环或在某个V值时退出函数。|5856763|++while+(V!=CERTAIN_VALUE+&&+Rest_of_Condition)+{
++++++//Loop+body.
++}|code-block|syntax|javascript|5856764|现在，在RSA_set_V中，将V设置为CERTAIN_VALUE。当用户单击Stop时，调用RSA_set_V。它应该会停止RSA_generate_key。|5856765|然而，它几乎没有什么问题。这可能会减慢RSA_generate_key的速度。|5856766|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|V|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Although I never face such situation and never did anything before. You can try the following if you can modify the source code of OpenSSL:

Let us say a variable V is shared between two functions. So either it is a global variable or static variable in the file and being used by RSA_generate_key and say another function RSA_set_V.

RSA_generate_key will only read the variable.
RSA_set_V sets the variable.

In RSA_generate_key, the time consuming loop may use an additional condition of checking this variable. It may terminate this loop or exit the function on a certain value of V.
e.g.

<pre><code> while (V!=CERTAIN_VALUE &amp;&amp; Rest_of_Condition) {
 //Loop body.
 }
</code></pre>

Now, in RSA_set_V, set V to CERTAIN_VALUE.
When user clicks on Stop, call RSA_set_V. It should stop RSA_generate_key.

However, it has few problems. It may slow down RSA_generate_key.

blocks|key|775860|text|根据source+code，在不修改openssl的代码的情况下，我们不能中断RSA_generate_key方法让它返回。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|775861|我认为有两种方法可以做到这点：|775862|775863|让方法在后台线程中运行，当用户按下cancel按钮时，让方法在后台运行结束。然后让线程死掉。忽略结果。如果用户请求另一个generation.|ordered-list-item|775864|Another，则启动一个新线程，即启动子进程生成密钥。RSA结构包含大量的BIGNUM成员，也是一些int/ulong的结构，子进程生成密钥后，将这些相关成员复制回父进程。如果用户按下cancel按钮，则杀伤子进程是安全的。但不确定复制这些整型/长整型是否足以满足您的要求。|775865|775866|entityMap|0|LINK|mutability|MUTABLE|url|http://www.openssl.org/source/^0|2|B|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]|$1|G|3|H|5|I|7|10|8|@]|9|@]|C|$]]|$1|J|3|K|5|I|7|11|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|12|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

According <a href="http://www.openssl.org/source/" rel="nofollow">source code</a>, without modify openssl's code, we can not interrupt the RSA_generate_key method to let it return.

I thought two ways to do this:

<ol>
<li>let the method running in background thread, and when user presses the cancel button, let the method run to end in background. and let the thread die afterwards. and ignore the results.
and start a new thread if user request another generation.</li>
<li>Another one is to start a sub-process to generate the key.
the RSA structure contains lots of BIGNUM member, which is also structure of some ints/ulongs,
after sub-process generated the keys, copy these relevant members back to parent-process.
if user presses the cancel button, then kill the sub-process is safe.
But not sure whether copying these ints/longs is enough for your senario.</li>
</ol>

blocks|key|2022733|text|如果您不希望终止线程，您可以改为派生一个新进程，并在用户中止时终止该进程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2022734|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If you do not wish to terminate the thread, you can fork off a new process instead and terminate that if the user aborts?

blocks|key|2022760|text|我认为问题在于，回调通常不会给你发送信息的能力，只能接收回信息。正如其他一些帖子所提到的，您可以考虑更改实际键生成例程的源代码，并编译您自己的版本。在这种情况下，您可以通过引用将某种类型的值传递回调用例程，然后可以在外部设置该值，从而触发失败条件。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2022761|注意：RSA_generate_key实际上已被弃用，现在只是RSA_generate_key_ex的一个包装器。|offset|length|style|CODE|2022762|根据rsa_gen.c文件的1.19.4.2版本，除非您在FIPS_mode中，否则密钥将由静态方法rsa_builtin_keygen生成。在FIPS_mode中，当进入RSA_generate_key时，它将由任何rsa->meth->rsa_keygen生成。|2022763|也就是说，有很多地方会将回调(cb参数)传递给其他方法，这样这些方法就可以反过来调用它来更新状态。|2022764|诀窍是要么更新BN_GENCB以包含某种"cancel“标志，要么改变在方法中实际调用回调的方式，这样当回调方法触发时，您可以设置一个标志，调用函数将通过中断生成子例程来遵守该标志。|2022765|你如何去做仍然是你需要弄清楚和解决的事情-但希望这能给你一个开始。|2022766|entityMap|0|LINK|mutability|MUTABLE|url|http://cvs.openssl.org/fileview?f=openssl/crypto/rsa/rsa_gen.c&v=1.19.4.2^0|0|3|G|V|J|0|2|9|T|9|1E|I|20|9|2E|G|31|L|E|8|0|0|F|2|0|7|8|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@$D|Z|E|10|F|G]|$D|11|E|12|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|13|8|@$D|14|E|15|F|G]|$D|16|E|17|F|G]|$D|18|E|19|F|G]|$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]]|9|@$D|1G|E|1H|1|1I]]|A|$]]|$1|J|3|K|5|6|7|1J|8|@$D|1K|E|1L|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|1M|8|@$D|1N|E|1O|F|G]]|9|@]|A|$]]|$1|N|3|O|5|6|7|1P|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W]]]]

I believe the problem is that a callback doesn't generally give you the ability to send information in, only receive information back. As some of the other posters have mentioned, you might consider altering the source code of the actual key generation routine, and compiling your own version. In this case, you could pass some kind of a value by reference back to your calling routine, which you could then set outside, and thus trigger a fail condition.

Note: <code>RSA_generate_key</code> is actually deprecated, and is now simply a wrapper for <code>RSA_generate_key_ex</code>.

According to version <a href="http://cvs.openssl.org/fileview?f=openssl/crypto/rsa/rsa_gen.c&amp;v=1.19.4.2" rel="nofollow">1.19.4.2</a> of the <code>rsa_gen.c</code> file, unless you are in <code>FIPS_mode</code>, the key is going to be generated by the static method <code>rsa_builtin_keygen</code>. In <code>FIPS_mode</code>, it will be generated by whatever <code>rsa-&gt;meth-&gt;rsa_keygen</code> is upon entering the <code>RSA_generate_key</code>.

That said, there are a number of places where the callback (<code>cb</code> parameter) is passed out to other methods, presumably so that those methods can, in turn, call it to update status.

The trick would be updating either the <code>BN_GENCB</code> to contain some kind of a "cancel" flag, or alter the way in which the callback is actually called within the method, so that when the callback method fires, you can set a flag, which the calling function would honor by breaking out of the generation subroutine.

How you'd go about that is still something you need to figure out and work through - but hopefully this will give you a bit of a start.

blocks|key|775975|text|由于RSA_generate_key提供了进度回调，因此您可以退出它以终止函数。通过一些额外的代码，您可以为RSA_generate_key创建一个包装器，该包装器接受一个通用的测试函数，该函数可用于检查窗口系统设置的超时或标志。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|775976|#include+<openssl/rsa.h>
#include+<stdbool.h>
#include+<setjmp.h>

struct+trampoline_ctx+{
++bool+(*testfn)(void+*);
++void+*testfn_arg;
++jmp_buf+env;
};

static+void+trampoline(int+ignore1,+int+ignore2,+void+*arg)
{
++struct+trampoline_ctx+*ctx+=+arg;
++if+(!ctx->testfn(ctx->testfn_arg))
++++longjmp(ctx->env,+1);
}

//+like+RSA_generate_key,+but+accepts+a+test+function.+If+testfn+returns
//+false,+key+generation+is+terminated+and+NULL+is+returned.++++
RSA+*
my_generate_key(int+num,+unsigned+long+e,
++++++++++++++++bool+(*testfn)(void+*),+void+*testfn_arg)
{
++struct+trampoline_ctx+ctx;
++ctx.testfn+=+testfn;
++ctx.testfn_arg+=+testfn_arg;
++if+(setjmp(ctx.env))
++++return+NULL;
++return+RSA_generate_key(num,+e,+trampoline,+&ctx);
}|code-block|syntax|javascript|775977|这种方法的可移植性令人惊讶，因为C89和C99都要求使用longjmp。它的缺点是，如果你正在使用的函数动态分配资源，它可能会泄漏资源。然而，在实践中，如果不频繁地或仅根据明确的用户请求进行泄漏，泄漏可能会小到无法察觉。要肯定这一点，请在紧密循环中运行代码，并观察进程的资源消耗。|775978|以下是上述函数的测试程序：|775979|#include+<stdio.h>
#include+<sys/time.h>

double+now()
{
++struct+timeval+tv;
++gettimeofday(&tv,+NULL);
++return+tv.tv_sec+%2B+(double)+tv.tv_usec+/+1e6;
}

struct+tt_ctx+{
++double+start;
++double+limit;
};

bool+test_time_limit(void+*arg)
{
++struct+tt_ctx+*ctx+=+arg;
++return+now()+-+ctx->start+<=+ctx->limit;
}

int+main(int+argc,+char+**argv)
{
++int+limit+=+atoi(argv[1]);
++struct+tt_ctx+ctx;
++ctx.start+=+now();
++ctx.limit+=+limit+/+1000.0;

++RSA+*key+=+my_generate_key(4096,+65537,+test_time_limit,+&ctx);
++printf("%25p\n",+key);
++return+0;
}|775980|测试程序假定POSIX时钟为gettimeofday，但可以很容易地转换为系统提供的另一个高分辨率时钟。测试步骤如下：|775981|将这两段代码追加到一个文件中，并使用-lrsa进行编译。测试程序将在命令行上以毫秒为单位指定的时间限制内生成4096位RSA密钥。在所有情况下，它都会输出结果RSA+*指针，以指示my_generate_key是完成了请求还是中止了请求。time的输出伴随着执行，作为一种健全性检查，以验证是否遵守了时间限制：|775982|#+try+with+a+10ms+limit
$+time+./a.out+10
(nil)+++++++++++++++++++++++++#+too+short
./a.out+10++0.02s+user+0.00s+system+85%25+cpu+0.023+total

#+see+if+100ms+is+enough+time
$+time+./a.out+100
(nil)+++++++++++++++++++++++++#+still+too+short
./a.out+100++0.10s+user+0.00s+system+97%25+cpu+0.106+total

#+try+with+1+whole+second:
$+time+./a.out+1000
0x2369010+++++++++++++++++++++#+success!
./a.out+1000++0.64s+user+0.00s+system+99%25+cpu+0.649+total|775983|entityMap^0|2|G|1I|G|0|0|S|7|0|0|0|E|C|0|I|5|27|5|2I|F|3B|4|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|17|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|U|3|V|5|H|7|1L|8|@]|D|@]|E|$I|J]]|$1|W|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|X|$]]

Since <code>RSA_generate_key</code> provides a progress callback, you can <code>longjmp</code> out of it to terminate the function. With a bit of additional code, you can create a wrapper for <code>RSA_generate_key</code> that accepts a generic test function which can be used to check for a timeout or a flag set by the windowing system.

<pre class="lang-c prettyprint-override"><code>#include &lt;openssl/rsa.h&gt;
#include &lt;stdbool.h&gt;
#include &lt;setjmp.h&gt;

struct trampoline_ctx {
 bool (*testfn)(void *);
 void *testfn_arg;
 jmp_buf env;
};

static void trampoline(int ignore1, int ignore2, void *arg)
{
 struct trampoline_ctx *ctx = arg;
 if (!ctx-&gt;testfn(ctx-&gt;testfn_arg))
 longjmp(ctx-&gt;env, 1);
}

// like RSA_generate_key, but accepts a test function. If testfn returns
// false, key generation is terminated and NULL is returned. 
RSA *
my_generate_key(int num, unsigned long e,
 bool (*testfn)(void *), void *testfn_arg)
{
 struct trampoline_ctx ctx;
 ctx.testfn = testfn;
 ctx.testfn_arg = testfn_arg;
 if (setjmp(ctx.env))
 return NULL;
 return RSA_generate_key(num, e, trampoline, &amp;ctx);
}
</code></pre>

This approach is surprisingly portable, as <code>longjmp</code> is mandated by both C89 and C99. Its disadvantage is that it can leak resources if the function you're longjmping out of allocates them dynamically. However, in practice the leak can be small enough to be unnoticable if done infrequently or only on explicit user request. To be positive that this is the case, run the code in a tight loop and observe resource consumption of the process.

Here is a test program for the above function:

<pre class="lang-c prettyprint-override"><code>#include &lt;stdio.h&gt;
#include &lt;sys/time.h&gt;

double now()
{
 struct timeval tv;
 gettimeofday(&amp;tv, NULL);
 return tv.tv_sec + (double) tv.tv_usec / 1e6;
}

struct tt_ctx {
 double start;
 double limit;
};

bool test_time_limit(void *arg)
{
 struct tt_ctx *ctx = arg;
 return now() - ctx-&gt;start &lt;= ctx-&gt;limit;
}

int main(int argc, char **argv)
{
 int limit = atoi(argv[1]);
 struct tt_ctx ctx;
 ctx.start = now();
 ctx.limit = limit / 1000.0;

 RSA *key = my_generate_key(4096, 65537, test_time_limit, &amp;ctx);
 printf("%p\n", key);
 return 0;
}
</code></pre>

The test program assumes POSIX <code>gettimeofday</code>, but can be trivially converted to another high-resolution clock as provided by the system. Test procedure is as follows:

Append both pieces of code to a file and compile with <code>-lrsa</code>. The test program will generate a 4096-bit RSA key within the time limit specified in milliseconds on the command line. In all cases it prints the resulting <code>RSA *</code> pointer to indicate whether <code>my_generate_key</code> completed its request or it was aborted. The output of <code>time</code> accompanies execution as a sanity check to verify that the time limit is being respected:

<pre><code># try with a 10ms limit
$ time ./a.out 10
(nil) # too short
./a.out 10 0.02s user 0.00s system 85% cpu 0.023 total

# see if 100ms is enough time
$ time ./a.out 100
(nil) # still too short
./a.out 100 0.10s user 0.00s system 97% cpu 0.106 total

# try with 1 whole second:
$ time ./a.out 1000
0x2369010 # success!
./a.out 1000 0.64s user 0.00s system 99% cpu 0.649 total
</code></pre>

Consider the following invocation of <code>RSA_generate_key()</code>:

<pre><code>RSA * rsa = RSA_generate_key(8192, RSA_F4, NULL, NULL);
</code></pre>

Generating an 8,192-bit RSA key can take a long time (anywhere from a few seconds to a few minutes). Suppose the application containing the line of code above offers the user a button that will cancel the key generation.

How can I abort the computation and make the function return before the key has been generated? I remember the third argument to <code>RSA_generate_key()</code> is a callback function used for displaying progress - is there any way that callback could return a value that means "abort the operation and return"?

Running the function in another thread and then terminating the thread is not an option.

How to abort RSA_generate_key?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

考虑下面的RSA_generate_key()调用RSA * rsa = RSA_generate_key(8192, RSA_F4, NULL, NULL);生成8,192位RSA密钥可能需要很长时间(从几秒钟到几分钟不等)。假设包含上述代码行的应用程序为用户提供了一个取消密钥生成的按钮。如何在密钥生成之前中止计算并...

问如何中止RSA_generate_key？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何中止RSA_generate_key？EN