hashlib.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# lishoujun <lsjun@aliyun.com>, 2020
# Konge <zkonge@outlook.com>, 2020
# walkinrain <walkinrain2008@outlook.com>, 2020
# nick <2330458484@qq.com>, 2020
# ppcfish <ppcfish@gmail.com>, 2020
# st z <zstcode@outlook.com>, 2020
# Freesand Leo <yuqinju@163.com>, 2021
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-05-09 17:20+0000\n"
"PO-Revision-Date: 2020-05-30 12:03+0000\n"
"Last-Translator: Freesand Leo <yuqinju@163.com>, 2021\n"
"Language-Team: Chinese (China) (https://www.transifex.com/python-doc/teams/5390/zh_CN/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: zh_CN\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/hashlib.rst:2
msgid ":mod:`hashlib` --- Secure hashes and message digests"
msgstr ":mod:`hashlib` --- 安全哈希与消息摘要"

#: ../../library/hashlib.rst:10
msgid "**Source code:** :source:`Lib/hashlib.py`"
msgstr "**源码：** :source:`Lib/hashlib.py`"

#: ../../library/hashlib.rst:23
msgid ""
"This module implements a common interface to many different secure hash and "
"message digest algorithms.  Included are the FIPS secure hash algorithms "
"SHA1, SHA224, SHA256, SHA384, and SHA512 (defined in FIPS 180-2) as well as "
"RSA's MD5 algorithm (defined in Internet :rfc:`1321`).  The terms \"secure "
"hash\" and \"message digest\" are interchangeable.  Older algorithms were "
"called message digests.  The modern term is secure hash."
msgstr ""
"这个模块针对不同的安全哈希和消息摘要算法实现了一个通用的接口。包括 FIPS 的 SHA1, SHA224, SHA256, SHA384, and "
"SHA512 (定义于 FIPS 180-2) 算法，以及 RSA 的 MD5 算法( 定义于 Internet "
":rfc:`1321`)。术语“安全哈希”和“消息摘要”是可互换的，较旧的算法被称为消息摘要，现代术语是安全哈希。"

#: ../../library/hashlib.rst:32
msgid ""
"If you want the adler32 or crc32 hash functions, they are available in the "
":mod:`zlib` module."
msgstr "如果你想找到 adler32 或 crc32 哈希函数，它们在 :mod:`zlib` 模块中。"

#: ../../library/hashlib.rst:37
msgid ""
"Some algorithms have known hash collision weaknesses, refer to the \"See "
"also\" section at the end."
msgstr "有些算法已知存在哈希碰撞弱点，请参考最后的“另请参阅”段。"

#: ../../library/hashlib.rst:44
msgid "Hash algorithms"
msgstr "哈希算法"

#: ../../library/hashlib.rst:46
msgid ""
"There is one constructor method named for each type of :dfn:`hash`.  All "
"return a hash object with the same simple interface. For example: use "
":func:`sha256` to create a SHA-256 hash object. You can now feed this object"
" with :term:`bytes-like objects <bytes-like object>` (normally "
":class:`bytes`) using the :meth:`update` method. At any point you can ask it"
" for the :dfn:`digest` of the concatenation of the data fed to it so far "
"using the :meth:`digest` or :meth:`hexdigest` methods."
msgstr ""
"每种类型的 :dfn:`hash` 都有一个构造器方法。 它们都返回一个具有相同的简单接口的 hash 对象。 例如，使用 use "
":func:`sha256` 创建一个 SHA-256 hash 对象。 你可以使用 :meth:`update` 方法向这个对象输入 "
":term:`字节类对象 <bytes-like object>` (通常是 :class:`bytes`)。 在任何时候你都可以使用 "
":meth:`digest` 或 :meth:`hexdigest` 方法获得到目前为止输入这个对象的拼接数据的 :dfn:`digest`。"

#: ../../library/hashlib.rst:56
msgid ""
"For better multithreading performance, the Python :term:`GIL` is released "
"for data larger than 2047 bytes at object creation or on update."
msgstr "为了更好的多线程性能，在对象创建或者更新时，若数据大于2047字节则 Python 的 :term:`GIL` 会被释放。"

#: ../../library/hashlib.rst:61
msgid ""
"Feeding string objects into :meth:`update` is not supported, as hashes work "
"on bytes, not on characters."
msgstr "向 :meth:`update` 输入字符串对象是不被支持的，因为哈希基于字节而非字符。"

#: ../../library/hashlib.rst:66
msgid ""
"Constructors for hash algorithms that are always present in this module are "
":func:`sha1`, :func:`sha224`, :func:`sha256`, :func:`sha384`, "
":func:`sha512`, :func:`blake2b`, and :func:`blake2s`. :func:`md5` is "
"normally available as well, though it may be missing if you are using a rare"
" \"FIPS compliant\" build of Python. Additional algorithms may also be "
"available depending upon the OpenSSL library that Python uses on your "
"platform. On most platforms the :func:`sha3_224`, :func:`sha3_256`, "
":func:`sha3_384`, :func:`sha3_512`, :func:`shake_128`, :func:`shake_256` are"
" also available."
msgstr ""
"此模块中总是可用的哈希算法构造器有 :func:`sha1`, :func:`sha224`, :func:`sha256`, "
":func:`sha384`, :func:`sha512`, :func:`blake2b` 和 :func:`blake2s`。 "
":func:`md5` 通常也是可用的，但如果你在使用少见的 \"FIPS 兼容\" 的 Python 编译版本则可能会找不到它。 "
"此外还可能有一些附加的算法，具体取决于你的平台上的 Python 所使用的 OpenSSL 库。 在大部分平台上可用的还有 "
":func:`sha3_224`, :func:`sha3_256`, :func:`sha3_384`, :func:`sha3_512`, "
":func:`shake_128`, :func:`shake_256` 等等。"

