110 lines
2.2 KiB
Go
110 lines
2.2 KiB
Go
package varsig
|
|
|
|
import (
|
|
"encoding/binary"
|
|
|
|
"github.com/multiformats/go-multicodec"
|
|
)
|
|
|
|
// DiscriminatorRSA is the multicodec.Code specifying an RSA signature.
|
|
const DiscriminatorRSA = Discriminator(multicodec.RsaPub)
|
|
|
|
var _ Varsig = RSAVarsig{}
|
|
|
|
// RSAVarsig is a varsig that encodes the parameters required to describe
|
|
// an RSA signature.
|
|
type RSAVarsig struct {
|
|
varsig
|
|
hashAlg HashAlgorithm
|
|
sigLen uint64
|
|
}
|
|
|
|
// NewRSAVarsig creates and validates an RSA varsig with the provided
|
|
// hash algorithm, key length and payload encoding.
|
|
func NewRSAVarsig(hashAlgorithm HashAlgorithm, keyLength uint64, payloadEncoding PayloadEncoding, opts ...Option) (RSAVarsig, error) {
|
|
options := newOptions(opts...)
|
|
|
|
var (
|
|
vers = Version1
|
|
sig []byte
|
|
)
|
|
|
|
if options.ForceVersion0() {
|
|
vers = Version0
|
|
sig = options.Signature()
|
|
}
|
|
|
|
v := RSAVarsig{
|
|
varsig: varsig{
|
|
vers: vers,
|
|
disc: DiscriminatorRSA,
|
|
payEnc: payloadEncoding,
|
|
sig: sig,
|
|
},
|
|
hashAlg: hashAlgorithm,
|
|
sigLen: keyLength,
|
|
}
|
|
|
|
err := v.validateSig(v.sigLen)
|
|
if err != nil {
|
|
return RSAVarsig{}, err
|
|
}
|
|
|
|
return v, nil
|
|
}
|
|
|
|
// Encode returns the encoded byte format of the RSAVarsig.
|
|
func (v RSAVarsig) Encode() []byte {
|
|
buf := v.encode()
|
|
buf = binary.AppendUvarint(buf, uint64(v.hashAlg))
|
|
buf = binary.AppendUvarint(buf, v.sigLen)
|
|
buf = binary.AppendUvarint(buf, uint64(v.payEnc))
|
|
buf = append(buf, v.Signature()...)
|
|
|
|
return buf
|
|
}
|
|
|
|
// HashAlgorithm returns the hash algorithm used to has the payload content.
|
|
func (v RSAVarsig) HashAlgorithm() HashAlgorithm {
|
|
return v.hashAlg
|
|
}
|
|
|
|
// KeyLength returns the length of the RSA key used to sign the payload
|
|
// content.
|
|
func (v RSAVarsig) KeyLength() uint64 {
|
|
return v.sigLen
|
|
}
|
|
|
|
func decodeRSA(r BytesReader, vers Version, disc Discriminator) (Varsig, error) {
|
|
hashAlg, err := DecodeHashAlgorithm(r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
sigLen, err := binary.ReadUvarint(r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
vs := RSAVarsig{
|
|
varsig: varsig{
|
|
vers: vers,
|
|
disc: disc,
|
|
},
|
|
hashAlg: hashAlg,
|
|
sigLen: sigLen,
|
|
}
|
|
|
|
vs.payEnc, vs.sig, err = vs.decodePayEncAndSig(r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err = vs.validateSig(vs.sigLen)
|
|
if err != nil {
|
|
return RSAVarsig{}, err
|
|
}
|
|
|
|
return vs, nil
|
|
}
|