File: C:/Ruby27-x64/share/doc/ruby/html/OpenSSL/PKey/DSA.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>class OpenSSL::PKey::DSA - RDoc Documentation</title>
<script type="text/javascript">
var rdoc_rel_prefix = "../../";
var index_rel_prefix = "../../";
</script>
<script src="../../js/navigation.js" defer></script>
<script src="../../js/search.js" defer></script>
<script src="../../js/search_index.js" defer></script>
<script src="../../js/searcher.js" defer></script>
<script src="../../js/darkfish.js" defer></script>
<link href="../../css/fonts.css" rel="stylesheet">
<link href="../../css/rdoc.css" rel="stylesheet">
<body id="top" role="document" class="class">
<nav role="navigation">
<div id="project-navigation">
<div id="home-section" role="region" title="Quick navigation" class="nav-section">
<h2>
<a href="../../index.html" rel="home">Home</a>
</h2>
<div id="table-of-contents-navigation">
<a href="../../table_of_contents.html#pages">Pages</a>
<a href="../../table_of_contents.html#classes">Classes</a>
<a href="../../table_of_contents.html#methods">Methods</a>
</div>
</div>
<div id="search-section" role="search" class="project-section initially-hidden">
<form action="#" method="get" accept-charset="utf-8">
<div id="search-field-wrapper">
<input id="search-field" role="combobox" aria-label="Search"
aria-autocomplete="list" aria-controls="search-results"
type="text" name="search" placeholder="Search" spellcheck="false"
title="Type to search, Up and Down to navigate, Enter to load">
</div>
<ul id="search-results" aria-label="Search Results"
aria-busy="false" aria-expanded="false"
aria-atomic="false" class="initially-hidden"></ul>
</form>
</div>
</div>
<div id="class-metadata">
<div id="parent-class-section" class="nav-section">
<h3>Parent</h3>
<p class="link"><a href="PKey.html">OpenSSL::PKey::PKey</a>
</div>
<!-- Method Quickref -->
<div id="method-list-section" class="nav-section">
<h3>Methods</h3>
<ul class="link-list" role="directory">
<li ><a href="#method-c-generate">::generate</a>
<li ><a href="#method-c-new">::new</a>
<li ><a href="#method-i-export">#export</a>
<li ><a href="#method-i-initialize_copy">#initialize_copy</a>
<li ><a href="#method-i-params">#params</a>
<li ><a href="#method-i-private-3F">#private?</a>
<li ><a href="#method-i-public-3F">#public?</a>
<li ><a href="#method-i-public_key">#public_key</a>
<li ><a href="#method-i-set_key">#set_key</a>
<li ><a href="#method-i-set_pqg">#set_pqg</a>
<li ><a href="#method-i-syssign">#syssign</a>
<li ><a href="#method-i-sysverify">#sysverify</a>
<li ><a href="#method-i-to_der">#to_der</a>
<li ><a href="#method-i-to_pem">#to_pem</a>
<li ><a href="#method-i-to_s">#to_s</a>
<li ><a href="#method-i-to_text">#to_text</a>
</ul>
</div>
</div>
</nav>
<main role="main" aria-labelledby="class-OpenSSL::PKey::DSA">
<h1 id="class-OpenSSL::PKey::DSA" class="class">
class OpenSSL::PKey::DSA
</h1>
<section class="description">
<p><a href="DSA.html"><code>DSA</code></a>, the Digital Signature Algorithm, is specified in NIST's FIPS 186-3. It is an asymmetric public key algorithm that may be used similar to e.g. <a href="RSA.html"><code>RSA</code></a>.</p>
</section>
<section id="5Buntitled-5D" class="documentation-section">
<section id="public-class-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Class Methods</h3>
</header>
<div id="method-c-generate" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
generate(size) → dsa
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Creates a new <a href="DSA.html"><code>DSA</code></a> instance by generating a private/public key pair from scratch.</p>
<h3 id="method-c-generate-label-Parameters">Parameters<span><a href="#method-c-generate-label-Parameters">¶</a> <a href="#top">↑</a></span></h3>
<ul><li>
<p><em>size</em> is an integer representing the desired key size.</p>
</li></ul>
<div class="method-source-code" id="generate-source">
<pre>static VALUE
ossl_dsa_s_generate(VALUE klass, VALUE size)
{
DSA *dsa = dsa_generate(NUM2INT(size)); /* err handled by dsa_instance */
VALUE obj = dsa_instance(klass, dsa);
if (obj == Qfalse) {
DSA_free(dsa);
ossl_raise(eDSAError, NULL);
}
return obj;
}</pre>
</div>
</div>
</div>
<div id="method-c-new" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
new → dsa
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
new(size) → dsa
</span>
</div>
<div class="method-heading">
<span class="method-callseq">
new(string [, pass]) → dsa
</span>
</div>
<div class="method-description">
<p>Creates a new <a href="DSA.html"><code>DSA</code></a> instance by reading an existing key from <em>string</em>.</p>
<h3 id="method-c-new-label-Parameters">Parameters<span><a href="#method-c-new-label-Parameters">¶</a> <a href="#top">↑</a></span></h3>
<ul><li>
<p><em>size</em> is an integer representing the desired key size.</p>
</li><li>
<p><em>string</em> contains a DER or PEM encoded key.</p>
</li><li>
<p><em>pass</em> is a string that contains an optional password.</p>
</li></ul>
<h3 id="method-c-new-label-Examples">Examples<span><a href="#method-c-new-label-Examples">¶</a> <a href="#top">↑</a></span></h3>
<pre>DSA.new -> dsa
DSA.new(1024) -> dsa
DSA.new(File.read('dsa.pem')) -> dsa
DSA.new(File.read('dsa.pem'), 'mypassword') -> dsa</pre>
<div class="method-source-code" id="new-source">
<pre>static VALUE
ossl_dsa_initialize(int argc, VALUE *argv, VALUE self)
{
EVP_PKEY *pkey;
DSA *dsa;
BIO *in;
VALUE arg, pass;
GetPKey(self, pkey);
if(rb_scan_args(argc, argv, "02", &arg, &pass) == 0) {
dsa = DSA_new();
}
else if (RB_INTEGER_TYPE_P(arg)) {
if (!(dsa = dsa_generate(NUM2INT(arg)))) {
ossl_raise(eDSAError, NULL);
}
}
else {
pass = ossl_pem_passwd_value(pass);
arg = ossl_to_der_if_possible(arg);
in = ossl_obj2bio(&arg);
dsa = PEM_read_bio_DSAPrivateKey(in, NULL, ossl_pem_passwd_cb, (void *)pass);
if (!dsa) {
OSSL_BIO_reset(in);
dsa = PEM_read_bio_DSA_PUBKEY(in, NULL, NULL, NULL);
}
if (!dsa) {
OSSL_BIO_reset(in);
dsa = d2i_DSAPrivateKey_bio(in, NULL);
}
if (!dsa) {
OSSL_BIO_reset(in);
dsa = d2i_DSA_PUBKEY_bio(in, NULL);
}
if (!dsa) {
OSSL_BIO_reset(in);
#define PEM_read_bio_DSAPublicKey(bp,x,cb,u) (DSA *)PEM_ASN1_read_bio( \
(d2i_of_void *)d2i_DSAPublicKey, PEM_STRING_DSA_PUBLIC, (bp), (void **)(x), (cb), (u))
dsa = PEM_read_bio_DSAPublicKey(in, NULL, NULL, NULL);
#undef PEM_read_bio_DSAPublicKey
}
BIO_free(in);
if (!dsa) {
ossl_clear_error();
ossl_raise(eDSAError, "Neither PUB key nor PRIV key");
}
}
if (!EVP_PKEY_assign_DSA(pkey, dsa)) {
DSA_free(dsa);
ossl_raise(eDSAError, NULL);
}
return self;
}</pre>
</div>
</div>
</div>
</section>
<section id="public-instance-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Instance Methods</h3>
</header>
<div id="method-i-export" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
export([cipher, password]) → aString
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
to_pem([cipher, password]) → aString
</span>
</div>
<div class="method-heading">
<span class="method-callseq">
to_s([cipher, password]) → aString
</span>
</div>
<div class="method-description">
<p>Encodes this <a href="DSA.html"><code>DSA</code></a> to its PEM encoding.</p>
<h3 id="method-i-export-label-Parameters">Parameters<span><a href="#method-i-export-label-Parameters">¶</a> <a href="#top">↑</a></span></h3>
<ul><li>
<p><em>cipher</em> is an <a href="../Cipher.html"><code>OpenSSL::Cipher</code></a>.</p>
</li><li>
<p><em>password</em> is a string containing your password.</p>
</li></ul>
<h3 id="method-i-export-label-Examples">Examples<span><a href="#method-i-export-label-Examples">¶</a> <a href="#top">↑</a></span></h3>
<pre>DSA.to_pem -> aString
DSA.to_pem(cipher, 'mypassword') -> aString</pre>
<div class="method-source-code" id="export-source">
<pre>static VALUE
ossl_dsa_export(int argc, VALUE *argv, VALUE self)
{
DSA *dsa;
BIO *out;
const EVP_CIPHER *ciph = NULL;
VALUE cipher, pass, str;
GetDSA(self, dsa);
rb_scan_args(argc, argv, "02", &cipher, &pass);
if (!NIL_P(cipher)) {
ciph = ossl_evp_get_cipherbyname(cipher);
pass = ossl_pem_passwd_value(pass);
}
if (!(out = BIO_new(BIO_s_mem()))) {
ossl_raise(eDSAError, NULL);
}
if (DSA_HAS_PRIVATE(dsa)) {
if (!PEM_write_bio_DSAPrivateKey(out, dsa, ciph, NULL, 0,
ossl_pem_passwd_cb, (void *)pass)){
BIO_free(out);
ossl_raise(eDSAError, NULL);
}
} else {
if (!PEM_write_bio_DSA_PUBKEY(out, dsa)) {
BIO_free(out);
ossl_raise(eDSAError, NULL);
}
}
str = ossl_membio2str(out);
return str;
}</pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="DSA.html#method-i-to_pem">to_pem</a>, <a href="DSA.html#method-i-to_s">to_s</a>
</div>
</div>
<div id="method-i-initialize_copy" class="method-detail ">
<div class="method-heading">
<span class="method-name">initialize_copy</span><span
class="method-args">(p1)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="initialize_copy-source">
<pre>static VALUE
ossl_dsa_initialize_copy(VALUE self, VALUE other)
{
EVP_PKEY *pkey;
DSA *dsa, *dsa_new;
GetPKey(self, pkey);
if (EVP_PKEY_base_id(pkey) != EVP_PKEY_NONE)
ossl_raise(eDSAError, "DSA already initialized");
GetDSA(other, dsa);
dsa_new = ASN1_dup((i2d_of_void *)i2d_DSAPrivateKey, (d2i_of_void *)d2i_DSAPrivateKey, (char *)dsa);
if (!dsa_new)
ossl_raise(eDSAError, "ASN1_dup");
EVP_PKEY_assign_DSA(pkey, dsa_new);
return self;
}</pre>
</div>
</div>
</div>
<div id="method-i-params" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
params → hash
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Stores all parameters of key to the hash INSECURE: PRIVATE INFORMATIONS CAN LEAK OUT!!! Don't use :-)) (I's up to you)</p>
<div class="method-source-code" id="params-source">
<pre>static VALUE
ossl_dsa_get_params(VALUE self)
{
DSA *dsa;
VALUE hash;
const BIGNUM *p, *q, *g, *pub_key, *priv_key;
GetDSA(self, dsa);
DSA_get0_pqg(dsa, &p, &q, &g);
DSA_get0_key(dsa, &pub_key, &priv_key);
hash = rb_hash_new();
rb_hash_aset(hash, rb_str_new2("p"), ossl_bn_new(p));
rb_hash_aset(hash, rb_str_new2("q"), ossl_bn_new(q));
rb_hash_aset(hash, rb_str_new2("g"), ossl_bn_new(g));
rb_hash_aset(hash, rb_str_new2("pub_key"), ossl_bn_new(pub_key));
rb_hash_aset(hash, rb_str_new2("priv_key"), ossl_bn_new(priv_key));
return hash;
}</pre>
</div>
</div>
</div>
<div id="method-i-private-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
private? → true | false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Indicates whether this <a href="DSA.html"><code>DSA</code></a> instance has a private key associated with it or not. The private key may be retrieved with DSA#private_key.</p>
<div class="method-source-code" id="private-3F-source">
<pre>static VALUE
ossl_dsa_is_private(VALUE self)
{
DSA *dsa;
GetDSA(self, dsa);
return DSA_PRIVATE(self, dsa) ? Qtrue : Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-public-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
public? → true | false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Indicates whether this <a href="DSA.html"><code>DSA</code></a> instance has a public key associated with it or not. The public key may be retrieved with <a href="DSA.html#method-i-public_key"><code>DSA#public_key</code></a>.</p>
<div class="method-source-code" id="public-3F-source">
<pre>static VALUE
ossl_dsa_is_public(VALUE self)
{
DSA *dsa;
const BIGNUM *bn;
GetDSA(self, dsa);
DSA_get0_key(dsa, &bn, NULL);
return bn ? Qtrue : Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-public_key" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
public_key → aDSA
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a new <a href="DSA.html"><code>DSA</code></a> instance that carries just the public key information. If the current instance has also private key information, this will no longer be present in the new instance. This feature is helpful for publishing the public key information without leaking any of the private information.</p>
<h3 id="method-i-public_key-label-Example">Example<span><a href="#method-i-public_key-label-Example">¶</a> <a href="#top">↑</a></span></h3>
<pre class="ruby"><span class="ruby-identifier">dsa</span> = <span class="ruby-constant">OpenSSL</span><span class="ruby-operator">::</span><span class="ruby-constant">PKey</span><span class="ruby-operator">::</span><span class="ruby-constant">DSA</span>.<span class="ruby-identifier">new</span>(<span class="ruby-value">2048</span>) <span class="ruby-comment"># has public and private information</span>
<span class="ruby-identifier">pub_key</span> = <span class="ruby-identifier">dsa</span>.<span class="ruby-identifier">public_key</span> <span class="ruby-comment"># has only the public part available</span>
<span class="ruby-identifier">pub_key_der</span> = <span class="ruby-identifier">pub_key</span>.<span class="ruby-identifier">to_der</span> <span class="ruby-comment"># it's safe to publish this</span>
</pre>
<div class="method-source-code" id="public_key-source">
<pre>static VALUE
ossl_dsa_to_public_key(VALUE self)
{
EVP_PKEY *pkey;
DSA *dsa;
VALUE obj;
GetPKeyDSA(self, pkey);
/* err check performed by dsa_instance */
#define DSAPublicKey_dup(dsa) (DSA *)ASN1_dup( \
(i2d_of_void *)i2d_DSAPublicKey, (d2i_of_void *)d2i_DSAPublicKey, (char *)(dsa))
dsa = DSAPublicKey_dup(EVP_PKEY_get0_DSA(pkey));
#undef DSAPublicKey_dup
obj = dsa_instance(rb_obj_class(self), dsa);
if (obj == Qfalse) {
DSA_free(dsa);
ossl_raise(eDSAError, NULL);
}
return obj;
}</pre>
</div>
</div>
</div>
<div id="method-i-set_key" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
set_key(pub_key, priv_key) → self
</span>
</div>
<div class="method-description">
<p>Sets <em>pub_key</em> and <em>priv_key</em> for the <a href="DSA.html"><code>DSA</code></a> instance. <em>priv_key</em> may be <code>nil</code>.</p>
</div>
</div>
<div id="method-i-set_pqg" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
set_pqg(p, q, g) → self
</span>
</div>
<div class="method-description">
<p>Sets <em>p</em>, <em>q</em>, <em>g</em> to the <a href="DSA.html"><code>DSA</code></a> instance.</p>
</div>
</div>
<div id="method-i-syssign" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
syssign(string) → aString
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Computes and returns the <a href="DSA.html"><code>DSA</code></a> signature of <em>string</em>, where <em>string</em> is expected to be an already-computed message digest of the original input data. The signature is issued using the private key of this <a href="DSA.html"><code>DSA</code></a> instance.</p>
<h3 id="method-i-syssign-label-Parameters">Parameters<span><a href="#method-i-syssign-label-Parameters">¶</a> <a href="#top">↑</a></span></h3>
<ul><li>
<p><em>string</em> is a message digest of the original input data to be signed.</p>
</li></ul>
<h3 id="method-i-syssign-label-Example">Example<span><a href="#method-i-syssign-label-Example">¶</a> <a href="#top">↑</a></span></h3>
<pre class="ruby"><span class="ruby-identifier">dsa</span> = <span class="ruby-constant">OpenSSL</span><span class="ruby-operator">::</span><span class="ruby-constant">PKey</span><span class="ruby-operator">::</span><span class="ruby-constant">DSA</span>.<span class="ruby-identifier">new</span>(<span class="ruby-value">2048</span>)
<span class="ruby-identifier">doc</span> = <span class="ruby-string">"Sign me"</span>
<span class="ruby-identifier">digest</span> = <span class="ruby-constant">OpenSSL</span><span class="ruby-operator">::</span><span class="ruby-constant">Digest</span><span class="ruby-operator">::</span><span class="ruby-constant">SHA1</span>.<span class="ruby-identifier">digest</span>(<span class="ruby-identifier">doc</span>)
<span class="ruby-identifier">sig</span> = <span class="ruby-identifier">dsa</span>.<span class="ruby-identifier">syssign</span>(<span class="ruby-identifier">digest</span>)
</pre>
<div class="method-source-code" id="syssign-source">
<pre>static VALUE
ossl_dsa_sign(VALUE self, VALUE data)
{
DSA *dsa;
const BIGNUM *dsa_q;
unsigned int buf_len;
VALUE str;
GetDSA(self, dsa);
DSA_get0_pqg(dsa, NULL, &dsa_q, NULL);
if (!dsa_q)
ossl_raise(eDSAError, "incomplete DSA");
if (!DSA_PRIVATE(self, dsa))
ossl_raise(eDSAError, "Private DSA key needed!");
StringValue(data);
str = rb_str_new(0, DSA_size(dsa));
if (!DSA_sign(0, (unsigned char *)RSTRING_PTR(data), RSTRING_LENINT(data),
(unsigned char *)RSTRING_PTR(str),
&buf_len, dsa)) { /* type is ignored (0) */
ossl_raise(eDSAError, NULL);
}
rb_str_set_len(str, buf_len);
return str;
}</pre>
</div>
</div>
</div>
<div id="method-i-sysverify" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
sysverify(digest, sig) → true | false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Verifies whether the signature is valid given the message digest input. It does so by validating <em>sig</em> using the public key of this <a href="DSA.html"><code>DSA</code></a> instance.</p>
<h3 id="method-i-sysverify-label-Parameters">Parameters<span><a href="#method-i-sysverify-label-Parameters">¶</a> <a href="#top">↑</a></span></h3>
<ul><li>
<p><em>digest</em> is a message digest of the original input data to be signed</p>
</li><li>
<p><em>sig</em> is a <a href="DSA.html"><code>DSA</code></a> signature value</p>
</li></ul>
<h3 id="method-i-sysverify-label-Example">Example<span><a href="#method-i-sysverify-label-Example">¶</a> <a href="#top">↑</a></span></h3>
<pre class="ruby"><span class="ruby-identifier">dsa</span> = <span class="ruby-constant">OpenSSL</span><span class="ruby-operator">::</span><span class="ruby-constant">PKey</span><span class="ruby-operator">::</span><span class="ruby-constant">DSA</span>.<span class="ruby-identifier">new</span>(<span class="ruby-value">2048</span>)
<span class="ruby-identifier">doc</span> = <span class="ruby-string">"Sign me"</span>
<span class="ruby-identifier">digest</span> = <span class="ruby-constant">OpenSSL</span><span class="ruby-operator">::</span><span class="ruby-constant">Digest</span><span class="ruby-operator">::</span><span class="ruby-constant">SHA1</span>.<span class="ruby-identifier">digest</span>(<span class="ruby-identifier">doc</span>)
<span class="ruby-identifier">sig</span> = <span class="ruby-identifier">dsa</span>.<span class="ruby-identifier">syssign</span>(<span class="ruby-identifier">digest</span>)
<span class="ruby-identifier">puts</span> <span class="ruby-identifier">dsa</span>.<span class="ruby-identifier">sysverify</span>(<span class="ruby-identifier">digest</span>, <span class="ruby-identifier">sig</span>) <span class="ruby-comment"># => true</span>
</pre>
<div class="method-source-code" id="sysverify-source">
<pre>static VALUE
ossl_dsa_verify(VALUE self, VALUE digest, VALUE sig)
{
DSA *dsa;
int ret;
GetDSA(self, dsa);
StringValue(digest);
StringValue(sig);
/* type is ignored (0) */
ret = DSA_verify(0, (unsigned char *)RSTRING_PTR(digest), RSTRING_LENINT(digest),
(unsigned char *)RSTRING_PTR(sig), RSTRING_LENINT(sig), dsa);
if (ret < 0) {
ossl_raise(eDSAError, NULL);
}
else if (ret == 1) {
return Qtrue;
}
return Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-to_der" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_der → aString
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Encodes this <a href="DSA.html"><code>DSA</code></a> to its DER encoding.</p>
<div class="method-source-code" id="to_der-source">
<pre>static VALUE
ossl_dsa_to_der(VALUE self)
{
DSA *dsa;
int (*i2d_func)(DSA *, unsigned char **);
unsigned char *p;
long len;
VALUE str;
GetDSA(self, dsa);
if(DSA_HAS_PRIVATE(dsa))
i2d_func = (int (*)(DSA *,unsigned char **))i2d_DSAPrivateKey;
else
i2d_func = i2d_DSA_PUBKEY;
if((len = i2d_func(dsa, NULL)) <= 0)
ossl_raise(eDSAError, NULL);
str = rb_str_new(0, len);
p = (unsigned char *)RSTRING_PTR(str);
if(i2d_func(dsa, &p) < 0)
ossl_raise(eDSAError, NULL);
ossl_str_adjust(str, p);
return str;
}</pre>
</div>
</div>
</div>
<div id="method-i-to_pem" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">to_pem</span><span
class="method-args">(p1 = v1, p2 = v2)</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="DSA.html#method-i-export">export</a>
</div>
</div>
<div id="method-i-to_s" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">to_s</span><span
class="method-args">(p1 = v1, p2 = v2)</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="DSA.html#method-i-export">export</a>
</div>
</div>
<div id="method-i-to_text" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_text → aString
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Prints all parameters of key to buffer INSECURE: PRIVATE INFORMATIONS CAN LEAK OUT!!! Don't use :-)) (I's up to you)</p>
<div class="method-source-code" id="to_text-source">
<pre>static VALUE
ossl_dsa_to_text(VALUE self)
{
DSA *dsa;
BIO *out;
VALUE str;
GetDSA(self, dsa);
if (!(out = BIO_new(BIO_s_mem()))) {
ossl_raise(eDSAError, NULL);
}
if (!DSA_print(out, dsa, 0)) { /* offset = 0 */
BIO_free(out);
ossl_raise(eDSAError, NULL);
}
str = ossl_membio2str(out);
return str;
}</pre>
</div>
</div>
</div>
</section>
</section>
</main>
<footer id="validator-badges" role="contentinfo">
<p><a href="https://validator.w3.org/check/referer">Validate</a>
<p>Generated by <a href="https://ruby.github.io/rdoc/">RDoc</a> 6.2.1.1.
<p>Based on <a href="http://deveiate.org/projects/Darkfish-RDoc/">Darkfish</a> by <a href="http://deveiate.org">Michael Granger</a>.
</footer>