#: ../../library/hashlib.rst:76
msgid ""
"SHA3 (Keccak) and SHAKE constructors :func:`sha3_224`, :func:`sha3_256`, "
":func:`sha3_384`, :func:`sha3_512`, :func:`shake_128`, :func:`shake_256`."
msgstr ""
"SHA3 (Keccak) 和 SHAKE 构造器 :func:`sha3_224`, :func:`sha3_256`, "
":func:`sha3_384`, :func:`sha3_512`, :func:`shake_128`, :func:`shake_256`."

#: ../../library/hashlib.rst:80
msgid ":func:`blake2b` and :func:`blake2s` were added."
msgstr "添加了 :func:`blake2b` 和 :func:`blake2s` 。"

#: ../../library/hashlib.rst:83
msgid ""
"For example, to obtain the digest of the byte string ``b'Nobody inspects the"
" spammish repetition'``::"
msgstr "例如，如果想获取字节串 ``b'Nobody inspects the spammish repetition'`` 的摘要::"

#: ../../library/hashlib.rst:97
msgid "More condensed:"
msgstr "更简要的写法："

#: ../../library/hashlib.rst:104
msgid ""
"Is a generic constructor that takes the string *name* of the desired "
"algorithm as its first parameter.  It also exists to allow access to the "
"above listed hashes as well as any other algorithms that your OpenSSL "
"library may offer.  The named constructors are much faster than :func:`new` "
"and should be preferred."
msgstr ""
"一个接受所希望的算法对应的字符串 *name* 作为第一个形参的通用构造器。 它还允许访问上面列出的哈希算法以及你的 OpenSSL "
"库可能提供的任何其他算法。 同名的构造器要比 :func:`new` 更快所以应当优先使用。"

#: ../../library/hashlib.rst:110
msgid "Using :func:`new` with an algorithm provided by OpenSSL:"
msgstr "使用 :func:`new` 并附带由 OpenSSL 所提供了算法:"

#: ../../library/hashlib.rst:117
msgid "Hashlib provides the following constant attributes:"
msgstr "Hashlib 提供下列常量属性："

#: ../../library/hashlib.rst:121
msgid ""
"A set containing the names of the hash algorithms guaranteed to be supported"
" by this module on all platforms.  Note that 'md5' is in this list despite "
"some upstream vendors offering an odd \"FIPS compliant\" Python build that "
"excludes it."
msgstr ""
"一个集合，其中包含此模块在所有平台上都保证支持的哈希算法的名称。 请注意 'md5' 也在此清单中，虽然某些上游厂商提供了一个怪异的排除了此算法的 "
"\"FIPS 兼容\" Python 编译版本。"

#: ../../library/hashlib.rst:130
msgid ""
"A set containing the names of the hash algorithms that are available in the "
"running Python interpreter.  These names will be recognized when passed to "
":func:`new`.  :attr:`algorithms_guaranteed` will always be a subset.  The "
"same algorithm may appear multiple times in this set under different names "
"(thanks to OpenSSL)."
msgstr ""
"一个集合，其中包含在所运行的 Python 解释器上可用的哈希算法的名称。 将这些名称传给 :func:`new` 时将可被识别。 "
":attr:`algorithms_guaranteed` 将总是它的一个子集。 同样的算法在此集合中可能以不同的名称出现多次（这是 OpenSSL "
"的原因）。"

#: ../../library/hashlib.rst:138
msgid ""
"The following values are provided as constant attributes of the hash objects"
" returned by the constructors:"
msgstr "下列值会以构造器所返回的哈希对象的常量属性的形式被提供:"

#: ../../library/hashlib.rst:144
msgid "The size of the resulting hash in bytes."
msgstr "以字节表示的结果哈希对象的大小。"

#: ../../library/hashlib.rst:148
msgid "The internal block size of the hash algorithm in bytes."
msgstr "以字节表示的哈希算法的内部块大小。"

#: ../../library/hashlib.rst:150
msgid "A hash object has the following attributes:"
msgstr "hash 对象具有以下属性："

#: ../../library/hashlib.rst:154
msgid ""
"The canonical name of this hash, always lowercase and always suitable as a "
"parameter to :func:`new` to create another hash of this type."
msgstr "此哈希对象的规范名称，总是为小写形式并且总是可以作为 :func:`new` 的形参用来创建另一个此类型的哈希对象。"

#: ../../library/hashlib.rst:157
msgid ""
"The name attribute has been present in CPython since its inception, but "
"until Python 3.4 was not formally specified, so may not exist on some "
"platforms."
msgstr "该属性名称自被引入起即存在于 CPython 中，但在 Python 3.4 之前并未正式指明，因此可能不存在于某些平台上。"

#: ../../library/hashlib.rst:162
msgid "A hash object has the following methods:"
msgstr "哈希对象具有下列方法:"

#: ../../library/hashlib.rst:167
msgid ""
"Update the hash object with the :term:`bytes-like object`. Repeated calls "
"are equivalent to a single call with the concatenation of all the arguments:"
" ``m.update(a); m.update(b)`` is equivalent to ``m.update(a+b)``."
msgstr ""
"用 :term:`bytes-like object` 来更新哈希对象。 重复调用相当于单次调用并传入所有参数的拼接结果: ``m.update(a);"
" m.update(b)`` 等价于 ``m.update(a+b)``。"

#: ../../library/hashlib.rst:172
msgid ""
"The Python GIL is released to allow other threads to run while hash updates "
"on data larger than 2047 bytes is taking place when using hash algorithms "
"supplied by OpenSSL."
msgstr "当使用 OpenSSL 提供的哈希算法在大于 2047 字节的数据上执行哈希更新时 Python GIL 会被释放以允许其他线程运行。"

