class OpenSSL::PKey::DSA

Parent:: OpenSSL::PKey::PKey
Included modules:: OpenSSL::Marshal

DSA, алгоритм цифровых подписей, определён в стандарте NIST FIPS 186-3. Это асимметричный алгоритм с открытым ключом, который может использоваться аналогично, например, RSA.

Методы публичного класса

generate(size) → dsa Показать исходный код

# File ext/openssl/lib/openssl/pkey.rb, line 169
def generate(size, &blk)
  # FIPS 186-4 specifies four (L,N) pairs: (1024,160), (2048,224),
  # (2048,256), and (3072,256).
  #
  # q size is derived here with compatibility with
  # DSA_generator_parameters_ex() which previous versions of ruby/openssl
  # used to call.
  qsize = size >= 2048 ? 256 : 160
  dsaparams = OpenSSL::PKey.generate_parameters("DSA", {
    "dsa_paramgen_bits" => size,
    "dsa_paramgen_q_bits" => qsize,
  }, &blk)
  OpenSSL::PKey.generate_key(dsaparams)
end

Создаёт новый экземпляр DSA, сгенерировав пару открытый/закрытый ключ с нуля.

См. также OpenSSL::PKey.generate_parameters и OpenSSL::PKey.generate_key.

size: Требуемый размер ключа в битах.

new → dsa Показать исходный код

new(string [, pass]) → dsa

new(size) → dsa

static VALUE
ossl_dsa_initialize(int argc, VALUE *argv, VALUE self)
{
    EVP_PKEY *pkey;
    DSA *dsa;
    BIO *in = NULL;
    VALUE arg, pass;
    int type;

    TypedData_Get_Struct(self, EVP_PKEY, &ossl_evp_pkey_type, pkey);
    if (pkey)
        rb_raise(rb_eTypeError, "pkey already initialized");

    /* The DSA.new(size, generator) form is handled by lib/openssl/pkey.rb */
    rb_scan_args(argc, argv, "02", &arg, &pass);
    if (argc == 0) {
        dsa = DSA_new();
        if (!dsa)
            ossl_raise(eDSAError, "DSA_new");
        goto legacy;
    }

    pass = ossl_pem_passwd_value(pass);
    arg = ossl_to_der_if_possible(arg);
    in = ossl_obj2bio(&arg);

    /* DER-encoded DSAPublicKey format isn't supported by the generic routine */
    dsa = (DSA *)PEM_ASN1_read_bio((d2i_of_void *)d2i_DSAPublicKey,
                                   PEM_STRING_DSA_PUBLIC,
                                   in, NULL, NULL, NULL);
    if (dsa)
        goto legacy;
    OSSL_BIO_reset(in);

    pkey = ossl_pkey_read_generic(in, pass);
    BIO_free(in);
    if (!pkey)
        ossl_raise(eDSAError, "Neither PUB key nor PRIV key");

    type = EVP_PKEY_base_id(pkey);
    if (type != EVP_PKEY_DSA) {
        EVP_PKEY_free(pkey);
        rb_raise(eDSAError, "incorrect pkey type: %s", OBJ_nid2sn(type));
    }
    RTYPEDDATA_DATA(self) = pkey;
    return self;

  legacy:
    BIO_free(in);
    pkey = EVP_PKEY_new();
    if (!pkey || EVP_PKEY_assign_DSA(pkey, dsa) != 1) {
        EVP_PKEY_free(pkey);
        DSA_free(dsa);
        ossl_raise(eDSAError, "EVP_PKEY_assign_DSA");
    }
    RTYPEDDATA_DATA(self) = pkey;
    return self;
}

Создаёт новый экземпляр DSA, прочитав существующий ключ из string.

Если вызван без аргументов, создаёт новый экземпляр без установленных компонентов ключа. Их можно установить индивидуально с помощью set_pqg и set_key.

Если вызван со строкой, пытается разобрать её как DER или PEM кодирование ключа DSA. См. также OpenSSL::PKey.read, который может разбирать ключи любого типа.

