Thanos did someting

[bytom/vapor.git] / vendor / github.com / libp2p / go-libp2p-crypto / rsa.go

diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/rsa.go b/vendor/github.com/libp2p/go-libp2p-crypto/rsa.go
deleted file mode 100644 (file)
index e1ab22d..0000000
--- a/vendor/github.com/libp2p/go-libp2p-crypto/rsa.go
+++ /dev/null
@@ -1,152 +0,0 @@
-package crypto
-
-import (
-       "crypto"
-       "crypto/rand"
-       "crypto/rsa"
-       "crypto/x509"
-       "errors"
-       "io"
-
-       pb "github.com/libp2p/go-libp2p-crypto/pb"
-
-       sha256 "github.com/minio/sha256-simd"
-)
-
-// ErrRsaKeyTooSmall is returned when trying to generate or parse an RSA key
-// that's smaller than 512 bits. Keys need to be larger enough to sign a 256bit
-// hash so this is a reasonable absolute minimum.
-var ErrRsaKeyTooSmall = errors.New("rsa keys must be >= 512 bits to be useful")
-
-// RsaPrivateKey is an rsa private key
-type RsaPrivateKey struct {
-       sk *rsa.PrivateKey
-       pk *rsa.PublicKey
-}
-
-// RsaPublicKey is an rsa public key
-type RsaPublicKey struct {
-       k *rsa.PublicKey
-}
-
-// GenerateRSAKeyPair generates a new rsa private and public key
-func GenerateRSAKeyPair(bits int, src io.Reader) (PrivKey, PubKey, error) {
-       if bits < 512 {
-               return nil, nil, ErrRsaKeyTooSmall
-       }
-       priv, err := rsa.GenerateKey(src, bits)
-       if err != nil {
-               return nil, nil, err
-       }
-       pk := &priv.PublicKey
-       return &RsaPrivateKey{sk: priv}, &RsaPublicKey{pk}, nil
-}
-
-// Verify compares a signature against input data
-func (pk *RsaPublicKey) Verify(data, sig []byte) (bool, error) {
-       hashed := sha256.Sum256(data)
-       err := rsa.VerifyPKCS1v15(pk.k, crypto.SHA256, hashed[:], sig)
-       if err != nil {
-               return false, err
-       }
-       return true, nil
-}
-
-func (pk *RsaPublicKey) Type() pb.KeyType {
-       return pb.KeyType_RSA
-}
-
-// Bytes returns protobuf bytes of a public key
-func (pk *RsaPublicKey) Bytes() ([]byte, error) {
-       return MarshalPublicKey(pk)
-}
-
-func (pk *RsaPublicKey) Raw() ([]byte, error) {
-       return x509.MarshalPKIXPublicKey(pk.k)
-}
-
-// Encrypt returns encrypted bytes from the inpu data
-func (pk *RsaPublicKey) Encrypt(b []byte) ([]byte, error) {
-       return rsa.EncryptPKCS1v15(rand.Reader, pk.k, b)
-}
-
-// Equals checks whether this key is equal to another
-func (pk *RsaPublicKey) Equals(k Key) bool {
-       return KeyEqual(pk, k)
-}
-
-// Sign returns a signature of the input data
-func (sk *RsaPrivateKey) Sign(message []byte) ([]byte, error) {
-       hashed := sha256.Sum256(message)
-       return rsa.SignPKCS1v15(rand.Reader, sk.sk, crypto.SHA256, hashed[:])
-}
-
-// GetPublic returns a public key
-func (sk *RsaPrivateKey) GetPublic() PubKey {
-       if sk.pk == nil {
-               sk.pk = &sk.sk.PublicKey
-       }
-       return &RsaPublicKey{sk.pk}
-}
-
-// Decrypt returns decrypted bytes of the input encrypted bytes
-func (sk *RsaPrivateKey) Decrypt(b []byte) ([]byte, error) {
-       return rsa.DecryptPKCS1v15(rand.Reader, sk.sk, b)
-}
-
-func (sk *RsaPrivateKey) Type() pb.KeyType {
-       return pb.KeyType_RSA
-}
-
-// Bytes returns protobuf bytes from a private key
-func (sk *RsaPrivateKey) Bytes() ([]byte, error) {
-       return MarshalPrivateKey(sk)
-}
-
-func (sk *RsaPrivateKey) Raw() ([]byte, error) {
-       b := x509.MarshalPKCS1PrivateKey(sk.sk)
-       return b, nil
-}
-
-// Equals checks whether this key is equal to another
-func (sk *RsaPrivateKey) Equals(k Key) bool {
-       return KeyEqual(sk, k)
-}
-
-// UnmarshalRsaPrivateKey returns a private key from the input x509 bytes
-func UnmarshalRsaPrivateKey(b []byte) (PrivKey, error) {
-       sk, err := x509.ParsePKCS1PrivateKey(b)
-       if err != nil {
-               return nil, err
-       }
-       if sk.N.BitLen() < 512 {
-               return nil, ErrRsaKeyTooSmall
-       }
-       return &RsaPrivateKey{sk: sk}, nil
-}
-
-// MarshalRsaPrivateKey returns the x509 bytes of the private key
-func MarshalRsaPrivateKey(k *RsaPrivateKey) []byte {
-       return x509.MarshalPKCS1PrivateKey(k.sk)
-}
-
-// UnmarshalRsaPublicKey returns a public key from the input x509 bytes
-func UnmarshalRsaPublicKey(b []byte) (PubKey, error) {
-       pub, err := x509.ParsePKIXPublicKey(b)
-       if err != nil {
-               return nil, err
-       }
-       pk, ok := pub.(*rsa.PublicKey)
-       if !ok {
-               return nil, errors.New("not actually an rsa public key")
-       }
-       if pk.N.BitLen() < 512 {
-               return nil, ErrRsaKeyTooSmall
-       }
-       return &RsaPublicKey{pk}, nil
-}
-
-// MarshalRsaPublicKey returns the x509 bytes from the public key
-func MarshalRsaPublicKey(k *RsaPublicKey) ([]byte, error) {
-       return x509.MarshalPKIXPublicKey(k.k)
-}