#: ../../library/hashlib.rst:180
msgid ""
"Return the digest of the data passed to the :meth:`update` method so far. "
"This is a bytes object of size :attr:`digest_size` which may contain bytes "
"in the whole range from 0 to 255."
msgstr ""
"返回当前已传给 :meth:`update` 方法的数据摘要。 这是一个大小为 :attr:`digest_size` 的字节串对象，字节串中可包含 0"
" 至 255 的完整取值范围。"

#: ../../library/hashlib.rst:187 ../../library/hashlib.rst:215
msgid ""
"Like :meth:`digest` except the digest is returned as a string object of "
"double length, containing only hexadecimal digits.  This may be used to "
"exchange the value safely in email or other non-binary environments."
msgstr ""
"类似于 :meth:`digest` 但摘要会以两倍长度字符串对象的形式返回，其中仅包含十六进制数码。 "
"这可以被用于在电子邮件或其他非二进制环境中安全地交换数据值。"

#: ../../library/hashlib.rst:194
msgid ""
"Return a copy (\"clone\") of the hash object.  This can be used to "
"efficiently compute the digests of data sharing a common initial substring."
msgstr "返回哈希对象的副本（“克隆”）。 这可被用来高效地计算共享相同初始子串的数据的摘要。"

#: ../../library/hashlib.rst:199
msgid "SHAKE variable length digests"
msgstr "SHAKE 可变长度摘要"

#: ../../library/hashlib.rst:201
msgid ""
"The :func:`shake_128` and :func:`shake_256` algorithms provide variable "
"length digests with length_in_bits//2 up to 128 or 256 bits of security. As "
"such, their digest methods require a length. Maximum length is not limited "
"by the SHAKE algorithm."
msgstr ""
":func:`shake_128` 和 :func:`shake_256` 算法提供安全的 length_in_bits//2 至 128 或 256 "
"位可变长度摘要。 为此，它们的摘要需指定一个长度。 SHAKE 算法不限制最大长度。"

#: ../../library/hashlib.rst:208
msgid ""
"Return the digest of the data passed to the :meth:`update` method so far. "
"This is a bytes object of size *length* which may contain bytes in the whole"
" range from 0 to 255."
msgstr ""
"返回当前已传给 :meth:`update` 方法的数据摘要。 这是一个大小为 *length* 的字节串对象，字节串中可包含 0 to 255 "
"的完整取值范围。"

#: ../../library/hashlib.rst:221
msgid "Key derivation"
msgstr "密钥派生"

#: ../../library/hashlib.rst:223
msgid ""
"Key derivation and key stretching algorithms are designed for secure "
"password hashing. Naive algorithms such as ``sha1(password)`` are not "
"resistant against brute-force attacks. A good password hashing function must"
" be tunable, slow, and include a `salt "
"<https://en.wikipedia.org/wiki/Salt_%28cryptography%29>`_."
msgstr ""
"密钥派生和密钥延展算法被设计用于安全密码哈希。 ``sha1(password)`` 这样的简单算法无法防御暴力攻击。 "
"好的密码哈希函数必须可以微调、放慢步调，并且包含 `加盐 "
"<https://en.wikipedia.org/wiki/Salt_%28cryptography%29>`_。"

#: ../../library/hashlib.rst:231
msgid ""
"The function provides PKCS#5 password-based key derivation function 2. It "
"uses HMAC as pseudorandom function."
msgstr "此函数提供 PKCS#5 基于密码的密钥派生函数 2。 它使用 HMAC 作为伪随机函数。"

#: ../../library/hashlib.rst:234
msgid ""
"The string *hash_name* is the desired name of the hash digest algorithm for "
"HMAC, e.g. 'sha1' or 'sha256'. *password* and *salt* are interpreted as "
"buffers of bytes. Applications and libraries should limit *password* to a "
"sensible length (e.g. 1024). *salt* should be about 16 or more bytes from a "
"proper source, e.g. :func:`os.urandom`."
msgstr ""
"字符串 *hash_name* 是要求用于 HMAC 的哈希摘要算法的名称，例如 'sha1' 或 'sha256'。 *password* 和 "
"*salt* 会以字节串缓冲区的形式被解析。 应用和库应当将 *password* 限制在合理长度 (例如 1024)。 *salt* "
"应当为适当来源例如 :func:`os.urandom` 的大约 16 个或更多的字节串数据。"

#: ../../library/hashlib.rst:240
msgid ""
"The number of *iterations* should be chosen based on the hash algorithm and "
"computing power. As of 2013, at least 100,000 iterations of SHA-256 are "
"suggested."
msgstr "*iterations* 数值应当基于哈希算法和算力来选择。 在 2013 年时，建议至少为 100,000 次 SHA-256 迭代。"

#: ../../library/hashlib.rst:244
msgid ""
"*dklen* is the length of the derived key. If *dklen* is ``None`` then the "
"digest size of the hash algorithm *hash_name* is used, e.g. 64 for SHA-512."
msgstr ""
"*dklen* 为派生密钥的长度。 如果 *dklen* 为 ``None`` 则会使用哈希算法 *hash_name* 的摘要大小，例如 "
"SHA-512 为 64。"

#: ../../library/hashlib.rst:256
msgid ""
"A fast implementation of *pbkdf2_hmac* is available with OpenSSL.  The "
"Python implementation uses an inline version of :mod:`hmac`. It is about "
"three times slower and doesn't release the GIL."
msgstr ""
"随同 OpenSSL 提供了一个快速的 *pbkdf2_hmac* 实现。 Python 实现是使用 :mod:`hmac` 的内联版本。 "
"它的速度大约要慢上三倍并且不会释放 GIL。"

