Пакет rsa
Обзор
Пакет rsa реализует шифрование RSA согласно спецификации PKCS #1 и RFC 8017.
RSA — это единичная фундаментальная операция, используемая в этом пакете для реализации шифрования с открытым ключом или подписей с открытым ключом.
Исходная спецификация шифрования и подписей с использованием RSA — PKCS #1, и термины «шифрование RSA» и «подписи RSA» по умолчанию относятся к версии 1.5 PKCS #1. Однако эта спецификация содержит недостатки, и в новых разработках по возможности следует использовать версию 2, обычно называемую просто OAEP и PSS.
В этот пакет включены два набора интерфейсов. Если более абстрактный интерфейс не требуется, доступны функции шифрования/расшифрования с использованием v1.5/OAEP и подписания/проверки с использованием v1.5/PSS. Если необходимо абстрагироваться от примитива открытого ключа, тип PrivateKey реализует интерфейсы Decrypter и Signer из пакета crypto.
Операции с закрытыми ключами реализованы с использованием алгоритмов с постоянным временем выполнения, за исключением GenerateKey и некоторых операций с устаревшими ключами с несколькими простыми множителями.
Минимальный размер ключа
GenerateKey возвращает ошибку, если запрошен ключ размером менее 1024 бит, а все методы Sign, Verify, Encrypt и Decrypt возвращают ошибку при использовании с ключом размером менее 1024 бит. Такие ключи небезопасны, и их не следует использовать.
Настройка rsa1024min=0 GODEBUG подавляет эту ошибку, но мы рекомендуем делать это только в тестах, если это необходимо. Тесты могут задать этот параметр с помощью testing.T.Setenv или добавив строку «//go:debug rsa1024min=0» в исходный файл *_test.go.
Также можно воспользоваться примером GenerateKey (тестовый ключ), в котором приведён заранее сгенерированный тестовый ключ размером 2048 бит.
Указатель
Примеры
Файлы пакета
fips.go notboring.go pkcs1v15.go rsa.go
Константы
const (
// PSSSaltLengthAuto causes the salt in a PSS signature to be as large
// as possible when signing, and to be auto-detected when verifying.
//
// When signing in FIPS 140-3 mode, the salt length is capped at the length
// of the hash function used in the signature.
PSSSaltLengthAuto = 0
// PSSSaltLengthEqualsHash causes the salt length to equal the length
// of the hash used in the signature.
PSSSaltLengthEqualsHash = -1
) Переменные
ErrDecryption обозначает невозможность расшифровать сообщение. Описание намеренно сформулировано расплывчато, чтобы избежать адаптивных атак.
var ErrDecryption = errors.New("crypto/rsa: decryption error") ErrMessageTooLong возвращается при попытке зашифровать или подписать сообщение, слишком большое для размера ключа. При использовании SignPSS эта ошибка также может возвращаться, если размер соли слишком велик.
var ErrMessageTooLong = errors.New("crypto/rsa: message too long for RSA key size") ErrVerification обозначает невозможность проверить подпись. Описание намеренно сформулировано расплывчато, чтобы избежать адаптивных атак.
var ErrVerification = errors.New("crypto/rsa: verification error") func DecryptOAEP
func DecryptOAEP(hash hash.Hash, random io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) ([]byte, error)
DecryptOAEP расшифровывает шифротекст с использованием RSA-OAEP.
OAEP параметризуется хеш-функцией, используемой в качестве случайного оракула. Для шифрования и расшифрования одного и того же сообщения необходимо использовать одну и ту же хеш-функцию; подходящим выбором будет sha256.New().
Параметр random оставлен для обратной совместимости и игнорируется; он может быть nil.
Параметр label должен совпадать со значением, заданным при шифровании. Подробности см. в описании EncryptOAEP.
Пример
Код:
ciphertext, _ := hex.DecodeString("4d1ee10e8f286390258c51a5e80802844c3e6358ad6690b7285218a7c7ed7fc3a4c7b950fbd04d4b0239cc060dcc7065ca6f84c1756deb71ca5685cadbb82be025e16449b905c568a19c088a1abfad54bf7ecc67a7df39943ec511091a34c0f2348d04e058fcff4d55644de3cd1d580791d4524b92f3e91695582e6e340a1c50b6c6d78e80b4e42c5b4d45e479b492de42bbd39cc642ebb80226bb5200020d501b24a37bcc2ec7f34e596b4fd6b063de4858dbf5a4e3dd18e262eda0ec2d19dbd8e890d672b63d368768360b20c0b6b8592a438fa275e5fa7f60bef0dd39673fd3989cc54d2cb80c08fcd19dacbc265ee1c6014616b0e04ea0328c2a04e73460")
label := []byte("orders")
plaintext, err := rsa.DecryptOAEP(sha256.New(), nil, test2048Key, ciphertext, label)
if err != nil {
fmt.Fprintf(os.Stderr, "Error from decryption: %s\n", err)
return
}
fmt.Printf("Plaintext: %s\n", plaintext)
// Remember that encryption only provides confidentiality. The
// ciphertext should be signed before authenticity is assumed and, even
// then, consider that messages might be reordered.
func DecryptPKCS1v15
func DecryptPKCS1v15(random io.Reader, priv *PrivateKey, ciphertext []byte) ([]byte, error)
DecryptPKCS1v15 расшифровывает открытый текст с использованием RSA и схемы дополнения из PKCS #1 v1.5. Параметр random оставлен для обратной совместимости и игнорируется; он может быть nil.
Устарело: шифрование PKCS #1 v1.5 опасно и не должно использоваться. Независимо от того, возвращает ли эта функция ошибку, она раскрывает секретную информацию. Если злоумышленник может многократно вызывать эту функцию и узнавать, возвращала ли каждая попытка ошибку, он сможет расшифровывать данные и подделывать подписи так, словно у него есть закрытый ключ. Подробнее см. в документе draft-irtf-cfrg-rsa-guidance-05. Вместо этого используйте EncryptOAEP и DecryptOAEP.
func DecryptPKCS1v15SessionKey
func DecryptPKCS1v15SessionKey(random io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) error
DecryptPKCS1v15SessionKey расшифровывает ключ сеанса с помощью RSA и схемы дополнения из PKCS #1 v1.5. Параметр random оставлен для совместимости и игнорируется; он может быть nil.
DecryptPKCS1v15SessionKey возвращает ошибку, если длина шифротекста неправильна или если шифротекст больше открытого модуля. В противном случае ошибка не возвращается. Если дополнение корректно, полученное сообщение в открытом виде копируется в key. В противном случае key не изменяется. Эти варианты обрабатываются за постоянное время. Предполагается, что пользователь этой функции заранее генерирует случайный ключ сеанса и продолжает протокол с полученным значением.
Обратите внимание: если ключ сеанса слишком короткий, злоумышленник может перебрать все его варианты. Если это удастся, он сможет определить, использовалось ли случайное значение (поскольку для одного и того же шифротекста оно будет отличаться), а значит, и было ли дополнение корректным. Это также сводит на нет назначение этой функции. Использование ключа длиной не менее 16 байт защитит от этой атаки.
Этот метод реализует защиту от атак с выбранным шифротекстом Блейхенбахера [0], описанную в разделе 2.3.2 RFC 3218 [1]. Хотя эта защита значительно затрудняет атаку Блейхенбахера, она эффективна только в том случае, если остальная часть протокола, использующего DecryptPKCS1v15SessionKey, разработана с учетом этих особенностей. В частности, если какие-либо последующие операции с расшифрованным ключом сеанса раскрывают информацию о ключе (например, является ли он постоянным или случайным), средства защиты перестают работать. Этот метод следует использовать с особой осторожностью; как правило, прибегать к нему следует только в случае крайней необходимости для совместимости с существующим протоколом (например, TLS), разработанным с учетом этих свойств.
- [0] «Атаки с выбранным шифротекстом на протоколы, основанные на стандарте шифрования RSA PKCS #1», Даниэль Блейхенбахер, Advances in Cryptology (Crypto '98)
- [1] RFC 3218, Предотвращение атаки миллиона сообщений на CMS, https://www.rfc-editor.org/rfc/rfc3218.html
Устарело: шифрование PKCS #1 v1.5 опасно и не должно использоваться. Реализованные этой функцией средства защиты ограничены и ненадежны, как объяснено выше. Подробнее см. в документе draft-irtf-cfrg-rsa-guidance-05. Вместо этого используйте EncryptOAEP и DecryptOAEP.
Пример
RSA позволяет шифровать лишь очень ограниченный объем данных. Для шифрования значительных объемов данных обычно используют гибридную схему: RSA шифрует ключ симметричного алгоритма, например AES-GCM. Перед шифрованием данные «дополняются» путем помещения их в известную структуру. Это делается по нескольким причинам, но наиболее очевидная — гарантировать, что значение достаточно велико и результат возведения в степень превышает модуль. (В противном случае его можно было бы расшифровать с помощью извлечения квадратного корня.) В таких схемах при использовании PKCS #1 v1.5 крайне важно не раскрывать, было ли полученное сообщение RSA корректно сформировано (то есть является ли результат расшифрования сообщением с корректным дополнением), поскольку это раскрывает секретную информацию. DecryptPKCS1v15SessionKey предназначена для такой ситуации: она за постоянное время копирует расшифрованный симметричный ключ (если сообщение корректно сформировано) поверх буфера, содержащего случайный ключ. Таким образом, если результат RSA сформирован некорректно, реализация за постоянное время использует случайный ключ.
Код:
// The hybrid scheme should use at least a 16-byte symmetric key. Here
// we read the random key that will be used if the RSA decryption isn't
// well-formed.
key := make([]byte, 32)
if _, err := rand.Read(key); err != nil {
panic("RNG failure")
}
rsaCiphertext, _ := hex.DecodeString("aabbccddeeff")
if err := rsa.DecryptPKCS1v15SessionKey(nil, rsaPrivateKey, rsaCiphertext, key); err != nil {
// Any errors that result will be “public” – meaning that they
// can be determined without any secret information. (For
// instance, if the length of key is impossible given the RSA
// public key.)
fmt.Fprintf(os.Stderr, "Error from RSA decryption: %s\n", err)
return
}
// Given the resulting key, a symmetric scheme can be used to decrypt a
// larger ciphertext.
block, err := aes.NewCipher(key)
if err != nil {
panic("aes.NewCipher failed: " + err.Error())
}
// Since the key is random, using a fixed nonce is acceptable as the
// (key, nonce) pair will still be unique, as required.
var zeroNonce [12]byte
aead, err := cipher.NewGCM(block)
if err != nil {
panic("cipher.NewGCM failed: " + err.Error())
}
ciphertext, _ := hex.DecodeString("00112233445566")
plaintext, err := aead.Open(nil, zeroNonce[:], ciphertext, nil)
if err != nil {
// The RSA ciphertext was badly formed; the decryption will
// fail here because the AES-GCM key will be incorrect.
fmt.Fprintf(os.Stderr, "Error decrypting: %s\n", err)
return
}
fmt.Printf("Plaintext: %s\n", plaintext)
func EncryptOAEP
func EncryptOAEP(hash hash.Hash, random io.Reader, pub *PublicKey, msg []byte, label []byte) ([]byte, error)
EncryptOAEP шифрует заданное сообщение с помощью RSA-OAEP.
В OAEP используется хеш-функция в качестве случайного оракула. Для шифрования и расшифрования заданного сообщения необходимо использовать одну и ту же хеш-функцию; разумным выбором будет sha256.New().
Параметр random используется как источник энтропии, чтобы шифрование одного и того же сообщения дважды не приводило к одинаковому шифротексту. В большинстве приложений в качестве random следует использовать crypto/rand.Reader.
Параметр label может содержать произвольные данные, которые не будут зашифрованы, но задают важный контекст сообщения. Например, если один открытый ключ используется для шифрования двух типов сообщений, можно использовать разные значения label, чтобы злоумышленник не мог применить шифротекст, предназначенный для одной цели, для другой. Если параметр не требуется, его можно оставить пустым.
Длина сообщения не должна превышать длину открытого модуля минус удвоенная длина хеша и еще 2.
Пример
Код:
secretMessage := []byte("send reinforcements, we're going to advance")
label := []byte("orders")
// crypto/rand.Reader is a good source of entropy for randomizing the
// encryption function.
rng := rand.Reader
ciphertext, err := rsa.EncryptOAEP(sha256.New(), rng, &test2048Key.PublicKey, secretMessage, label)
if err != nil {
fmt.Fprintf(os.Stderr, "Error from encryption: %s\n", err)
return
}
// Since encryption is a randomized function, ciphertext will be
// different each time.
fmt.Printf("Ciphertext: %x\n", ciphertext)
func EncryptOAEPWithOptions 1.26
func EncryptOAEPWithOptions(random io.Reader, pub *PublicKey, msg []byte, opts *OAEPOptions) ([]byte, error)
EncryptOAEPWithOptions шифрует заданное сообщение с помощью RSA-OAEP, используя указанные параметры.
Эту функцию следует использовать вместо EncryptOAEP только в том случае, если необходимо отдельно указать хеш-функции для OAEP и MGF1.
Дополнительные сведения см. в описании EncryptOAEP.
func EncryptPKCS1v15
func EncryptPKCS1v15(random io.Reader, pub *PublicKey, msg []byte) ([]byte, error)
EncryptPKCS1v15 шифрует заданное сообщение с помощью RSA и схемы дополнения из PKCS #1 v1.5. Длина сообщения не должна превышать длину открытого модуля минус 11 байт.
Параметр random используется как источник энтропии, чтобы шифрование одного и того же сообщения дважды не приводило к одинаковому шифротексту. Начиная с Go 1.26 всегда используется безопасный источник случайных байтов, а Reader игнорируется, если не задано GODEBUG=cryptocustomrand=1. Эта настройка будет удалена в одном из будущих выпусков Go. Вместо нее используйте testing/cryptotest.SetGlobalRandom.
Устарело: шифрование PKCS #1 v1.5 опасно и не должно использоваться. Подробнее см. в документе draft-irtf-cfrg-rsa-guidance-05. Вместо этого используйте EncryptOAEP и DecryptOAEP.
func SignPKCS1v15
func SignPKCS1v15(random io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) ([]byte, error)
SignPKCS1v15 вычисляет подпись для hashed с помощью RSASSA-PKCS1-V1_5-SIGN из RSA PKCS #1 v1.5. Обратите внимание: hashed должен быть результатом хеширования входного сообщения с помощью заданной хеш-функции. Если hash равен нулю, подпись вычисляется непосредственно для hashed. Это не рекомендуется, кроме случаев, когда это необходимо для взаимодействия с другими системами.
Параметр random оставлен для совместимости и игнорируется; он может быть nil.
Эта функция детерминирована. Поэтому, если множество возможных сообщений невелико, злоумышленник может составить таблицу соответствия сообщений подписям и определить, какие сообщения были подписаны. Как всегда, подписи обеспечивают подлинность, а не конфиденциальность.
Пример
Код:
message := []byte("message to be signed")
// Only small messages can be signed directly; thus the hash of a
// message, rather than the message itself, is signed. This requires
// that the hash function be collision resistant. SHA-256 is the
// least-strong hash function that should be used for this at the time
// of writing (2016).
hashed := sha256.Sum256(message)
signature, err := rsa.SignPKCS1v15(nil, rsaPrivateKey, crypto.SHA256, hashed[:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error from signing: %s\n", err)
return
}
fmt.Printf("Signature: %x\n", signature)
func SignPSS 1.2
func SignPSS(random io.Reader, priv *PrivateKey, hash crypto.Hash, digest []byte, opts *PSSOptions) ([]byte, error)
SignPSS вычисляет подпись дайджеста с помощью PSS.
digest должен быть результатом хеширования входного сообщения с использованием заданной хеш-функции. Аргумент opts может быть nil, в этом случае используются разумные значения по умолчанию. Если задан opts.Hash, он переопределяет hash.
Подпись рандомизирована в зависимости от сообщения, ключа и размера соли; для этого используются байты из random. В большинстве приложений в качестве random следует использовать crypto/rand.Reader.
func VerifyPKCS1v15
func VerifyPKCS1v15(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte) error
VerifyPKCS1v15 проверяет подпись RSA PKCS #1 v1.5. hashed — результат хеширования входного сообщения с использованием заданной хеш-функции, а sig — подпись. Действительность подписи обозначается возвратом ошибки nil. Если hash равен нулю, hashed используется напрямую. Это не рекомендуется, за исключением случаев, когда необходима совместимость.
Входные данные не считаются конфиденциальными и могут утечь через побочные каналы по времени или в случае, если злоумышленник контролирует часть входных данных.
Пример
Код:
message := []byte("message to be signed")
signature, _ := hex.DecodeString("ad2766728615cc7a746cc553916380ca7bfa4f8983b990913bc69eb0556539a350ff0f8fe65ddfd3ebe91fe1c299c2fac135bc8c61e26be44ee259f2f80c1530")
// Only small messages can be signed directly; thus the hash of a
// message, rather than the message itself, is signed. This requires
// that the hash function be collision resistant. SHA-256 is the
// least-strong hash function that should be used for this at the time
// of writing (2016).
hashed := sha256.Sum256(message)
err := rsa.VerifyPKCS1v15(&rsaPrivateKey.PublicKey, crypto.SHA256, hashed[:], signature)
if err != nil {
fmt.Fprintf(os.Stderr, "Error from verification: %s\n", err)
return
}
// signature is a valid signature of message from the public key.
func VerifyPSS 1.2
func VerifyPSS(pub *PublicKey, hash crypto.Hash, digest []byte, sig []byte, opts *PSSOptions) error
VerifyPSS проверяет подпись PSS.
Действительность подписи обозначается возвратом ошибки nil. digest должен быть результатом хеширования входного сообщения с использованием заданной хеш-функции. Аргумент opts может быть nil, в этом случае используются разумные значения по умолчанию. opts.Hash игнорируется.
Входные данные не считаются конфиденциальными и могут утечь через побочные каналы по времени или в случае, если злоумышленник контролирует часть входных данных.
type CRTValue
CRTValue содержит предварительно вычисленные значения китайской теоремы об остатках.
type CRTValue struct {
Exp *big.Int // D mod (prime-1).
Coeff *big.Int // R·Coeff ≡ 1 mod Prime.
R *big.Int // product of primes prior to this (inc p and q).
}
type OAEPOptions 1.5
OAEPOptions позволяет передавать параметры шифрования и расшифрования OAEP через функции PrivateKey.Decrypt и EncryptOAEPWithOptions.
type OAEPOptions struct {
// Hash is the hash function that will be used when generating the mask.
Hash crypto.Hash
// MGFHash is the hash function used for MGF1.
// If zero, Hash is used instead.
MGFHash crypto.Hash // Go 1.20
// Label is an arbitrary byte string that must be equal to the value
// used when encrypting.
Label []byte
}
type PKCS1v15DecryptOptions 1.5
PKCS1v15DecryptOptions используется для передачи параметров расшифрования PKCS #1 v1.5 с помощью интерфейса crypto.Decrypter.
Устарело: шифрование PKCS #1 v1.5 опасно и не должно использоваться. Дополнительные сведения см. в документе draft-irtf-cfrg-rsa-guidance-05. Вместо этого используйте EncryptOAEP и DecryptOAEP.
type PKCS1v15DecryptOptions struct {
// SessionKeyLen is the length of the session key that is being
// decrypted. If not zero, then a padding error during decryption will
// cause a random plaintext of this length to be returned rather than
// an error. These alternatives happen in constant time.
SessionKeyLen int
}
type PSSOptions 1.2
PSSOptions содержит параметры для создания и проверки подписей PSS.
type PSSOptions struct {
// SaltLength controls the length of the salt used in the PSS signature. It
// can either be a positive number of bytes, or one of the special
// PSSSaltLength constants.
SaltLength int
// Hash is the hash function used to generate the message digest. If not
// zero, it overrides the hash function passed to SignPSS. It's required
// when using PrivateKey.Sign.
Hash crypto.Hash // Go 1.4
}
func (*PSSOptions) HashFunc 1.4
func (opts *PSSOptions) HashFunc() crypto.Hash
HashFunc возвращает opts.Hash, благодаря чему PSSOptions реализует crypto.SignerOpts.
type PrecomputedValues
type PrecomputedValues struct {
Dp, Dq *big.Int // D mod (P-1) (or mod Q-1)
Qinv *big.Int // Q^-1 mod P
// CRTValues is used for the 3rd and subsequent primes. Due to a
// historical accident, the CRT for the first two primes is handled
// differently in PKCS #1 and interoperability is sufficiently
// important that we mirror this.
//
// Deprecated: These values are still filled in by Precompute for
// backwards compatibility but are not used. Multi-prime RSA is very rare,
// and is implemented by this package without CRT optimizations to limit
// complexity.
CRTValues []CRTValue
// contains filtered or unexported fields
}
type PrivateKey
PrivateKey представляет ключ RSA.
Его поля нельзя изменять после вызова PrivateKey.Precompute, а сами поля не следует напрямую использовать как значения big.Int в криптографических целях.
type PrivateKey struct {
PublicKey // public part.
D *big.Int // private exponent
Primes []*big.Int // prime factors of N, has >= 2 elements.
// Precomputed contains precomputed values that speed up RSA operations,
// if available. It must be generated by calling PrivateKey.Precompute and
// must not be modified afterwards.
Precomputed PrecomputedValues
}
func GenerateKey
func GenerateKey(random io.Reader, bits int) (*PrivateKey, error)
GenerateKey генерирует случайный закрытый ключ RSA заданного размера в битах.
Если bits меньше 1024, GenerateKey возвращает ошибку. Дополнительные сведения см. в разделе «Минимальный размер ключа».
Начиная с Go 1.26 всегда используется безопасный источник случайных байтов, а Reader игнорируется, если не задано GODEBUG=cryptocustomrand=1. Эта настройка будет удалена в одном из будущих выпусков Go. Вместо этого используйте testing/cryptotest.SetGlobalRandom.
Пример
Код:
privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
fmt.Fprintf(os.Stderr, "Error generating RSA key: %s", err)
return
}
der, err := x509.MarshalPKCS8PrivateKey(privateKey)
if err != nil {
fmt.Fprintf(os.Stderr, "Error marshalling RSA private key: %s", err)
return
}
fmt.Printf("%s", pem.EncodeToMemory(&pem.Block{
Type: "PRIVATE KEY",
Bytes: der,
}))
Пример (TestKey)
Код:
// This is an insecure, test-only key from RFC 9500, Section 2.1.
// It can be used in tests to avoid slow key generation.
block, _ := pem.Decode([]byte(strings.ReplaceAll(
`-----BEGIN RSA TESTING KEY-----
MIIEowIBAAKCAQEAsPnoGUOnrpiSqt4XynxA+HRP7S+BSObI6qJ7fQAVSPtRkqso
tWxQYLEYzNEx5ZSHTGypibVsJylvCfuToDTfMul8b/CZjP2Ob0LdpYrNH6l5hvFE
89FU1nZQF15oVLOpUgA7wGiHuEVawrGfey92UE68mOyUVXGweJIVDdxqdMoPvNNU
l86BU02vlBiESxOuox+dWmuVV7vfYZ79Toh/LUK43YvJh+rhv4nKuF7iHjVjBd9s
B6iDjj70HFldzOQ9r8SRI+9NirupPTkF5AKNe6kUhKJ1luB7S27ZkvB3tSTT3P59
3VVJvnzOjaA1z6Cz+4+eRvcysqhrRgFlwI9TEwIDAQABAoIBAEEYiyDP29vCzx/+
dS3LqnI5BjUuJhXUnc6AWX/PCgVAO+8A+gZRgvct7PtZb0sM6P9ZcLrweomlGezI
FrL0/6xQaa8bBr/ve/a8155OgcjFo6fZEw3Dz7ra5fbSiPmu4/b/kvrg+Br1l77J
aun6uUAs1f5B9wW+vbR7tzbT/mxaUeDiBzKpe15GwcvbJtdIVMa2YErtRjc1/5B2
BGVXyvlJv0SIlcIEMsHgnAFOp1ZgQ08aDzvilLq8XVMOahAhP1O2A3X8hKdXPyrx
IVWE9bS9ptTo+eF6eNl+d7htpKGEZHUxinoQpWEBTv+iOoHsVunkEJ3vjLP3lyI/
fY0NQ1ECgYEA3RBXAjgvIys2gfU3keImF8e/TprLge1I2vbWmV2j6rZCg5r/AS0u
pii5CvJ5/T5vfJPNgPBy8B/yRDs+6PJO1GmnlhOkG9JAIPkv0RBZvR0PMBtbp6nT
Y3yo1lwamBVBfY6rc0sLTzosZh2aGoLzrHNMQFMGaauORzBFpY5lU50CgYEAzPHl
u5DI6Xgep1vr8QvCUuEesCOgJg8Yh1UqVoY/SmQh6MYAv1I9bLGwrb3WW/7kqIoD
fj0aQV5buVZI2loMomtU9KY5SFIsPV+JuUpy7/+VE01ZQM5FdY8wiYCQiVZYju9X
Wz5LxMNoz+gT7pwlLCsC4N+R8aoBk404aF1gum8CgYAJ7VTq7Zj4TFV7Soa/T1eE
k9y8a+kdoYk3BASpCHJ29M5R2KEA7YV9wrBklHTz8VzSTFTbKHEQ5W5csAhoL5Fo
qoHzFFi3Qx7MHESQb9qHyolHEMNx6QdsHUn7rlEnaTTyrXh3ifQtD6C0yTmFXUIS
CW9wKApOrnyKJ9nI0HcuZQKBgQCMtoV6e9VGX4AEfpuHvAAnMYQFgeBiYTkBKltQ
XwozhH63uMMomUmtSG87Sz1TmrXadjAhy8gsG6I0pWaN7QgBuFnzQ/HOkwTm+qKw
AsrZt4zeXNwsH7QXHEJCFnCmqw9QzEoZTrNtHJHpNboBuVnYcoueZEJrP8OnUG3r
UjmopwKBgAqB2KYYMUqAOvYcBnEfLDmyZv9BTVNHbR2lKkMYqv5LlvDaBxVfilE0
2riO4p6BaAdvzXjKeRrGNEKoHNBpOSfYCOM16NjL8hIZB1CaV3WbT5oY+jp7Mzd5
7d56RZOE+ERK2uz/7JX9VSsM/LbH9pJibd4e8mikDS9ntciqOH/3
-----END RSA TESTING KEY-----`, "TESTING KEY", "PRIVATE KEY")))
testRSA2048, _ := x509.ParsePKCS1PrivateKey(block.Bytes)
fmt.Println("Private key bit size:", testRSA2048.N.BitLen())
func GenerateMultiPrimeKey
func GenerateMultiPrimeKey(random io.Reader, nprimes int, bits int) (*PrivateKey, error)
GenerateMultiPrimeKey генерирует многопростойную пару ключей RSA заданного размера в битах, используя указанный источник случайных данных.
В таблице 1 документа «О безопасности многопростойного RSA» приведены рекомендуемые максимальные количества простых чисел для заданных размеров ключа.
Хотя открытые ключи совместимы с ключами для случая с двумя простыми числами (фактически неотличимы от них), закрытые ключи — нет. Поэтому может оказаться невозможным экспортировать многопростые закрытые ключи в некоторых форматах или впоследствии импортировать их в другой код.
Этот пакет не реализует оптимизации CRT для многопростого RSA, поэтому ключи с более чем двумя простыми числами будут работать медленнее.
Начиная с Go 1.26 всегда используется безопасный источник случайных байтов, а Reader игнорируется, если не задано GODEBUG=cryptocustomrand=1. Эта настройка будет удалена в одном из будущих выпусков Go. Вместо этого используйте testing/cryptotest.SetGlobalRandom.
Устарело: использование этой функции с количеством простых чисел, отличным от двух, не рекомендуется по указанным выше причинам безопасности, совместимости и производительности. Вместо этого используйте GenerateKey.
func (*PrivateKey) Decrypt 1.5
func (priv *PrivateKey) Decrypt(rand io.Reader, ciphertext []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error)
Decrypt расшифровывает ciphertext с помощью priv. Если opts равен nil или имеет тип *PKCS1v15DecryptOptions, выполняется расшифрование PKCS #1 v1.5. В противном случае opts должен иметь тип *OAEPOptions, и выполняется расшифрование OAEP.
func (*PrivateKey) Equal 1.15
func (priv *PrivateKey) Equal(x crypto.PrivateKey) bool
Equal сообщает, имеют ли priv и x эквивалентные значения. Предварительно вычисленные значения игнорируются.
func (*PrivateKey) Precompute
func (priv *PrivateKey) Precompute()
Precompute выполняет вычисления, ускоряющие последующие операции с закрытым ключом. Функцию безопасно вызывать для непроверенных закрытых ключей; она также может ускорить последующие вызовы PrivateKey.Validate для корректных ключей.
Precompute записывает данные в поле Precomputed, поэтому эту функцию нельзя вызывать одновременно с любым другим методом.
Precompute не возвращает ошибку. После вызова Precompute приложениям следует вызвать PrivateKey.Validate, чтобы проверить ключ на наличие проблем, в том числе тех, которые могли бы привести к сбою Precompute.
Повторный вызов Precompute для уже предварительно вычисленного ключа ничего не делает.
func (*PrivateKey) Public 1.4
func (priv *PrivateKey) Public() crypto.PublicKey
Public возвращает открытый ключ, соответствующий priv.
func (*PrivateKey) Sign 1.4
func (priv *PrivateKey) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error)
Sign подписывает digest с помощью priv, считывая случайные данные из rand. Если opts имеет тип *PSSOptions, используется алгоритм PSS; в противном случае используется PKCS #1 v1.5. digest должен быть результатом хеширования входного сообщения с использованием opts.HashFunc().
Этот метод реализует интерфейс crypto.Signer, предназначенный для поддержки ключей, закрытая часть которых хранится, например, в аппаратном модуле. В обычных случаях следует напрямую использовать функции Sign* из этого пакета.
func (*PrivateKey) Validate
func (priv *PrivateKey) Validate() error
Validate выполняет базовые проверки корректности ключа. Если ключ действителен, метод возвращает nil, в противном случае — ошибку с описанием проблемы.
При запуске после PrivateKey.Precompute проверка действительных ключей выполняется быстрее.
type PublicKey
PublicKey представляет открытую часть ключа RSA.
Значения N и E не считаются конфиденциальными и могут утечь через побочные каналы либо быть математически выведены из других открытых значений.
type PublicKey struct {
N *big.Int // modulus
E int // public exponent
}
func (*PublicKey) Equal 1.15
func (pub *PublicKey) Equal(x crypto.PublicKey) bool
Equal сообщает, имеют ли pub и x одинаковые значения.
func (*PublicKey) Size 1.11
func (pub *PublicKey) Size() int
Size возвращает размер модуля в байтах. Сырые подписи и зашифрованные данные, созданные этим открытым ключом или для него, будут иметь одинаковый размер.
© Google, Inc.
Licensed under the Creative Commons Attribution License 3.0.
http://golang.org/pkg/crypto/rsa/
