In Files

  • openssl/ossl_pkey.c

Class/Module Index [+]

Quicksearch

OpenSSL::PKey::DSA

Public Class Methods

generate(size) → dsa click to toggle source

Parameters ↑

  • size is an integer representing the desired key size.

 
               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;
}
new([size | string [, pass]) → dsa click to toggle source

Parameters ↑

  • size is an integer representing the desired key size.

  • string contains a DER or PEM encoded key.

  • pass is a string that contains a optional password.

Examples ↑

  • ::new -> dsa

  • ::new -> dsa

  • ::new(File.read('dsa.pem')) -> dsa

  • ::new(File.read('dsa.pem'), 'mypassword') -> dsa

 
               static VALUE
ossl_dsa_initialize(int argc, VALUE *argv, VALUE self)
{
    EVP_PKEY *pkey;
    DSA *dsa;
    BIO *in;
    char *passwd = NULL;
    VALUE arg, pass;
        
    GetPKey(self, pkey);
    if(rb_scan_args(argc, argv, "02", &arg, &pass) == 0) {
        dsa = DSA_new();
    }
    else if (FIXNUM_P(arg)) {
        if (!(dsa = dsa_generate(FIX2INT(arg)))) {
            ossl_raise(eDSAError, NULL);
        }
    }
    else {
        if (!NIL_P(pass)) passwd = StringValuePtr(pass);
        arg = ossl_to_der_if_possible(arg);
        in = ossl_obj2bio(arg);
        dsa = PEM_read_bio_DSAPrivateKey(in, NULL, ossl_pem_passwd_cb, passwd);
        if (!dsa) {
            (void)BIO_reset(in);
            dsa = PEM_read_bio_DSAPublicKey(in, NULL, NULL, NULL);
        }
        if (!dsa) {
            (void)BIO_reset(in);
            dsa = PEM_read_bio_DSA_PUBKEY(in, NULL, NULL, NULL);
        }
        if (!dsa) {
            (void)BIO_reset(in);
            dsa = d2i_DSAPrivateKey_bio(in, NULL);
        }
        if (!dsa) {
            (void)BIO_reset(in);
            dsa = d2i_DSA_PUBKEY_bio(in, NULL);
        }
        BIO_free(in);
        if (!dsa) 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;
}

Public Instance Methods

to_pem([cipher, password]) → aString click to toggle source

Parameters ↑

cipher is an OpenSSL::Cipher. password is a string containing your password.

Examples ↑

 
               static VALUE
ossl_dsa_export(int argc, VALUE *argv, VALUE self)
{
    EVP_PKEY *pkey;
    BIO *out;
    const EVP_CIPHER *ciph = NULL;
    char *passwd = NULL;
    VALUE cipher, pass, str;

    GetPKeyDSA(self, pkey);
    rb_scan_args(argc, argv, "02", &cipher, &pass);
    if (!NIL_P(cipher)) {
        ciph = GetCipherPtr(cipher);
        if (!NIL_P(pass)) {
            passwd = StringValuePtr(pass);
        }
    }
    if (!(out = BIO_new(BIO_s_mem()))) {
        ossl_raise(eDSAError, NULL);
    }
    if (DSA_HAS_PRIVATE(pkey->pkey.dsa)) {
        if (!PEM_write_bio_DSAPrivateKey(out, pkey->pkey.dsa, ciph,
                                         NULL, 0, ossl_pem_passwd_cb, passwd)){
            BIO_free(out);
            ossl_raise(eDSAError, NULL);
        }
    } else {
        if (!PEM_write_bio_DSAPublicKey(out, pkey->pkey.dsa)) {
            BIO_free(out);
            ossl_raise(eDSAError, NULL);
        }
    }
    str = ossl_membio2str(out);

    return str;
}
Also aliased as: to_pem, to_s
params → hash click to toggle source

Stores all parameters of key to the hash INSECURE: PRIVATE INFORMATIONS CAN LEAK OUT!!! Don’t use :-)) (I’s up to you)

 
               static VALUE
ossl_dsa_get_params(VALUE self)
{
    EVP_PKEY *pkey;
    VALUE hash;

    GetPKeyDSA(self, pkey);

    hash = rb_hash_new();

    rb_hash_aset(hash, rb_str_new2("p"), ossl_bn_new(pkey->pkey.dsa->p));
    rb_hash_aset(hash, rb_str_new2("q"), ossl_bn_new(pkey->pkey.dsa->q));
    rb_hash_aset(hash, rb_str_new2("g"), ossl_bn_new(pkey->pkey.dsa->g));
    rb_hash_aset(hash, rb_str_new2("pub_key"), ossl_bn_new(pkey->pkey.dsa->pub_key));
    rb_hash_aset(hash, rb_str_new2("priv_key"), ossl_bn_new(pkey->pkey.dsa->priv_key));
    
    return hash;
}
private? → true | false click to toggle source 
 
               static VALUE