#: ../../library/hashlib.rst:262
msgid ""
"The function provides scrypt password-based key derivation function as "
"defined in :rfc:`7914`."
msgstr "此函数提供基于密码加密的密钥派生函数，其定义参见 :rfc:`7914`。"

#: ../../library/hashlib.rst:265
msgid ""
"*password* and *salt* must be :term:`bytes-like objects <bytes-like "
"object>`.  Applications and libraries should limit *password* to a sensible "
"length (e.g. 1024).  *salt* should be about 16 or more bytes from a proper "
"source, e.g. :func:`os.urandom`."
msgstr ""
"*password* 和 *salt* 必须为 :term:`字节类对象 <bytes-like object>`。 应用和库应当将 "
"*password* 限制在合理长度 (例如 1024)。 *salt* 应当为适当来源例如 :func:`os.urandom` 的大约 16 "
"个或更多的字节串数据。"

#: ../../library/hashlib.rst:270
msgid ""
"*n* is the CPU/Memory cost factor, *r* the block size, *p* parallelization "
"factor and *maxmem* limits memory (OpenSSL 1.1.0 defaults to 32 MiB). "
"*dklen* is the length of the derived key."
msgstr ""
"*n* 为 CPU/内存开销因子，*r* 为块大小，*p* 为并行化因子，*maxmem* 为内存限制 (OpenSSL 1.1.0 默认为 32 "
"MiB)。 *dklen* 为派生密钥的长度。"

#: ../../library/hashlib.rst:275
msgid ":ref:`Availability <availability>`: OpenSSL 1.1+."
msgstr ":ref:`可用性 <availability>`: OpenSSL 1.1+。"

#: ../../library/hashlib.rst:280
msgid "BLAKE2"
msgstr "BLAKE2"

#: ../../library/hashlib.rst:287
msgid ""
"BLAKE2_ is a cryptographic hash function defined in :rfc:`7693` that comes "
"in two flavors:"
msgstr "BLAKE2_ 是在 :rfc:`7693` 中定义的加密哈希函数，它有两种形式:"

#: ../../library/hashlib.rst:290
msgid ""
"**BLAKE2b**, optimized for 64-bit platforms and produces digests of any size"
" between 1 and 64 bytes,"
msgstr "**BLAKE2b**，针对 64 位平台进行优化，并会生成长度介于 1 和 64 字节之间任意大小的摘要。"

#: ../../library/hashlib.rst:293
msgid ""
"**BLAKE2s**, optimized for 8- to 32-bit platforms and produces digests of "
"any size between 1 and 32 bytes."
msgstr "**BLAKE2s**，针对 8 至 32 位平台进行优化，并会生成长度介于 1 和 32 字节之间任意大小的摘要。"

#: ../../library/hashlib.rst:296
msgid ""
"BLAKE2 supports **keyed mode** (a faster and simpler replacement for HMAC_),"
" **salted hashing**, **personalization**, and **tree hashing**."
msgstr ""
"BLAKE2 支持 **keyed mode** (HMAC_ 的更快速更简单的替代), **salted hashing**, "
"**personalization** 和 **tree hashing**."

#: ../../library/hashlib.rst:299
msgid ""
"Hash objects from this module follow the API of standard library's "
":mod:`hashlib` objects."
msgstr "此模块的哈希对象遵循标准库 :mod:`hashlib` 对象的 API。"

#: ../../library/hashlib.rst:304
msgid "Creating hash objects"
msgstr "创建哈希对象"

#: ../../library/hashlib.rst:306
msgid "New hash objects are created by calling constructor functions:"
msgstr "新哈希对象可通过调用构造器函数来创建:"

#: ../../library/hashlib.rst:318
msgid ""
"These functions return the corresponding hash objects for calculating "
"BLAKE2b or BLAKE2s. They optionally take these general parameters:"
msgstr "这些函数返回用于计算 BLAKE2b 或 BLAKE2s 的相应的哈希对象。 它们接受下列可选通用形参:"

#: ../../library/hashlib.rst:321
msgid ""
"*data*: initial chunk of data to hash, which must be :term:`bytes-like "
"object`.  It can be passed only as positional argument."
msgstr "*data*: 要哈希的初始数据块，它必须为 :term:`bytes-like object`。 它只能作为位置参数传入。"

#: ../../library/hashlib.rst:324
msgid "*digest_size*: size of output digest in bytes."
msgstr "*digest_size*: 以字节数表示的输出摘要大小。"

#: ../../library/hashlib.rst:326
msgid ""
"*key*: key for keyed hashing (up to 64 bytes for BLAKE2b, up to 32 bytes for"
" BLAKE2s)."
msgstr "*key*: 用于密钥哈希的密钥（对于 BLAKE2b 最长 64 字节，对于 BLAKE2s 最长 32 字节）。"

#: ../../library/hashlib.rst:329
msgid ""
"*salt*: salt for randomized hashing (up to 16 bytes for BLAKE2b, up to 8 "
"bytes for BLAKE2s)."
msgstr "*salt*: 用于随机哈希的盐值（对于 BLAKE2b 最长 16 字节，对于 BLAKE2s 最长 8 字节）。"

#: ../../library/hashlib.rst:332
msgid ""
"*person*: personalization string (up to 16 bytes for BLAKE2b, up to 8 bytes "
"for BLAKE2s)."
msgstr "*person*: 个性化字符串（对于 BLAKE2b 最长 16 字节，对于 BLAKE2s 最长 8 字节）。"

#: ../../library/hashlib.rst:335
msgid "The following table shows limits for general parameters (in bytes):"
msgstr "下表显示了常规参数的限制（以字节为单位）："

#: ../../library/hashlib.rst:338
msgid "Hash"
msgstr "Hash"

