github.com/keltia/go-ipfs@v0.3.8-0.20150909044612-210793031c63/p2p/crypto/rsa.go (about)

     1  package crypto
     2  
     3  import (
     4  	"crypto"
     5  	"crypto/rand"
     6  	"crypto/rsa"
     7  	"crypto/sha256"
     8  	"crypto/x509"
     9  	"errors"
    10  
    11  	proto "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/gogo/protobuf/proto"
    12  
    13  	pb "github.com/ipfs/go-ipfs/p2p/crypto/pb"
    14  )
    15  
    16  type RsaPrivateKey struct {
    17  	sk *rsa.PrivateKey
    18  	pk *rsa.PublicKey
    19  }
    20  
    21  type RsaPublicKey struct {
    22  	k *rsa.PublicKey
    23  }
    24  
    25  func (pk *RsaPublicKey) Verify(data, sig []byte) (bool, error) {
    26  	hashed := sha256.Sum256(data)
    27  	err := rsa.VerifyPKCS1v15(pk.k, crypto.SHA256, hashed[:], sig)
    28  	if err != nil {
    29  		return false, err
    30  	}
    31  	return true, nil
    32  }
    33  
    34  func (pk *RsaPublicKey) Bytes() ([]byte, error) {
    35  	b, err := x509.MarshalPKIXPublicKey(pk.k)
    36  	if err != nil {
    37  		return nil, err
    38  	}
    39  
    40  	pbmes := new(pb.PublicKey)
    41  	typ := pb.KeyType_RSA
    42  	pbmes.Type = &typ
    43  	pbmes.Data = b
    44  	return proto.Marshal(pbmes)
    45  }
    46  
    47  func (pk *RsaPublicKey) Encrypt(b []byte) ([]byte, error) {
    48  	return rsa.EncryptPKCS1v15(rand.Reader, pk.k, b)
    49  }
    50  
    51  // Equals checks whether this key is equal to another
    52  func (pk *RsaPublicKey) Equals(k Key) bool {
    53  	return KeyEqual(pk, k)
    54  }
    55  
    56  func (pk *RsaPublicKey) Hash() ([]byte, error) {
    57  	return KeyHash(pk)
    58  }
    59  
    60  func (sk *RsaPrivateKey) GenSecret() []byte {
    61  	buf := make([]byte, 16)
    62  	rand.Read(buf)
    63  	return buf
    64  }
    65  
    66  func (sk *RsaPrivateKey) Sign(message []byte) ([]byte, error) {
    67  	hashed := sha256.Sum256(message)
    68  	return rsa.SignPKCS1v15(rand.Reader, sk.sk, crypto.SHA256, hashed[:])
    69  }
    70  
    71  func (sk *RsaPrivateKey) GetPublic() PubKey {
    72  	if sk.pk == nil {
    73  		sk.pk = &sk.sk.PublicKey
    74  	}
    75  	return &RsaPublicKey{sk.pk}
    76  }
    77  
    78  func (sk *RsaPrivateKey) Decrypt(b []byte) ([]byte, error) {
    79  	return rsa.DecryptPKCS1v15(rand.Reader, sk.sk, b)
    80  }
    81  
    82  func (sk *RsaPrivateKey) Bytes() ([]byte, error) {
    83  	b := x509.MarshalPKCS1PrivateKey(sk.sk)
    84  	pbmes := new(pb.PrivateKey)
    85  	typ := pb.KeyType_RSA
    86  	pbmes.Type = &typ
    87  	pbmes.Data = b
    88  	return proto.Marshal(pbmes)
    89  }
    90  
    91  // Equals checks whether this key is equal to another
    92  func (sk *RsaPrivateKey) Equals(k Key) bool {
    93  	return KeyEqual(sk, k)
    94  }
    95  
    96  func (sk *RsaPrivateKey) Hash() ([]byte, error) {
    97  	return KeyHash(sk)
    98  }
    99  
   100  func UnmarshalRsaPrivateKey(b []byte) (*RsaPrivateKey, error) {
   101  	sk, err := x509.ParsePKCS1PrivateKey(b)
   102  	if err != nil {
   103  		return nil, err
   104  	}
   105  	return &RsaPrivateKey{sk: sk}, nil
   106  }
   107  
   108  func MarshalRsaPrivateKey(k *RsaPrivateKey) []byte {
   109  	return x509.MarshalPKCS1PrivateKey(k.sk)
   110  }
   111  
   112  func UnmarshalRsaPublicKey(b []byte) (*RsaPublicKey, error) {
   113  	pub, err := x509.ParsePKIXPublicKey(b)
   114  	if err != nil {
   115  		return nil, err
   116  	}
   117  	pk, ok := pub.(*rsa.PublicKey)
   118  	if !ok {
   119  		return nil, errors.New("Not actually an rsa public key.")
   120  	}
   121  	return &RsaPublicKey{pk}, nil
   122  }
   123  
   124  func MarshalRsaPublicKey(k *RsaPublicKey) ([]byte, error) {
   125  	return x509.MarshalPKIXPublicKey(k.k)
   126  }