#use wml::openssl-macros area=docs page=EVP_PKEY_verifyrecover

<title>Documents, EVP_PKEY_verifyrecover(3)</title>

<h1>EVP_PKEY_verifyrecover(3)</h1>

#use wml::imp::generic

{:
## What's this? [[s|(<STRONG>[^<].+?)</A>(</STRONG><DD>)|$1$2|sg]]
[[s|<P>\s+<P>|<P>|sg]]
[[s|<P>\s+</|</|sg]]
[[s|<DD>\s*<DT>|<DD>&nbsp;<DT>|sg]]
[[s|<DD>\s*</DL>|<DD>&nbsp;</DL>|sg]]
[[s|\[|&#91;|sg]]
[[s|\]|&#93;|sg]]

<!-- INDEX BEGIN -->

<UL>

	<LI><A HREF="#NAME">NAME</A>
	<LI><A HREF="#SYNOPSIS">SYNOPSIS</A>
	<LI><A HREF="#DESCRIPTION">DESCRIPTION</A>
	<LI><A HREF="#NOTES">NOTES</A>
	<LI><A HREF="#RETURN_VALUES">RETURN VALUES</A>
	<LI><A HREF="#EXAMPLE">EXAMPLE</A>
	<LI><A HREF="#SEE_ALSO">SEE ALSO</A>
	<LI><A HREF="#HISTORY">HISTORY</A>
</UL>
<!-- INDEX END -->

<HR>
<P>
<HR>
<H1><A NAME="NAME">NAME</A></H1>
<P>
EVP_PKEY_verifyrecover_init, EVP_PKEY_verifyrecover - recover signature
using a public key algorithm

</P>
<P>
<HR>
<H1><A NAME="SYNOPSIS">SYNOPSIS</A></H1>
<PRE> #include &lt;openssl/evp.h&gt;
</PRE>
<PRE> int EVP_PKEY_verifyrecover_init(EVP_PKEY_CTX *ctx);
 int EVP_PKEY_verifyrecover(EVP_PKEY_CTX *ctx,
                        unsigned char *rout, size_t *routlen,
                        const unsigned char *sig, size_t siglen);
</PRE>
<P>
<HR>
<H1><A NAME="DESCRIPTION">DESCRIPTION</A></H1>
<P>
The <CODE>EVP_PKEY_verifyrecover_init()</CODE> function initializes a
public key algorithm context using key <STRONG>pkey</STRONG> for a verify recover operation.

</P>
<P>
The <CODE>EVP_PKEY_verifyrecover()</CODE> function recovers signed data
using <STRONG>ctx</STRONG>. The signature is specified using the <STRONG>sig</STRONG> and
<STRONG>siglen</STRONG> parameters. If <STRONG>rout</STRONG> is <STRONG>NULL</STRONG> then the maximum size of the output buffer is written to the <STRONG>routlen</STRONG> parameter. If <STRONG>rout</STRONG> is not <STRONG>NULL</STRONG> then before the call the <STRONG>routlen</STRONG> parameter should contain the length of the
<STRONG>rout</STRONG> buffer, if the call is successful recovered data is written to
<STRONG>rout</STRONG> and the amount of data written to <STRONG>routlen</STRONG>.

</P>
<P>
<HR>
<H1><A NAME="NOTES">NOTES</A></H1>
<P>
Normally an application is only interested in whether a signature
verification operation is successful in those cases the
<CODE>EVP_verify()</CODE> function should be used.

</P>
<P>
Sometimes however it is useful to obtain the data originally signed using a
signing operation. Only certain public key algorithms can recover a
signature in this way (for example RSA in PKCS padding mode).

</P>
<P>
After the call to <CODE>EVP_PKEY_verifyrecover_init()</CODE> algorithm
specific control operations can be performed to set any appropriate
parameters for the operation.

</P>
<P>
The function <CODE>EVP_PKEY_verifyrecover()</CODE> can be called more than
once on the same context if several operations are performed using the same
parameters.

</P>
<P>
<HR>
<H1><A NAME="RETURN_VALUES">RETURN VALUES</A></H1>
<P>
<CODE>EVP_PKEY_verifyrecover_init()</CODE> and
<CODE>EVP_PKEY_verifyrecover()</CODE> return 1 for success and 0 or a
negative value for failure. In particular a return value of -2 indicates
the operation is not supported by the public key algorithm.

</P>
<P>
<HR>
<H1><A NAME="EXAMPLE">EXAMPLE</A></H1>
<P>
Recover digest originally signed using PKCS#1 and SHA256 digest:

</P>
<PRE> #include &lt;openssl/evp.h&gt;
 \#include &lt;openssl/rsa.h&gt;
</PRE>
<PRE> EVP_PKEY_CTX *ctx;
 unsigned char *rout, *sig;
 size_t routlen, siglen; 
 EVP_PKEY *verify_key;
 /* NB: assumes verify_key, sig and siglen are already set up
  * and that verify_key is an RSA public key
  */
 ctx = EVP_PKEY_CTX_new(verify_key);
 if (!ctx)
        /* Error occurred */
 if (EVP_PKEY_verifyrecover_init(ctx) &lt;= 0)
        /* Error */
 if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) &lt;= 0)
        /* Error */
 if (EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()) &lt;= 0)
        /* Error */
</PRE>
<PRE> /* Determine buffer length */
 if (EVP_PKEY_verifyrecover(ctx, NULL, &amp;routlen, sig, siglen) &lt;= 0)
        /* Error */
</PRE>
<PRE> rout = OPENSSL_malloc(routlen);
</PRE>
<PRE> if (!rout)
        /* malloc failure */
 
 if (EVP_PKEY_verifyrecover(ctx, rout, &amp;routlen, sig, siglen) &lt;= 0)
        /* Error */
</PRE>
<PRE> /* Recovered data is routlen bytes written to buffer rout */
</PRE>
<P>
<HR>
<H1><A NAME="SEE_ALSO">SEE ALSO</A></H1>
<P>
<A HREF="../crypto/EVP_PKEY_CTX_new.html#">EVP_PKEY_CTX_new(3)</A>,
<A HREF="../crypto/EVP_PKEY_encrypt.html#">EVP_PKEY_encrypt(3)</A>,
<A HREF="../crypto/EVP_PKEY_decrypt.html#">EVP_PKEY_decrypt(3)</A>,
<A HREF="../crypto/EVP_PKEY_sign.html#">EVP_PKEY_sign(3)</A>,
<A HREF="../crypto/EVP_PKEY_verify.html#">EVP_PKEY_verify(3)</A>,
<A HREF="../crypto/EVP_PKEY_derive.html#">EVP_PKEY_derive(3)</A> 

 

</P>
<P>
<HR>
<H1><A NAME="HISTORY">HISTORY</A></H1>
<P>
These functions were first added to OpenSSL 1.0.0.

</P>
:}