#: ../../library/hashlib.rst:338
msgid "digest_size"
msgstr "目标长度"

#: ../../library/hashlib.rst:338
msgid "len(key)"
msgstr "长度（键）"

#: ../../library/hashlib.rst:338
msgid "len(salt)"
msgstr "长度（盐）"

#: ../../library/hashlib.rst:338
msgid "len(person)"
msgstr "长度（个人）"

#: ../../library/hashlib.rst:340
msgid "BLAKE2b"
msgstr "BLAKE2b"

#: ../../library/hashlib.rst:340 ../../library/hashlib.rst:340
msgid "64"
msgstr "64"

#: ../../library/hashlib.rst:340 ../../library/hashlib.rst:340
msgid "16"
msgstr "16"

#: ../../library/hashlib.rst:341
msgid "BLAKE2s"
msgstr "BLAKE2s"

#: ../../library/hashlib.rst:341 ../../library/hashlib.rst:341
msgid "32"
msgstr "32"

#: ../../library/hashlib.rst:341 ../../library/hashlib.rst:341
msgid "8"
msgstr "8"

#: ../../library/hashlib.rst:346
msgid ""
"BLAKE2 specification defines constant lengths for salt and personalization "
"parameters, however, for convenience, this implementation accepts byte "
"strings of any size up to the specified length. If the length of the "
"parameter is less than specified, it is padded with zeros, thus, for "
"example, ``b'salt'`` and ``b'salt\\x00'`` is the same value. (This is not "
"the case for *key*.)"
msgstr ""
"BLAKE2 规格描述为盐值和个性化形参定义了固定的长度，但是为了方便起见，此实现接受指定在长度以内的任意大小的字节串。 "
"如果形参长度小于指定值，它将以零值进行填充，因此举例来说，``b'salt'`` 和 ``b'salt\\x00'`` 为相同的值 (*key* "
"的情况则并非如此。)"

#: ../../library/hashlib.rst:353
msgid "These sizes are available as module `constants`_ described below."
msgstr "如下面的模块 `constants`_ 所描述，这些是可用的大小取值。"

#: ../../library/hashlib.rst:355
msgid ""
"Constructor functions also accept the following tree hashing parameters:"
msgstr "构造器函数还接受下列树形哈希形参:"

#: ../../library/hashlib.rst:357
msgid "*fanout*: fanout (0 to 255, 0 if unlimited, 1 in sequential mode)."
msgstr "*fanout*: 扇出值 (0 至 255，如无限制即为 0，连续模式下为 1)。"

#: ../../library/hashlib.rst:359
msgid ""
"*depth*: maximal depth of tree (1 to 255, 255 if unlimited, 1 in sequential "
"mode)."
msgstr "*depth*: 树的最大深度 (1 至 255，如无限制则为 255，连续模式下为 1)。"

#: ../../library/hashlib.rst:362
msgid ""
"*leaf_size*: maximal byte length of leaf (0 to 2**32-1, 0 if unlimited or in"
" sequential mode)."
msgstr "*leaf_size*: 叶子的最大字节长度 (0 至 2**32-1，如无限制或在连续模式下则为 0)。"

#: ../../library/hashlib.rst:365
msgid ""
"*node_offset*: node offset (0 to 2**64-1 for BLAKE2b, 0 to 2**48-1 for "
"BLAKE2s, 0 for the first, leftmost, leaf, or in sequential mode)."
msgstr ""
"*node_offset*: 节点偏移量 (对于 BLAKE2b 为 0 至 2**64-1，对于 BLAKE2s 为 0 至 "
"2**48-1，对于最左边第一个叶子或在连续模式下则为 0)。"

#: ../../library/hashlib.rst:368
msgid ""
"*node_depth*: node depth (0 to 255, 0 for leaves, or in sequential mode)."
msgstr "*node_depth*: 节点深度 (0 至 255，对于叶子或在连续模式下则为 0)。"

#: ../../library/hashlib.rst:370
msgid ""
"*inner_size*: inner digest size (0 to 64 for BLAKE2b, 0 to 32 for BLAKE2s, 0"
" in sequential mode)."
msgstr ""
"*inner_size*: 内部摘要大小 (对于 BLAKE2b 为 0 至 64，对于 BLAKE2s 为 0 至 32，连续模式下则为 0)。"

#: ../../library/hashlib.rst:373
msgid ""
"*last_node*: boolean indicating whether the processed node is the last one "
"(`False` for sequential mode)."
msgstr "*last_node*: 一个布尔值，指明所处理的节点是否为最后一个 (连续模式下则为 `False`)。"

#: ../../library/hashlib.rstNone
msgid "Explanation of tree mode parameters."
msgstr "树模式形参的说明。"

#: ../../library/hashlib.rst:379
msgid ""
"See section 2.10 in `BLAKE2 specification "
"<https://blake2.net/blake2_20130129.pdf>`_ for comprehensive review of tree "
"hashing."
msgstr ""
"请参阅 `BLAKE2 规格描述 <https://blake2.net/blake2_20130129.pdf>`_ 第 2.10 "
"节获取有关树形哈希的完整说明。"

#: ../../library/hashlib.rst:385
msgid "Constants"
msgstr "常量"

#: ../../library/hashlib.rst:390
msgid "Salt length (maximum length accepted by constructors)."
msgstr "盐值长度（构造器所接受的最大长度）。"

#: ../../library/hashlib.rst:396
msgid ""
"Personalization string length (maximum length accepted by constructors)."
msgstr "个性化字符串长度（构造器所接受的最大长度）。"

#: ../../library/hashlib.rst:402
msgid "Maximum key size."
msgstr "最大密钥长度。"

#: ../../library/hashlib.rst:408
msgid "Maximum digest size that the hash function can output."
msgstr "哈希函数可输出的最大摘要长度。"

