Пакет 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 (TestKey)] для предварительно сгенерированного ключа размером 2048 бит, предназначенного только для тестов.
[GenerateKey (TestKey)]: #example-GenerateKey-TestKey
Индекс
Примеры
Файлы пакета
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.
Обратите внимание, что возврат ошибки или ее отсутствие раскрывает секретную информацию. Если злоумышленник может заставить эту функцию выполняться многократно и узнать, вернулась ли ошибка в каждом случае, он может дешифровать и подделывать подписи так, как если бы у него был закрытый ключ. См. DecryptPKCS1v15SessionKey для решения этой проблемы.
func DecryptPKCS1v15SessionKey
func DecryptPKCS1v15SessionKey(random io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) error
DecryptPKCS1v15SessionKey дешифрует сессионный ключ с использованием RSA и схемы заполнения из PKCS #1 v1.5. Параметр random устарел и игнорируется, и он может быть nil.
DecryptPKCS1v15SessionKey возвращает ошибку, если зашифрованный текст имеет неправильную длину или если зашифрованный текст больше, чем модуль открытого ключа. В противном случае ошибка не возвращается. Если заполнение корректно, результирующее сообщение открытого текста копируется в ключ. В противном случае ключ остается неизменным. Эти альтернативы происходят в постоянное время. Предполагается, что пользователь этой функции предварительно сгенерирует случайный сессионный ключ и продолжит протокол с полученным значением.
Обратите внимание, что если сессионный ключ слишком мал, злоумышленник может его подобрать методом грубой силы. Если они смогут сделать это, они смогут узнать, использовалось ли случайное значение (потому что оно будет другим для одного и того же зашифрованного текста) и, следовательно, было ли заполнение правильным. Это также лишает смысла использование этой функции. Использование ключа размером как минимум 16 байт защитит от этой атаки.
Этот метод реализует защиту от атак Блайхенбахера на выбор текста с шифрованием [0], описанных в RFC 3218 раздел 2.3.2 [1]. Хотя эти меры защиты значительно затрудняют атаку Блайхенбахера, они эффективны только если остальная часть протокола, использующая DecryptPKCS1v15SessionKey, спроектирована с учетом этих соображений. В частности, если любые последующие операции, которые используют дешифрованный сессионный ключ, выдают любую информацию о ключе (например, является ли он статическим или случайным), то защитные меры будут нарушены. Этот метод должен использоваться очень осторожно и обычно должен использоваться только в том случае, если это совершенно необходимо для совместимости с существующим протоколом (таким как TLS), который спроектирован с учетом этих свойств.
- [0] «Chosen Ciphertext Attacks Against Protocols Based on the RSA Encryption Standard PKCS #1», Daniel Bleichenbacher, Advances in Cryptology (Crypto '98)
- [1] RFC 3218, Preventing the Million Message Attack on CMS, https://www.rfc-editor.org/rfc/rfc3218.html
Пример
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 используется в качестве источника энтропии, чтобы гарантировать, что шифрование одного и того же сообщения дважды не приводит к одному и тому же зашифрованному тексту. Большинство приложений должны использовать crypto/rand.Reader в качестве случайного источника.
Параметр метки может содержать произвольные данные, которые не будут шифроваться, но которые предоставляют важный контекст для сообщения. Например, если заданный открытый ключ используется для шифрования двух типов сообщений, то можно использовать различные значения меток, чтобы гарантировать, что шифртекст для одной цели не может быть использован для другой злоумышленником. Если не требуется, он может быть пустым.
Сообщение не должно быть длиннее, чем длина открытого модуля минус удвоенная длина хэша минус 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 EncryptPKCS1v15
func EncryptPKCS1v15(random io.Reader, pub *PublicKey, msg []byte) ([]byte, error)
EncryptPKCS1v15 шифрует данное сообщение с помощью RSA и схемы заполнения из PKCS #1 v1.5. Сообщение не должно быть длиннее, чем длина открытого модуля минус 11 байтов.
Параметр случайности используется в качестве источника энтропии, чтобы гарантировать, что шифрование одного и того же сообщения дважды не приводит к одному и тому же шифртексту. Большинство приложений должны использовать crypto/rand.Reader в качестве случайности. Обратите внимание, что полученный шифртекст не зависит детерминированно от байтов, считанных из случайности, и может изменяться между вызовами и/или между версиями.
ВНИМАНИЕ: использование этой функции для шифрования простых текстов, отличных от сессионных ключей, опасно. Используйте RSA OAEP в новых протоколах.
func SignPKCS1v15
func SignPKCS1v15(random io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) ([]byte, error)
SignPKCS1v15 вычисляет подпись хэшированного значения с использованием RSASSA-PKCS1-V1_5-SIGN из RSA PKCS #1 v1.5. Обратите внимание, что hashed должно быть результатом хэширования входного сообщения с использованием указанной функции хэширования. Если hash равно нулю, hashed подписывается непосредственно. Это не рекомендуется, за исключением межпротокольной совместимости.
Параметр случайности устарел и игнорируется, и он может быть 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(rand io.Reader, priv *PrivateKey, hash crypto.Hash, digest []byte, opts *PSSOptions) ([]byte, error)
SignPSS вычисляет подпись digest с использованием PSS.
digest должно быть результатом хэширования входного сообщения с использованием указанной функции хэширования. Аргумент opts может быть nil, в этом случае используются разумные значения по умолчанию. Если opts.Hash установлен, он переопределяет hash.
Подпись случайным образом зависит от сообщения, ключа и размера соли, используя байты из rand. Большинство приложений должны использовать crypto/rand.Reader как rand.
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 игнорируется.
Вводные данные не считаются конфиденциальными и могут утечь через временные каналы, или если злоумышленник контролирует часть входных данных.
тип 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).
}
тип OAEPOptions 1.5
OAEPOptions — это интерфейс для передачи параметров дешифрования OAEP с использованием интерфейса crypto.Decrypter.
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
}
тип PKCS1v15DecryptOptions 1.5
PKCS1v15DecryptOptions предназначены для передачи параметров дешифрования PKCS #1 v1.5 с использованием интерфейса crypto.Decrypter.
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
}
тип 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.
тип 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
}
тип PrivateKey
PrivateKey представляет собой открытый ключ RSA
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.
Precomputed PrecomputedValues
}
func GenerateKey
func GenerateKey(random io.Reader, bits int) (*PrivateKey, error)
GenerateKey генерирует случайный закрытый ключ RSA заданного размера в битах.
Если bits меньше 1024, GenerateKey возвращает ошибку. См. раздел "[Минимальный размер ключа]" для получения дополнительной информации.
Большинство приложений должны использовать crypto/rand.Reader как rand. Обратите внимание, что возвращаемый ключ не зависит детерминированно от байтов, считанных из rand, и может изменяться между вызовами и/или между версиями.
[Минимальный размер ключа]: #hdr-Минимальный_размер_ключа
Пример
Код:
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 в "On the Security of Multi-prime RSA" предлагает максимальное количество простых чисел для заданного размера в битах.
Хотя открытые ключи совместимы (на самом деле, неразличимы) с двухпростым случаем, закрытые ключи не являются таковыми. Таким образом, может быть невозможно экспортировать закрытые ключи многократного RSA в определённых форматах или впоследствии импортировать их в другой код.
Этот пакет не реализует оптимизаций CRT для многократного RSA, поэтому ключи с более чем двумя простыми числами будут иметь худшую производительность.
Устарело: использование этой функции с количеством простых чисел, отличным от двух, не рекомендуется по вышеуказанным причинам безопасности, совместимости и производительности. Используйте GenerateKey вместо этого.
func (*PrivateKey) Decrypt 1.5
func (priv *PrivateKey) Decrypt(rand io.Reader, ciphertext []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error)
Decrypt дешифрует шифртекст с 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. Он игнорирует Precomputed значения.
func (*PrivateKey) Precompute
func (priv *PrivateKey) 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, если ключ действителен, или же ошибку, описывающую проблему.
Он работает быстрее на валидных ключах, если запущен после [Precompute].
тип PublicKey
PublicKey представляет собой открытую часть ключа RSA.
Значение модуля N считается секретным в этой библиотеке и защищено от утечки через временные каналы. Однако ни значение экспоненты E, ни точный размер в битах N не защищены аналогичным образом.
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/
