class OpenSSL::PKey::DSA

DSA，即数字签名算法，在 NIST 的 FIPS 186-3 中有规定。它是一种非对称公钥算法，可以像 RSA 一样使用。

Public Class Methods

Source

# File ext/openssl/lib/openssl/pkey.rb, line 199
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

Source

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) {
#ifdef OSSL_HAVE_IMMUTABLE_PKEY
        rb_raise(rb_eArgError, "OpenSSL::PKey::DSA.new cannot be called " \
                 "without arguments; pkeys are immutable with OpenSSL 3.0");
#else
        dsa = DSA_new();
        if (!dsa)
            ossl_raise(ePKeyError, "DSA_new");
        goto legacy;
#endif
    }

    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(ePKeyError, "Neither PUB key nor PRIV key");

    type = EVP_PKEY_base_id(pkey);
    if (type != EVP_PKEY_DSA) {
        EVP_PKEY_free(pkey);
        rb_raise(ePKeyError, "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(ePKeyError, "EVP_PKEY_assign_DSA");
    }
    RTYPEDDATA_DATA(self) = pkey;
    return self;
}

通过从字符串读取现有密钥来创建一个新的 DSA 实例。

如果无参数调用，则创建一个没有设置密钥组件的新实例。它们可以分别通过 set_pqg 和 set_key 设置。此形式与 OpenSSL 3.0 或更高版本不兼容。

如果使用 String 调用，则尝试将其解析为 DER 或 PEM 编码的 DSA 密钥。另请参阅 OpenSSL::PKey.read，它可以解析各种类型的密钥。

如果使用数字调用，则生成随机参数和密钥对。此形式是 DSA.generate 的别名。

字符串: 包含 DER 或 PEM 编码密钥的 String。
密码: 包含可选密码的 String。
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>

Public Instance Methods

export([cipher, password]) → aString

Source

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);
}

将私有或公钥序列化为 PEM 编码。

当密钥仅包含公有组件时

将其序列化为 X.509 SubjectPublicKeyInfo。cipher 和 password 参数将被忽略。

PEM 编码的密钥将如下所示

-----BEGIN PUBLIC KEY-----
[...]
-----END PUBLIC KEY-----

请考虑改用 public_to_pem。这会将密钥序列化为 X.509 SubjectPublicKeyInfo，而不管它是公钥还是私钥。

当密钥包含私有组件，且未提供参数时

将其序列化为传统的 OpenSSL DSAPrivateKey。

PEM 编码的密钥将如下所示

-----BEGIN DSA PRIVATE KEY-----
[...]
-----END DSA PRIVATE KEY-----

当密钥包含私有组件，且提供了cipher 和 password 时

将其序列化为传统的 OpenSSL DSAPrivateKey，并以 OpenSSL 的传统 PEM 加密格式对其进行加密。cipher 必须是 OpenSSL::Cipher.new 理解的密码名称，或 OpenSSL::Cipher 类的实例。

加密的 PEM 编码密钥将如下所示

-----BEGIN DSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-128-CBC,733F5302505B34701FC41F5C0746E4C0

[...]
-----END DSA PRIVATE KEY-----

请注意，此格式使用 MD5 来派生加密密钥，因此在符合 FIPS 的系统上将不可用。

此方法为保持兼容性而保留。 仅应在需要传统的、非标准的 OpenSSL 格式时使用。