#: ../../library/hashlib.rst:412
msgid "Examples"
msgstr "例子"

#: ../../library/hashlib.rst:415
msgid "Simple hashing"
msgstr "简单哈希"

#: ../../library/hashlib.rst:417
msgid ""
"To calculate hash of some data, you should first construct a hash object by "
"calling the appropriate constructor function (:func:`blake2b` or "
":func:`blake2s`), then update it with the data by calling :meth:`update` on "
"the object, and, finally, get the digest out of the object by calling "
":meth:`digest` (or :meth:`hexdigest` for hex-encoded string)."
msgstr ""
"要计算某个数据的哈希值，你应该首先通过调用适当的构造器函数 (:func:`blake2b` 或 :func:`blake2s`) "
"来构造一个哈希对象，然后通过在该对象上调用 :meth:`update` 来更新目标数据，最后通过调用 :meth:`digest` "
"(或针对十六进制编码字符串的 :meth:`hexdigest`) 来获取该对象的摘要。"

#: ../../library/hashlib.rst:430
msgid ""
"As a shortcut, you can pass the first chunk of data to update directly to "
"the constructor as the positional argument:"
msgstr "作为快捷方式，你可以直接以位置参数的形式向构造器传入第一个数据块来直接更新:"

#: ../../library/hashlib.rst:437
msgid ""
"You can call :meth:`hash.update` as many times as you need to iteratively "
"update the hash:"
msgstr "你可以多次调用 :meth:`hash.update` 至你所想要的任意次数以迭代地更新哈希值:"

#: ../../library/hashlib.rst:450
msgid "Using different digest sizes"
msgstr "使用不同的摘要大小"

#: ../../library/hashlib.rst:452
msgid ""
"BLAKE2 has configurable size of digests up to 64 bytes for BLAKE2b and up to"
" 32 bytes for BLAKE2s. For example, to replace SHA-1 with BLAKE2b without "
"changing the size of output, we can tell BLAKE2b to produce 20-byte digests:"
msgstr ""
"BLAKE2 具有可配置的摘要大小，对于 BLAKE2b 最多 64 字节，对于 BLAKE2s 最多 32 字节。 例如，要使用 BLAKE2b "
"来替代 SHA-1 而不改变输出大小，我们可以让 BLAKE2b 产生 20 个字节的摘要:"

#: ../../library/hashlib.rst:466
msgid ""
"Hash objects with different digest sizes have completely different outputs "
"(shorter hashes are *not* prefixes of longer hashes); BLAKE2b and BLAKE2s "
"produce different outputs even if the output length is the same:"
msgstr ""
"不同摘要大小的哈希对象具有完全不同的输出（较短哈希值 *并非* 较长哈希值的前缀）；即使输出长度相同，BLAKE2b 和 BLAKE2s "
"也会产生不同的输出:"

#: ../../library/hashlib.rst:482
msgid "Keyed hashing"
msgstr "密钥哈希"

#: ../../library/hashlib.rst:484
msgid ""
"Keyed hashing can be used for authentication as a faster and simpler "
"replacement for `Hash-based message authentication code "
"<https://en.wikipedia.org/wiki/Hash-based_message_authentication_code>`_ "
"(HMAC). BLAKE2 can be securely used in prefix-MAC mode thanks to the "
"indifferentiability property inherited from BLAKE."
msgstr ""
"密钥哈希可被用于身份验证，作为 `基于哈希的消息验证代码 <https://en.wikipedia.org/wiki/Hash-"
"based_message_authentication_code>`_ (HMAC) 的一种更快速更简单的替代。 BLAKE2 可在前缀 MAC "
"模式下安全地使用，这是由于它从 BLAKE 所继承的不可区分特性。"

#: ../../library/hashlib.rst:490
msgid ""
"This example shows how to get a (hex-encoded) 128-bit authentication code "
"for message ``b'message data'`` with key ``b'pseudorandom key'``::"
msgstr ""
"这个例子演示了如何使用密钥 ``b'pseudorandom key'`` 来为 ``b'message data'`` "
"获取一个（十六进制编码的）128 位验证代码::"

#: ../../library/hashlib.rst:500
msgid ""
"As a practical example, a web application can symmetrically sign cookies "
"sent to users and later verify them to make sure they weren't tampered "
"with::"
msgstr "作为实际的例子，一个 Web 应用可为发送给用户的 cookies 进行对称签名，并在之后对其进行验证以确保它们没有被篡改::"

#: ../../library/hashlib.rst:529
msgid ""
"Even though there's a native keyed hashing mode, BLAKE2 can, of course, be "
"used in HMAC construction with :mod:`hmac` module::"
msgstr "即使存在原生的密钥哈希模式，BLAKE2 也同样可在 :mod:`hmac` 模块的 HMAC 构造过程中使用::"

#: ../../library/hashlib.rst:540
msgid "Randomized hashing"
msgstr "随机哈希"

#: ../../library/hashlib.rst:542
msgid ""
"By setting *salt* parameter users can introduce randomization to the hash "
"function. Randomized hashing is useful for protecting against collision "
"attacks on the hash function used in digital signatures."
msgstr "用户可通过设置 *salt* 形参来为哈希函数引入随机化。 随机哈希适用于防止对数字签名中使用的哈希函数进行碰撞攻击。"

