func (e *UntrackEngine) storeRemoteUntrack(them *libkb.User, ctx *Context) (err error) {
e.G().Log.Debug("+ StoreRemoteUntrack")
defer e.G().Log.Debug("- StoreRemoteUntrack -> %s", libkb.ErrToOk(err))
arg := libkb.SecretKeyArg{
Me: e.arg.Me,
KeyType: libkb.DeviceSigningKeyType,
}
var signingKeyPriv libkb.GenericKey
if signingKeyPriv, err = e.G().Keyrings.GetSecretKeyWithPrompt(ctx.LoginContext, arg, ctx.SecretUI, "untracking signature"); err != nil {
return
}
var sig string
var sigid keybase1.SigID
if sig, sigid, err = signingKeyPriv.SignToString(e.untrackStatementBytes); err != nil {
return
}
_, err = e.G().API.Post(libkb.APIArg{
Endpoint: "follow",
NeedSession: true,
Args: libkb.HTTPArgs{
"sig_id_base": libkb.S{Val: sigid.ToString(false)},
"sig_id_short": libkb.S{Val: sigid.ToShortID()},
"sig": libkb.S{Val: sig},
"uid": libkb.UIDArg(them.GetUID()),
"type": libkb.S{Val: "untrack"},
"signing_kid": e.signingKeyPub.GetKID(),
},
})
return
}
func (h *HackerNewsChecker) CheckStatus(hint SigHint) ProofError {
res, err := G.XAPI.GetText(APIArg{
Endpoint: hint.apiURL,
NeedSession: false,
})
if err != nil {
return XapiError(err, hint.apiURL)
}
var sigID keybase1.SigID
_, sigID, err = OpenSig(h.proof.GetArmoredSig())
var ret ProofError
if err != nil {
return NewProofError(keybase1.ProofStatus_BAD_SIGNATURE,
"Bad signature: %s", err)
}
wanted := sigID.ToMediumID()
G.Log.Debug("| HackerNews profile: %s", res.Body)
G.Log.Debug("| Wanted signature hash: %s", wanted)
if !strings.Contains(res.Body, wanted) {
ret = NewProofError(keybase1.ProofStatus_TEXT_NOT_FOUND,
"Posted text does not include signature '%s'", wanted)
}
return ret
}
func (t BaseServiceType) BaseCheckProofForURL(text string, id keybase1.SigID) (err error) {
urlRxx := regexp.MustCompile(`https://(\S+)`)
target := id.ToMediumID()
urls := urlRxx.FindAllString(text, -1)
G.Log.Debug("Found urls %v", urls)
found := false
for _, u := range urls {
if strings.HasSuffix(u, target) {
found = true
}
}
if !found {
err = NotFoundError{"Didn't find a URL with suffix '" + target + "'"}
}
return
}
func makeKeyArgs(sigID keybase1.SigID, sig []byte, delType libkb.DelegationType, key libkb.GenericKey, eldestKID, signingKID keybase1.KID) (*libkb.HTTPArgs, error) {
pub, err := key.Encode()
if err != nil {
return nil, err
}
args := libkb.HTTPArgs{
"sig_id_base": libkb.S{Val: sigID.ToString(false)},
"sig_id_short": libkb.S{Val: sigID.ToShortID()},
"sig": libkb.S{Val: string(sig)},
"type": libkb.S{Val: string(delType)},
"is_remote_proof": libkb.B{Val: false},
"public_key": libkb.S{Val: pub},
"eldest_kid": libkb.S{Val: eldestKID.String()},
"signing_kid": libkb.S{Val: signingKID.String()},
}
return &args, nil
}
func (t BaseServiceType) BaseCheckProofTextShort(text string, id keybase1.SigID, med bool) error {
blocks := FindBase64Snippets(text)
var target string
if med {
target = id.ToMediumID()
} else {
target = id.ToShortID()
}
for _, b := range blocks {
if len(b) < len(target) {
continue
}
if b != target {
return WrongSigError{b}
}
// found match:
return nil
}
return NotFoundError{"Couldn't find signature ID " + target + " in text"}
}
func (u *User) CryptocurrencySig(key GenericKey, address string, sigToRevoke keybase1.SigID) (*jsonw.Wrapper, error) {
ret, err := ProofMetadata{
Me: u,
LinkType: CryptocurrencyType,
SigningKey: key,
}.ToJSON(u.G())
if err != nil {
return nil, err
}
body := ret.AtKey("body")
currencySection := jsonw.NewDictionary()
currencySection.SetKey("address", jsonw.NewString(address))
currencySection.SetKey("type", jsonw.NewString("bitcoin"))
body.SetKey("cryptocurrency", currencySection)
if len(sigToRevoke) > 0 {
revokeSection := jsonw.NewDictionary()
revokeSection.SetKey("sig_id", jsonw.NewString(sigToRevoke.ToString(true /* suffix */)))
body.SetKey("revoke", revokeSection)
}
return ret, nil
}
func CheckPostedViaSigID(sigID keybase1.SigID) (found bool, status keybase1.ProofStatus, err error) {
res, e2 := G.API.Post(APIArg{
Endpoint: "sig/posted",
NeedSession: true,
Args: HTTPArgs{
"sig_id": S{sigID.ToString(true)},
},
})
if e2 != nil {
err = e2
return
}
var (
rfound bool
rstatus int
rerr error
)
res.Body.AtKey("proof_ok").GetBoolVoid(&rfound, &rerr)
res.Body.AtPath("proof_res.status").GetIntVoid(&rstatus, &rerr)
return rfound, keybase1.ProofStatus(rstatus), rerr
}
// Delegate marks the given ComputedKeyInfos object that the given kid is now
// delegated, as of time tm, in sigid, as signed by signingKid, etc.
func (cki *ComputedKeyInfos) Delegate(kid keybase1.KID, tm *KeybaseTime, sigid keybase1.SigID, signingKid, parentKID keybase1.KID, pgpHash string, isSibkey bool, ctime, etime time.Time) (err error) {
G.Log.Debug("ComputeKeyInfos::Delegate To %s with %s at sig %s", kid.String(), signingKid, sigid.ToDisplayString(true))
info, found := cki.Infos[kid]
if !found {
newInfo := NewComputedKeyInfo(false, false, KeyUncancelled, ctime.Unix(), etime.Unix(), pgpHash)
newInfo.DelegatedAt = tm
info = &newInfo
cki.Infos[kid] = info
} else {
info.Status = KeyUncancelled
info.CTime = ctime.Unix()
info.ETime = etime.Unix()
}
info.Delegations[sigid] = signingKid
info.Sibkey = isSibkey
cki.Sigs[sigid] = info
// If it's a subkey, make a pointer from it to its parent,
// and also from its parent to it.
if parentKID.Exists() {
info.Parent = parentKID
if parent, found := cki.Infos[parentKID]; found {
parent.Subkey = kid
}
}
return
}
func (pc *ProofCache) dbKey(sid keybase1.SigID) (DbKey, string) {
sidstr := sid.ToString(true)
key := DbKey{Typ: DBProofCheck, Key: sidstr}
return key, sidstr
}