// checkReverseSig verifies that the reverse sig in jw is valid
// and matches jw.
func (e *Kex2Provisioner) checkReverseSig(jw *jsonw.Wrapper) error {
kid, err := jw.AtPath("body.sibkey.kid").GetString()
if err != nil {
return err
}
keypair, err := libkb.ImportKeypairFromKID(keybase1.KIDFromString(kid))
if err != nil {
return err
}
revsig, err := jw.AtPath("body.sibkey.reverse_sig").GetString()
if err != nil {
return err
}
// set reverse_sig to nil to verify it:
jw.SetValueAtPath("body.sibkey.reverse_sig", jsonw.NewNil())
msg, err := jw.Marshal()
if err != nil {
return err
}
_, err = keypair.VerifyString(revsig, msg)
if err != nil {
return err
}
// put reverse_sig back in
jw.SetValueAtPath("body.sibkey.reverse_sig", jsonw.NewString(revsig))
return nil
}
func (f *JSONConfigFile) SetNullAtPath(p string) (err error) {
existing := f.jw.AtPath(p)
if !existing.IsNil() || existing.Error() != nil {
err = f.jw.SetValueAtPath(p, jsonw.NewNil())
if err == nil {
return f.flush()
}
}
return
}
func (u *User) ToTrackingStatementSeqTail() *jsonw.Wrapper {
mul := u.GetPublicChainTail()
if mul == nil {
return jsonw.NewNil()
}
ret := jsonw.NewDictionary()
ret.SetKey("sig_id", jsonw.NewString(mul.SigID.ToString(true)))
ret.SetKey("seqno", jsonw.NewInt(int(mul.Seqno)))
ret.SetKey("payload_hash", jsonw.NewString(mul.LinkID.String()))
return ret
}
func (arg KeySection) ToJSON() (*jsonw.Wrapper, error) {
ret := jsonw.NewDictionary()
ret.SetKey("kid", jsonw.NewString(arg.Key.GetKID().String()))
if arg.EldestKID != "" {
ret.SetKey("eldest_kid", jsonw.NewString(arg.EldestKID.String()))
}
if arg.ParentKID != "" {
ret.SetKey("parent_kid", jsonw.NewString(arg.ParentKID.String()))
}
if arg.HasRevSig {
var revSig *jsonw.Wrapper
if arg.RevSig != "" {
revSig = jsonw.NewString(arg.RevSig)
} else {
revSig = jsonw.NewNil()
}
ret.SetKey("reverse_sig", revSig)
}
if arg.SigningUser != nil {
ret.SetKey("host", jsonw.NewString(CanonicalHost))
ret.SetKey("uid", UIDWrapper(arg.SigningUser.GetUID()))
ret.SetKey("username", jsonw.NewString(arg.SigningUser.GetName()))
}
if pgp, ok := arg.Key.(*PGPKeyBundle); ok {
fingerprint := pgp.GetFingerprint()
ret.SetKey("fingerprint", jsonw.NewString(fingerprint.String()))
ret.SetKey("key_id", jsonw.NewString(fingerprint.ToKeyID()))
if arg.IncludePGPHash {
hash, err := pgp.FullHash()
if err != nil {
return nil, err
}
ret.SetKey("full_hash", jsonw.NewString(hash))
}
}
return ret, nil
}
func (e *Kex2Provisionee) reverseSig(jw *jsonw.Wrapper) error {
// need to set reverse_sig to nil before making reverse sig:
if err := jw.SetValueAtPath("body.sibkey.reverse_sig", jsonw.NewNil()); err != nil {
return err
}
sig, _, _, err := libkb.SignJSON(jw, e.eddsa)
if err != nil {
return err
}
// put the signature in reverse_sig
if err := jw.SetValueAtPath("body.sibkey.reverse_sig", jsonw.NewString(sig)); err != nil {
return err
}
return nil
}
func (g *GenericChainLink) BaseToTrackingStatement(state keybase1.ProofState) *jsonw.Wrapper {
ret := jsonw.NewDictionary()
ret.SetKey("curr", jsonw.NewString(g.id.String()))
ret.SetKey("sig_id", jsonw.NewString(g.GetSigID().ToString(true)))
rkp := jsonw.NewDictionary()
ret.SetKey("remote_key_proof", rkp)
rkp.SetKey("state", jsonw.NewInt(int(state)))
prev := g.GetPrev()
var prevVal *jsonw.Wrapper
if prev == nil {
prevVal = jsonw.NewNil()
} else {
prevVal = jsonw.NewString(prev.String())
}
ret.SetKey("prev", prevVal)
ret.SetKey("ctime", jsonw.NewInt64(g.unpacked.ctime))
ret.SetKey("etime", jsonw.NewInt64(g.unpacked.etime))
return ret
}
// VerifyReverseSig checks a SibkeyChainLink's reverse signature using the ComputedKeyFamily provided.
func (s *SibkeyChainLink) VerifyReverseSig(ckf ComputedKeyFamily) (err error) {
var key GenericKey
if key, err = ckf.FindKeyWithKIDUnsafe(s.GetDelegatedKid()); err != nil {
return err
}
var p1, p2 []byte
if p1, _, err = key.VerifyStringAndExtract(s.reverseSig); err != nil {
err = ReverseSigError{fmt.Sprintf("Failed to verify/extract sig: %s", err)}
return
}
if p1, err = jsonw.Canonicalize(p1); err != nil {
err = ReverseSigError{fmt.Sprintf("Failed to canonicalize json: %s", err)}
return
}
// Null-out the reverse sig on the parent
path := "body.sibkey.reverse_sig"
s.payloadJSON.SetValueAtPath(path, jsonw.NewNil())
if p2, err = s.payloadJSON.Marshal(); err != nil {
err = ReverseSigError{fmt.Sprintf("Can't remarshal JSON statement: %s", err)}
return
}
eq := FastByteArrayEq(p1, p2)
s.payloadJSON.SetValueAtPath(path, jsonw.NewString(s.reverseSig))
if !eq {
err = ReverseSigError{fmt.Sprintf("JSON mismatch: %s != %s",
string(p1), string(p2))}
return
}
return
}
func (arg ProofMetadata) ToJSON(g *GlobalContext) (ret *jsonw.Wrapper, err error) {
// if only Me exists, then that is the signing user too
if arg.SigningUser == nil && arg.Me != nil {
arg.SigningUser = arg.Me
}
var seqno int
var prev *jsonw.Wrapper
if arg.LastSeqno > 0 {
seqno = int(arg.LastSeqno) + 1
prev = jsonw.NewString(arg.PrevLinkID.String())
} else {
lastSeqno := arg.Me.sigChain().GetLastKnownSeqno()
lastLink := arg.Me.sigChain().GetLastKnownID()
if lastLink == nil {
seqno = 1
prev = jsonw.NewNil()
} else {
seqno = int(lastSeqno) + 1
prev = jsonw.NewString(lastLink.String())
}
}
ctime := arg.CreationTime
if ctime == 0 {
ctime = time.Now().Unix()
}
ei := arg.ExpireIn
if ei == 0 {
ei = SigExpireIn
}
ret = jsonw.NewDictionary()
ret.SetKey("tag", jsonw.NewString("signature"))
ret.SetKey("ctime", jsonw.NewInt64(ctime))
ret.SetKey("expire_in", jsonw.NewInt(ei))
ret.SetKey("seqno", jsonw.NewInt(seqno))
ret.SetKey("prev", prev)
eldest := arg.Eldest
if eldest == "" {
eldest = arg.Me.GetEldestKID()
}
body := jsonw.NewDictionary()
body.SetKey("version", jsonw.NewInt(KeybaseSignatureV1))
body.SetKey("type", jsonw.NewString(string(arg.LinkType)))
key, err := KeySection{
Key: arg.SigningKey,
EldestKID: eldest,
SigningUser: arg.SigningUser,
IncludePGPHash: arg.IncludePGPHash,
}.ToJSON()
if err != nil {
return nil, err
}
body.SetKey("key", key)
ret.SetKey("body", body)
// Capture the most recent Merkle Root and also what kind of client
// we're running.
ret.SetKey("client", clientInfo(g))
if mr := merkleRootInfo(g); mr != nil {
ret.SetKey("merkle_root", mr)
}
return
}
func (k KID) ToJsonw() *jsonw.Wrapper {
if k.IsNil() {
return jsonw.NewNil()
}
return jsonw.NewString(string(k))
}