#: ../../library/hashlib.rst:546
msgid ""
"Randomized hashing is designed for situations where one party, the message "
"preparer, generates all or part of a message to be signed by a second party,"
" the message signer. If the message preparer is able to find cryptographic "
"hash function collisions (i.e., two messages producing the same hash value),"
" then they might prepare meaningful versions of the message that would "
"produce the same hash value and digital signature, but with different "
"results (e.g., transferring $1,000,000 to an account, rather than $10). "
"Cryptographic hash functions have been designed with collision resistance as"
" a major goal, but the current concentration on attacking cryptographic hash"
" functions may result in a given cryptographic hash function providing less "
"collision resistance than expected. Randomized hashing offers the signer "
"additional protection by reducing the likelihood that a preparer can "
"generate two or more messages that ultimately yield the same hash value "
"during the digital signature generation process --- even if it is practical "
"to find collisions for the hash function. However, the use of randomized "
"hashing may reduce the amount of security provided by a digital signature "
"when all portions of the message are prepared by the signer."
msgstr ""
"随机哈希被设计用来处理当一方（消息准备者）要生成由另一方（消息签名者）进行签名的全部或部分消息的情况。 "
"如果消息准备者能够找到加密哈希函数的碰撞现象（即两条消息产生相同的哈希值），则他们就可以准备将产生相同哈希值和数字签名但却具有不同结果的有意义的消息版本（例如向某个账户转入"
" $1,000,000 而不是 $10）。 "
"加密哈希函数的设计都是以防碰撞性能为其主要目标之一的，但是当前针对加密哈希函数的集中攻击可能导致特定加密哈希函数所提供的防碰撞性能低于预期。 "
"随机哈希为签名者提供了额外的保护，可以降低准备者在数字签名生成过程中使得两条或更多条消息最终产生相同哈希值的可能性 --- "
"即使为特定哈希函数找到碰撞现象是可行的。 但是，当消息的所有部分均由签名者准备时，使用随机哈希可能降低数字签名所提供的安全性。"

#: ../../library/hashlib.rst:565
msgid ""
"(`NIST SP-800-106 \"Randomized Hashing for Digital Signatures\" "
"<https://csrc.nist.gov/publications/detail/sp/800-106/final>`_)"
msgstr ""
"(`NIST SP-800-106 \"数字签名的随机哈希\" "
"<https://csrc.nist.gov/publications/detail/sp/800-106/final>`_)"

#: ../../library/hashlib.rst:568
msgid ""
"In BLAKE2 the salt is processed as a one-time input to the hash function "
"during initialization, rather than as an input to each compression function."
msgstr "在 BLAKE2 中，盐值会在初始化期间作为对哈希函数的一次性输入而不是对每个压缩函数的输入来处理。"

#: ../../library/hashlib.rst:573
msgid ""
"*Salted hashing* (or just hashing) with BLAKE2 or any other general-purpose "
"cryptographic hash function, such as SHA-256, is not suitable for hashing "
"passwords.  See `BLAKE2 FAQ <https://blake2.net/#qa>`_ for more information."
msgstr ""
"使用 BLAKE2 或任何其他通用加密哈希函数例如 SHA-256 进行 *加盐哈希* (或纯哈希) 并不适用于哈希密码。 请参阅 `BLAKE2 "
"FAQ <https://blake2.net/#qa>`_ 了解更多信息。"

#: ../../library/hashlib.rst:596
msgid "Personalization"
msgstr "个性化"

#: ../../library/hashlib.rst:598
msgid ""
"Sometimes it is useful to force hash function to produce different digests "
"for the same input for different purposes. Quoting the authors of the Skein "
"hash function:"
msgstr "出于不同的目的强制让哈希函数为相同的输入生成不同的摘要有时也是有用的。 正如 Skein 哈希函数的作者所言:"

#: ../../library/hashlib.rst:602
msgid ""
"We recommend that all application designers seriously consider doing this; "
"we have seen many protocols where a hash that is computed in one part of the"
" protocol can be used in an entirely different part because two hash "
"computations were done on similar or related data, and the attacker can "
"force the application to make the hash inputs the same. Personalizing each "
"hash function used in the protocol summarily stops this type of attack."
msgstr ""
"我们建议所有应用设计者慎重考虑这种做法；我们已看到有许多协议在协议的某一部分中计算出来的哈希值在另一个完全不同的部分中也可以被使用，因为两次哈希计算是针对类似或相关的数据进行的，这样攻击者可以强制应用为相同的输入生成哈希值。"
" 个性化协议中所使用的每个哈希函数将有效地阻止这种类型的攻击。"

#: ../../library/hashlib.rst:609
msgid ""
"(`The Skein Hash Function Family <http://www.skein-"
"hash.info/sites/default/files/skein1.3.pdf>`_, p. 21)"
msgstr ""
"(`Skein 哈希函数族 <http://www.skein-"
"hash.info/sites/default/files/skein1.3.pdf>`_, p. 21)"

#: ../../library/hashlib.rst:613
msgid "BLAKE2 can be personalized by passing bytes to the *person* argument::"
msgstr "BLAKE2 可通过向 *person* 参数传入字节串来进行个性化::"

#: ../../library/hashlib.rst:627
msgid ""
"Personalization together with the keyed mode can also be used to derive "
"different keys from a single one."
msgstr "个性化配合密钥模式也可被用来从单个密钥派生出多个不同密钥。"

#: ../../library/hashlib.rst:641
msgid "Tree mode"
msgstr "树形模式"

#: ../../library/hashlib.rst:643
msgid "Here's an example of hashing a minimal tree with two leaf nodes::"
msgstr "以下是对包含两个叶子节点的最小树进行哈希的例子::"

#: ../../library/hashlib.rst:649
msgid ""
"This example uses 64-byte internal digests, and returns the 32-byte final "
"digest::"
msgstr "这个例子使用 64 字节内部摘要，返回 32 字节最终摘要::"

#: ../../library/hashlib.rst:679
msgid "Credits"
msgstr "开发人员"