Если вызван с числом, генерирует случайные параметры и пару ключей. Этот вариант работает как псевдоним для DSA.generate.

string: Строка, содержащая DER или PEM кодированный ключ.
pass: Строка, содержащая необязательный пароль.
size: См. DSA.generate.

Примеры:

p OpenSSL::PKey::DSA.new(1024)
#=> #<OpenSSL::PKey::DSA:0x000055a8d6025bf0 oid=DSA>

p OpenSSL::PKey::DSA.new(File.read('dsa.pem'))
#=> #<OpenSSL::PKey::DSA:0x000055555d6b8110 oid=DSA>

p OpenSSL::PKey::DSA.new(File.read('dsa.pem'), 'mypassword')
#=> #<OpenSSL::PKey::DSA:0x0000556f973c40b8 oid=DSA>

Методы публичного экземпляра

export([cipher, password]) → aString Показать исходный код

static VALUE
ossl_dsa_export(int argc, VALUE *argv, VALUE self)
{
    OSSL_3_const DSA *dsa;

    GetDSA(self, dsa);
    if (DSA_HAS_PRIVATE(dsa))
        return ossl_pkey_export_traditional(argc, argv, self, 0);
    else
        return ossl_pkey_export_spki(self, 0);
}

Кодирует этот DSA в его PEM кодирование.

Параметры

cipher — OpenSSL::Cipher.
password — строка, содержащая ваш пароль.

Примеры

DSA.to_pem -> aString
DSA.to_pem(cipher, 'mypassword') -> aString

Также алиасы: to_pem, to_s

initialize_copy(p1) Показать исходный код

static VALUE
ossl_dsa_initialize_copy(VALUE self, VALUE other)
{
    EVP_PKEY *pkey;
    DSA *dsa, *dsa_new;

    TypedData_Get_Struct(self, EVP_PKEY, &ossl_evp_pkey_type, pkey);
    if (pkey)
        rb_raise(rb_eTypeError, "pkey already initialized");
    GetDSA(other, dsa);

    dsa_new = (DSA *)ASN1_dup((i2d_of_void *)i2d_DSAPrivateKey,
                              (d2i_of_void *)d2i_DSAPrivateKey,
                              (char *)dsa);
    if (!dsa_new)
        ossl_raise(eDSAError, "ASN1_dup");

    pkey = EVP_PKEY_new();
    if (!pkey || EVP_PKEY_assign_DSA(pkey, dsa_new) != 1) {
        EVP_PKEY_free(pkey);
        DSA_free(dsa_new);
        ossl_raise(eDSAError, "EVP_PKEY_assign_DSA");
    }
    RTYPEDDATA_DATA(self) = pkey;

    return self;
}

params → hash Показать исходный код

static VALUE
ossl_dsa_get_params(VALUE self)
{
    OSSL_3_const 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;
}

Хранит все параметры ключа в хэше. НЕБЕЗОПАСНО: КОНФИДЕНЦИАЛЬНАЯ ИНФОРМАЦИЯ МОЖЕТ УТЕЧЬ!!! Не используйте :-)) (Решать вам)

private? → true | false Показать исходный код

static VALUE
ossl_dsa_is_private(VALUE self)
{
    OSSL_3_const DSA *dsa;

    GetDSA(self, dsa);

    return DSA_PRIVATE(self, dsa) ? Qtrue : Qfalse;
}

Указывает, имеет ли этот экземпляр DSA связанный с ним закрытый ключ или нет. Закрытый ключ может быть получен с помощью DSA#private_key.

public? → true | false Показать исходный код

static VALUE
ossl_dsa_is_public(VALUE self)
{
    const DSA *dsa;
    const BIGNUM *bn;

    GetDSA(self, dsa);
    DSA_get0_key(dsa, &bn, NULL);

    return bn ? Qtrue : Qfalse;
}

Указывает, имеет ли этот экземпляр DSA связанный с ним открытый ключ или нет. Открытый ключ может быть получен с помощью DSA#public_key.

