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 }