ossl_dsa_is_private(VALUE self)
{
    EVP_PKEY *pkey;
        
    GetPKeyDSA(self, pkey);
        
    return (DSA_PRIVATE(self, pkey->pkey.dsa)) ? Qtrue : Qfalse;
}
public? → true | false click to toggle source 
 
               static VALUE
ossl_dsa_is_public(VALUE self)
{
    EVP_PKEY *pkey;

    GetPKeyDSA(self, pkey);

    return (pkey->pkey.dsa->pub_key) ? Qtrue : Qfalse;
}
public_key → aDSA click to toggle source

Makes new instance DSA PUBLIC_KEY from PRIVATE_KEY

 
               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 */
    dsa = DSAPublicKey_dup(pkey->pkey.dsa);
    obj = dsa_instance(CLASS_OF(self), dsa);
    if (obj == Qfalse) {
        DSA_free(dsa);
        ossl_raise(eDSAError, NULL);
    }
    return obj;
}
syssign(string) → aString click to toggle source 
 
               static VALUE
ossl_dsa_sign(VALUE self, VALUE data)
{
    EVP_PKEY *pkey;
    unsigned int buf_len;
    VALUE str;

    GetPKeyDSA(self, pkey);
    StringValue(data);
    if (!DSA_PRIVATE(self, pkey->pkey.dsa)) {
        ossl_raise(eDSAError, "Private DSA key needed!");
    }
    str = rb_str_new(0, ossl_dsa_buf_size(pkey));
    if (!DSA_sign(0, (unsigned char *)RSTRING_PTR(data), RSTRING_LEN(data),
                  (unsigned char *)RSTRING_PTR(str),
                  &buf_len, pkey->pkey.dsa)) { /* type is ignored (0) */
        ossl_raise(eDSAError, NULL);
    }
    rb_str_set_len(str, buf_len);

    return str;
}
sysverify(digest, sig) → true | false click to toggle source 
 
               static VALUE
ossl_dsa_verify(VALUE self, VALUE digest, VALUE sig)
{
    EVP_PKEY *pkey;
    int ret;

    GetPKeyDSA(self, pkey);
    StringValue(digest);
    StringValue(sig);
    /* type is ignored (0) */
    ret = DSA_verify(0, (unsigned char *)RSTRING_PTR(digest), RSTRING_LEN(digest),
                     (unsigned char *)RSTRING_PTR(sig), RSTRING_LEN(sig), pkey->pkey.dsa);
    if (ret < 0) {
        ossl_raise(eDSAError, NULL);
    }
    else if (ret == 1) {
        return Qtrue;
    }

    return Qfalse;
}
to_der → aString click to toggle source 
 
               static VALUE
ossl_dsa_to_der(VALUE self)
{
    EVP_PKEY *pkey;
    int (*i2d_func)_((DSA*, unsigned char**));
    unsigned char *p;
    long len;
    VALUE str;

    GetPKeyDSA(self, pkey);
    if(DSA_HAS_PRIVATE(pkey->pkey.dsa))
        i2d_func = (int(*)_((DSA*,unsigned char**)))i2d_DSAPrivateKey;
    else
        i2d_func = i2d_DSA_PUBKEY;
    if((len = i2d_func(pkey->pkey.dsa, NULL)) <= 0)
        ossl_raise(eDSAError, NULL);
    str = rb_str_new(0, len);
    p = (unsigned char *)RSTRING_PTR(str);
    if(i2d_func(pkey->pkey.dsa, &p) < 0)
        ossl_raise(eDSAError, NULL);
    ossl_str_adjust(str, p);

    return str;
}
to_pem(p1 = v1, p2 = v2) click to toggle source
Alias for: export
to_s(p1 = v1, p2 = v2) click to toggle source
Alias for: export
to_text → aString click to toggle source

Prints all parameters of key to buffer INSECURE: PRIVATE INFORMATIONS CAN LEAK OUT!!! Don’t use :-)) (I’s up to you)

 
               static VALUE
ossl_dsa_to_text(VALUE self)
{
    EVP_PKEY *pkey;
    BIO *out;
    VALUE str;

    GetPKeyDSA(self, pkey);
    if (!(out = BIO_new(BIO_s_mem()))) {
        ossl_raise(eDSAError, NULL);
    }
    if (!DSA_print(out, pkey->pkey.dsa, 0)) { /* offset = 0 */
        BIO_free(out);
        ossl_raise(eDSAError, NULL);
    }
    str = ossl_membio2str(out);

    return str;
}

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please see Improve the docs, or visit Documenting-ruby.org.

blog comments powered by Disqus