#: ../../library/hashlib.rst:681
msgid ""
"BLAKE2_ was designed by *Jean-Philippe Aumasson*, *Samuel Neves*, *Zooko "
"Wilcox-O'Hearn*, and *Christian Winnerlein* based on SHA-3_ finalist BLAKE_ "
"created by *Jean-Philippe Aumasson*, *Luca Henzen*, *Willi Meier*, and "
"*Raphael C.-W. Phan*."
msgstr ""
"BLAKE2_ 是由 *Jean-Philippe Aumasson*, *Samuel Neves*, *Zooko Wilcox-O'Hearn* "
"和 *Christian Winnerlein* 基于 *Jean-Philippe Aumasson*, *Luca Henzen*, *Willi "
"Meier* 和 *Raphael C.-W. Phan* 所创造的 SHA-3_ 入围方案 BLAKE_ 进行设计的。"

#: ../../library/hashlib.rst:686
msgid ""
"It uses core algorithm from ChaCha_ cipher designed by *Daniel J.  "
"Bernstein*."
msgstr "它使用的核心算法来自由 *Daniel J. Bernstein* 所设计的 ChaCha_ 加密。"

#: ../../library/hashlib.rst:688
msgid ""
"The stdlib implementation is based on pyblake2_ module. It was written by "
"*Dmitry Chestnykh* based on C implementation written by *Samuel Neves*. The "
"documentation was copied from pyblake2_ and written by *Dmitry Chestnykh*."
msgstr ""
"stdlib 实现是基于 pyblake2_ 模块的。 它由 *Dmitry Chestnykh* 在 *Samuel Neves* 所编写的 C "
"实现的基础上编写。 此文档拷贝自 pyblake2_ 并由 *Dmitry Chestnykh* 撰写。"

#: ../../library/hashlib.rst:692
msgid "The C code was partly rewritten for Python by *Christian Heimes*."
msgstr "C 代码由 *Christian Heimes* 针对 Python 进行了部分的重写。"

#: ../../library/hashlib.rst:694
msgid ""
"The following public domain dedication applies for both C hash function "
"implementation, extension code, and this documentation:"
msgstr "以下公共领域贡献同时适用于 C 哈希函数实现、扩展代码和本文档:"

#: ../../library/hashlib.rst:697
msgid ""
"To the extent possible under law, the author(s) have dedicated all copyright"
" and related and neighboring rights to this software to the public domain "
"worldwide. This software is distributed without any warranty."
msgstr "在法律许可的范围内，作者已将此软件的全部版权以及关联和邻接权利贡献到全球公共领域。 此软件的发布不附带任何担保。"

#: ../../library/hashlib.rst:701
msgid ""
"You should have received a copy of the CC0 Public Domain Dedication along "
"with this software. If not, see "
"https://creativecommons.org/publicdomain/zero/1.0/."
msgstr ""
"你应该已收到此软件附带的 CC0 公共领域专属证书的副本。 如果没有，请参阅 "
"https://creativecommons.org/publicdomain/zero/1.0/。"

#: ../../library/hashlib.rst:705
msgid ""
"The following people have helped with development or contributed their "
"changes to the project and the public domain according to the Creative "
"Commons Public Domain Dedication 1.0 Universal:"
msgstr "根据创意分享公共领域贡献 1.0 通用规范，下列人士为此项目的开发提供了帮助或对公共领域的修改作出了贡献:"

#: ../../library/hashlib.rst:709
msgid "*Alexandr Sokolovskiy*"
msgstr "*Alexandr Sokolovskiy*"

#: ../../library/hashlib.rst:723
msgid "Module :mod:`hmac`"
msgstr "模块 :mod:`hmac`"

#: ../../library/hashlib.rst:723
msgid "A module to generate message authentication codes using hashes."
msgstr "使用哈希运算来生成消息验证代码的模块。"

#: ../../library/hashlib.rst:726
msgid "Module :mod:`base64`"
msgstr "模块 :mod:`base64`"

#: ../../library/hashlib.rst:726
msgid "Another way to encode binary hashes for non-binary environments."
msgstr "针对非二进制环境对二进制哈希值进行编辑的另一种方式。"

#: ../../library/hashlib.rst:729
msgid "https://blake2.net"
msgstr "https://blake2.net"

#: ../../library/hashlib.rst:729
msgid "Official BLAKE2 website."
msgstr "BLAKE2 官方网站"

#: ../../library/hashlib.rst:732
msgid ""
"https://csrc.nist.gov/csrc/media/publications/fips/180/2/archive/2002-08-01/documents/fips180-2.pdf"
msgstr ""
"https://csrc.nist.gov/csrc/media/publications/fips/180/2/archive/2002-08-01/documents/fips180-2.pdf"

#: ../../library/hashlib.rst:732
msgid "The FIPS 180-2 publication on Secure Hash Algorithms."
msgstr "有关安全哈希算法的 FIPS 180-2 出版物。"

#: ../../library/hashlib.rst:736
msgid ""
"https://en.wikipedia.org/wiki/Cryptographic_hash_function#Cryptographic_hash_algorithms"
msgstr ""
"https://en.wikipedia.org/wiki/Cryptographic_hash_function#Cryptographic_hash_algorithms"

#: ../../library/hashlib.rst:735
msgid ""
"Wikipedia article with information on which algorithms have known issues and"
" what that means regarding their use."
msgstr "包含关于哪些算法存在已知问题以及对其使用所造成的影响的信息的 Wikipedia 文章。"

#: ../../library/hashlib.rst:738
msgid "https://www.ietf.org/rfc/rfc2898.txt"
msgstr "https://www.ietf.org/rfc/rfc2898.txt"

#: ../../library/hashlib.rst:739
msgid "PKCS #5: Password-Based Cryptography Specification Version 2.0"
msgstr "PKCS #5: 基于密码的加密规范描述 2.0 版"