public_key → dsanew Показать исходный код

# File ext/openssl/lib/openssl/pkey.rb, line 153
def public_key
  OpenSSL::PKey.read(public_to_der)
end

Возвращает новый экземпляр DSA, содержащий только параметры DSA и открытый ключ.

Этот метод предоставлен для обратной совместимости. В большинстве случаев нет необходимости вызывать этот метод.

Для сериализации открытого ключа в PEM или DER кодирование формата X.509 SubjectPublicKeyInfo см. PKey#public_to_pem и PKey#public_to_der.

set_key(pub_key, priv_key) → self

Устанавливает pub_key и priv_key для экземпляра DSA. priv_key может быть nil.

set_pqg(p, q, g) → self

Устанавливает p, q, g для экземпляра DSA.

syssign(string) → string Показать исходный код

# File ext/openssl/lib/openssl/pkey.rb, line 220
def syssign(string)
  q or raise OpenSSL::PKey::DSAError, "incomplete DSA"
  private? or raise OpenSSL::PKey::DSAError, "Private DSA key needed!"
  begin
    sign_raw(nil, string)
  rescue OpenSSL::PKey::PKeyError
    raise OpenSSL::PKey::DSAError, $!.message
  end
end

Вычисляет и возвращает подпись DSA для string, где string ожидается как уже вычисленный дайджест сообщения исходных входных данных. Подпись выдаётся с использованием закрытого ключа этого экземпляра DSA.

Устарело начиная с версии 3.0. Рассмотрите использование PKey::PKey#sign_raw и PKey::PKey#verify_raw вместо этого.

string: Дайджест сообщения исходных входных данных, подлежащих подписанию.

Пример:

dsa = OpenSSL::PKey::DSA.new(2048)
doc = "Sign me"
digest = OpenSSL::Digest.digest('SHA1', doc)

# With legacy #syssign and #sysverify:
sig = dsa.syssign(digest)
p dsa.sysverify(digest, sig) #=> true

# With #sign_raw and #verify_raw:
sig = dsa.sign_raw(nil, digest)
p dsa.verify_raw(nil, sig, digest) #=> true

sysverify(digest, sig) → true | false Показать исходный код

# File ext/openssl/lib/openssl/pkey.rb, line 243
def sysverify(digest, sig)
  verify_raw(nil, sig, digest)
rescue OpenSSL::PKey::PKeyError
  raise OpenSSL::PKey::DSAError, $!.message
end

Проверяет, является ли подпись валидной, учитывая входной дайджест сообщения. Это делается путём проверки sig с использованием открытого ключа этого экземпляра DSA.

Устарело начиная с версии 3.0. Рассмотрите использование PKey::PKey#sign_raw и PKey::PKey#verify_raw вместо этого.

digest: Дайджест сообщения исходных входных данных, подлежащих подписанию.
sig: Значение подписи DSA.

to_der → aString Показать исходный код

static VALUE
ossl_dsa_to_der(VALUE self)
{
    OSSL_3_const DSA *dsa;

    GetDSA(self, dsa);
    if (DSA_HAS_PRIVATE(dsa))
        return ossl_pkey_export_traditional(0, NULL, self, 1);
    else
        return ossl_pkey_export_spki(self, 1);
}

Кодирует этот DSA в его DER кодирование.

to_pem([cipher, password]) → aString

Кодирует этот DSA в его PEM кодирование.

Параметры

cipher — OpenSSL::Cipher.
password — строка, содержащая ваш пароль.

Примеры

DSA.to_pem -> aString
DSA.to_pem(cipher, 'mypassword') -> aString

Псевдоним для: export

to_s([cipher, password]) → aString

Кодирует этот DSA в его PEM кодирование.

Параметры

cipher — OpenSSL::Cipher.
password — строка, содержащая ваш пароль.

Примеры

DSA.to_pem -> aString
DSA.to_pem(cipher, 'mypassword') -> aString

Псевдоним для: export

Ruby Core © 1993–2022 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.