请考虑改用 public_to_pem (X.509 SubjectPublicKeyInfo) 或 private_to_pem (PKCS #8 PrivateKeyInfo 或 EncryptedPrivateKeyInfo)。

也别名为：to_pem, to_s

params → hash

Source

# File ext/openssl/lib/openssl/pkey.rb, line 181
def params
  %w{p q g pub_key priv_key}.map { |name|
    [name, send(name)]
  }.to_h
end

将密钥的所有参数存储到 Hash 中。

该哈希具有键 'p'、'q'、'g'、'pub_key' 和 'priv_key'。

private? → true | false

Source

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

Source

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

Source

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

返回一个携带仅 DSA 参数和公钥的新 DSA 实例。

此方法是为了向后兼容而提供的。在大多数情况下，无需调用此方法。

为了将公钥序列化为 X.509 SubjectPublicKeyInfo 格式的 PEM 或 DER 编码，请查看 PKey#public_to_pem 和 PKey#public_to_der。

set_key(pub_key, priv_key) → self

为 DSA 实例设置pub_key 和 priv_key。priv_key 可以是 nil。

set_pqg(p, q, g) → self

将 p、q、g 设置到 DSA 实例。

syssign(string) → string

Source

# File ext/openssl/lib/openssl/pkey.rb, line 250
def syssign(string)
  q or raise PKeyError, "incomplete DSA"
  private? or raise PKeyError, "Private DSA key needed!"
  sign_raw(nil, string)
end

计算并返回 string 的 DSA 签名，其中 string 预计是原始输入数据的已计算的消息摘要。签名使用此 DSA 实例的私钥签发。

在版本 3.0 中已弃用。请考虑改用 PKey::PKey#sign_raw 和 PKey::PKey#verify_raw。

字符串: 要签名的原始输入数据的消息摘要。

示例

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

Source

# File ext/openssl/lib/openssl/pkey.rb, line 269
def sysverify(digest, sig)
  verify_raw(nil, sig, digest)
end

根据消息摘要输入验证签名是否有效。它通过使用此 DSA 实例的公钥验证 sig 来实现。

在版本 3.0 中已弃用。请考虑改用 PKey::PKey#sign_raw 和 PKey::PKey#verify_raw。

digest: 要签名的原始输入数据的消息摘要。
签名: DSA 签名值。

to_der → aString

Source

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);
}

将私有或公钥序列化为 DER 编码。

有关详细信息，请参阅 to_pem。

此方法为保持兼容性而保留。 仅应在需要传统的、非标准的 OpenSSL 格式时使用。

请考虑改用 public_to_der 或 private_to_der。

to_pem([cipher, password]) → aString

将私有或公钥序列化为 PEM 编码。

当密钥仅包含公有组件时

将其序列化为 X.509 SubjectPublicKeyInfo。cipher 和 password 参数将被忽略。

PEM 编码的密钥将如下所示

-----BEGIN PUBLIC KEY-----
[...]
-----END PUBLIC KEY-----

请考虑改用 public_to_pem。这会将密钥序列化为 X.509 SubjectPublicKeyInfo，而不管它是公钥还是私钥。

当密钥包含私有组件，且未提供参数时

将其序列化为传统的 OpenSSL DSAPrivateKey。

PEM 编码的密钥将如下所示

-----BEGIN DSA PRIVATE KEY-----
[...]
-----END DSA PRIVATE KEY-----

当密钥包含私有组件，且提供了cipher 和 password 时

加密的 PEM 编码密钥将如下所示

-----BEGIN DSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-128-CBC,733F5302505B34701FC41F5C0746E4C0

[...]
-----END DSA PRIVATE KEY-----

请注意，此格式使用 MD5 来派生加密密钥，因此在符合 FIPS 的系统上将不可用。

此方法为保持兼容性而保留。 仅应在需要传统的、非标准的 OpenSSL 格式时使用。

请考虑改用 public_to_pem (X.509 SubjectPublicKeyInfo) 或 private_to_pem (PKCS #8 PrivateKeyInfo 或 EncryptedPrivateKeyInfo)。

别名：export

to_s([cipher, password]) → aString

将私有或公钥序列化为 PEM 编码。

当密钥仅包含公有组件时

将其序列化为 X.509 SubjectPublicKeyInfo。cipher 和 password 参数将被忽略。

PEM 编码的密钥将如下所示

-----BEGIN PUBLIC KEY-----
[...]
-----END PUBLIC KEY-----

请考虑改用 public_to_pem。这会将密钥序列化为 X.509 SubjectPublicKeyInfo，而不管它是公钥还是私钥。

当密钥包含私有组件，且未提供参数时

将其序列化为传统的 OpenSSL DSAPrivateKey。

PEM 编码的密钥将如下所示

-----BEGIN DSA PRIVATE KEY-----
[...]
-----END DSA PRIVATE KEY-----

当密钥包含私有组件，且提供了cipher 和 password 时

加密的 PEM 编码密钥将如下所示

-----BEGIN DSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-128-CBC,733F5302505B34701FC41F5C0746E4C0

[...]
-----END DSA PRIVATE KEY-----

请注意，此格式使用 MD5 来派生加密密钥，因此在符合 FIPS 的系统上将不可用。

此方法为保持兼容性而保留。 仅应在需要传统的、非标准的 OpenSSL 格式时使用。

请考虑改用 public_to_pem (X.509 SubjectPublicKeyInfo) 或 private_to_pem (PKCS #8 PrivateKeyInfo 或 EncryptedPrivateKeyInfo)。

别名：export