README
¶
SRP
An implementation of SRP-6a as documented in RFC 5054 and RFC 2945. It also exports modified versions of routines allowing it to be used with AWS Cognito which uses a variation of SRP.
Generate the verifier:
package main
import "github.com/bodgit/srp"
func main() {
g, err := srp.GetGroup(1024)
if err != nil {
panic(err)
}
s, err := srp.NewSRP(crypto.SHA1, g)
if err != nil {
panic(err)
}
i, err := s.NewISV("username", "password")
if err != nil {
panic(err)
}
// Marshal and store i on the server against the identity
}
Example client:
package main
import "github.com/bodgit/srp"
func main() {
g, err := srp.GetGroup(1024)
if err != nil {
panic(err)
}
s, err := srp.NewSRP(crypto.SHA1, g)
if err != nil {
panic(err)
}
client, err := s.NewClient("username", "password")
if err != nil {
panic(err)
}
// Send identity and client.A() to the server, receive salt and B
m1, err := client.Compute(salt, b)
if err != nil {
panic(err)
}
// Send m1 to the server, receive m2
if err := client.Check(m2); err != nil {
panic(err)
}
// Use client.Key()
}
Example server:
package main
import "github.com/bodgit/srp"
func main() {
g, err := srp.GetGroup(1024)
if err != nil {
panic(err)
}
s, err := srp.NewSRP(crypto.SHA1, g)
if err != nil {
panic(err)
}
// Receive identity and A from client, lookup/unmarshal ISV i
server, err := s.NewServer(i, a)
if err != nil {
panic(err)
}
// Send server.Salt() and server.B() to the client, receive m1
m2, err := server.Check(m1)
if err != nil {
panic(err)
}
// Send m2 to the client, use server.Key()
}
Other implementations
- https://github.com/opencoff/go-srp - Calculates verifier value differently compared to RFC so session keys never match
- https://github.com/Kong/go-srp - Calculates proof values differently compared to RFC but session keys match
- https://github.com/posterity/srp - Interoperates fine
The last two implementations however assume that the client knows their salt value from the start rather than waiting for the server to provide it which doesn't match the behaviour documented in the RFC.
Documentation
¶
Index ¶
- Variables
- func K(f func(*SRP) *big.Int) func(*SRP) error
- func U(f func(*SRP, *big.Int, *big.Int) *big.Int) func(*SRP) error
- func X(f func(*SRP, []byte, []byte, []byte) *big.Int) func(*SRP) error
- type Client
- type Group
- type ISV
- type SRP
- func (s *SRP) Group() *Group
- func (s *SRP) HashBytes(a ...[]byte) []byte
- func (s *SRP) HashInt(a ...[]byte) *big.Int
- func (s *SRP) NewClient(identity, password []byte) (*Client, error)
- func (s *SRP) NewISV(identity, password []byte) (*ISV, error)
- func (s *SRP) NewServer(i *ISV, xA []byte) (*Server, error)
- func (s *SRP) SetK(f func(*SRP) *big.Int) error
- func (s *SRP) SetU(f func(*SRP, *big.Int, *big.Int) *big.Int) error
- func (s *SRP) SetX(f func(*SRP, []byte, []byte, []byte) *big.Int) error
- type Server
Constants ¶
This section is empty.
Variables ¶
var ( // ErrInvalidPublicKey means the public key is invalid. ErrInvalidPublicKey = errors.New("invalid public key") // ErrTrailingBytes means there were additional trailing bytes when // unmarshalling. ErrTrailingBytes = errors.New("trailing bytes") // ErrTooBig means the length of the value exceeds the size of a 16-bit // integer. ErrTooBig = fmt.Errorf("value exceeds %d bytes", math.MaxUint16) )
Functions ¶
Types ¶
type Client ¶
type Client struct {
// contains filtered or unexported fields
}
Client represents the client-side of an SRP session.
func (*Client) Compute ¶
Compute takes the salt and public value provided by the server and computes the proofs and shared key. It returns the M1 proof to be sent to the server.
func (*Client) S ¶
S returns the computed S value after c.Compute() has been called, otherwise an error is returned.
func (*Client) SetIdentity ¶
SetIdentity sets the client identity.
type Group ¶
Group represents the SRP group parameters.
type ISV ¶
type ISV struct {
Identity []byte `json:"identity"`
Salt []byte `json:"salt"`
Verifier []byte `json:"verifier"`
}
ISV holds the triplet of the Identity, Salt, and Verifier. It implements encoding.BinaryMarshaler and encoding.BinaryUnmarshaler so it can be serialized to and from persistent storage.
func (*ISV) MarshalBinary ¶
MarshalBinary satisfies the encoding.BinaryMarshaler interface.
func (*ISV) UnmarshalBinary ¶
UnmarshalBinary satisfies the encoding.BinaryUnmarshaler interface.
type SRP ¶
type SRP struct {
// contains filtered or unexported fields
}
SRP manages the various computations used in the SRP protocol.
type Server ¶
type Server struct {
// contains filtered or unexported fields
}
Server represents the server-side of an SRP session. It implements encoding.BinaryMarshaler and encoding.BinaryUnmarshaler so it can be serialized to and from persistent storage.
func (*Server) Check ¶
Check compares the M1 proof computed by the client with the servers copy. If it is identical then the servers M2 proof is returned to be sent back to the client.
func (*Server) MarshalBinary ¶
MarshalBinary satisfies the encoding.BinaryMarshaler interface.
func (*Server) UnmarshalBinary ¶
UnmarshalBinary satisfies the encoding.BinaryUnmarshaler interface.
Source Files
¶
Directories
¶
| Path | Synopsis |
|---|---|
|
Package cognito contains the SRP primitives that differ between RFC 5054 and the AWS Cognito implementation.
|
Package cognito contains the SRP primitives that differ between RFC 5054 and the AWS Cognito implementation. |
|
internal
|
|
|
rfc5054
Package rfc5054 provides the prime numbers and test vectors documented in RFC 5054.
|
Package rfc5054 provides the prime numbers and test vectors documented in RFC 5054. |