func (rc *RedditChecker) UnpackData(inp *jsonw.Wrapper) (*jsonw.Wrapper, ProofError) {
var k1, k2 string
var err error
inp.AtIndex(0).AtKey("kind").GetStringVoid(&k1, &err)
parent := inp.AtIndex(0).AtKey("data").AtKey("children").AtIndex(0)
parent.AtKey("kind").GetStringVoid(&k2, &err)
var ret *jsonw.Wrapper
var pe ProofError
cf := keybase1.ProofStatus_CONTENT_FAILURE
cm := keybase1.ProofStatus_CONTENT_MISSING
if err != nil {
pe = NewProofError(cm, "Bad proof JSON: %s", err)
} else if k1 != "Listing" {
pe = NewProofError(cf,
"Reddit: Wanted a post of type 'Listing', but got %s", k1)
} else if k2 != "t3" {
pe = NewProofError(cf, "Wanted a child of type 't3' but got %s", k2)
} else if ret = parent.AtKey("data"); ret.IsNil() {
pe = NewProofError(cm, "Couldn't get child data for post")
}
return ret, pe
}
func (sh *SigHints) PopulateWith(jw *jsonw.Wrapper) (err error) {
if jw == nil || jw.IsNil() {
return
}
jw.AtKey("version").GetIntVoid(&sh.version, &err)
if err != nil {
return
}
sh.hints = make(map[keybase1.SigID]*SigHint)
var n int
n, err = jw.AtKey("hints").Len()
if err != nil {
return
}
for i := 0; i < n; i++ {
hint, tmpe := NewSigHint(jw.AtKey("hints").AtIndex(i))
if tmpe != nil {
sh.G().Log.Warning("Bad SigHint Loaded: %s", tmpe)
} else {
sh.hints[hint.sigID] = hint
}
}
return
}
// ParseKeyFamily takes as input a dictionary from a JSON file and returns
// a parsed version for manipulation in the program.
func ParseKeyFamily(jw *jsonw.Wrapper) (ret *KeyFamily, err error) {
G.Log.Debug("+ ParseKeyFamily")
defer func() {
G.Log.Debug("- ParseKeyFamily -> %s", ErrToOk(err))
}()
if jw == nil || jw.IsNil() {
err = KeyFamilyError{"nil record from server"}
return
}
kf := KeyFamily{
pgp2kid: make(map[PGPFingerprint]keybase1.KID),
kid2pgp: make(map[keybase1.KID]PGPFingerprint),
Contextified: NewContextified(G),
}
// Fill in AllKeys. Somewhat wasteful but probably faster than
// using Jsonw wrappers, and less error-prone.
var rkf RawKeyFamily
if err = jw.UnmarshalAgain(&rkf); err != nil {
return
}
kf.BundlesForTesting = rkf.AllBundles
// Parse the keys, and collect the PGP keys to map their fingerprints.
kf.AllKIDs = make(map[keybase1.KID]bool)
kf.PGPKeySets = make(map[keybase1.KID]*PGPKeySet)
kf.SingleKeys = make(map[keybase1.KID]GenericKey)
for _, bundle := range rkf.AllBundles {
newKey, err := ParseGenericKey(bundle)
if err != nil {
return nil, err
}
kid := newKey.GetKID()
if pgp, isPGP := newKey.(*PGPKeyBundle); isPGP {
ks, ok := kf.PGPKeySets[kid]
if !ok {
ks = &PGPKeySet{nil, make(map[string]*PGPKeyBundle)}
kf.PGPKeySets[kid] = ks
fp := pgp.GetFingerprint()
kf.pgp2kid[fp] = kid
kf.kid2pgp[kid] = fp
}
ks.addKey(pgp)
} else {
kf.SingleKeys[kid] = newKey
}
kf.AllKIDs[kid] = true
}
ret = &kf
return
}
func (c *ChainLink) UnpackComputedKeyInfos(jw *jsonw.Wrapper) (err error) {
var tmp ComputedKeyInfos
if jw == nil || jw.IsNil() {
return
}
if err = jw.UnmarshalAgain(&tmp); err == nil {
c.cki = &tmp
}
return
}
func GetLinkID(w *jsonw.Wrapper) (LinkID, error) {
if w.IsNil() {
return nil, nil
}
s, err := w.GetString()
if err != nil {
return nil, err
}
ret, err := LinkIDFromHex(s)
return ret, err
}
func parseTriple(jw *jsonw.Wrapper) (*MerkleTriple, error) {
if jw.IsNil() {
return nil, nil
}
l, err := jw.Len()
if err != nil {
return nil, err
}
if l == 0 {
return nil, nil
}
if l == 1 {
return nil, fmt.Errorf("Bad merkle 'triple', with < 2 values")
}
if l > 3 {
return nil, fmt.Errorf("Bad merkle triple, with > 3 values")
}
seqno, err := jw.AtIndex(0).GetInt()
if err != nil {
return nil, err
}
li, err := GetLinkID(jw.AtIndex(1))
if err != nil {
return nil, err
}
var si keybase1.SigID
if l == 3 {
si, err = GetSigID(jw.AtIndex(2), false)
if err != nil {
return nil, err
}
}
return &MerkleTriple{Seqno(seqno), li, si}, nil
}
func importPathFromJSON(jw *jsonw.Wrapper) (out []*PathStep, err error) {
if jw.IsNil() {
return
}
var path *jsonw.Wrapper
if path, err = jw.ToArray(); err != nil {
return
}
var l int
if l, err = path.Len(); err != nil {
return
}
for i := 0; i < l; i++ {
var step *PathStep
if step, err = pathStepFromJSON(path.AtIndex(i)); err != nil {
return
}
out = append(out, step)
}
return
}
// ParseKeyFamily takes as input a dictionary from a JSON file and returns
// a parsed version for manipulation in the program.
func ParseKeyFamily(g *GlobalContext, jw *jsonw.Wrapper) (ret *KeyFamily, err error) {
defer g.Trace("ParseKeyFamily", func() error { return err })()
if jw == nil || jw.IsNil() {
err = KeyFamilyError{"nil record from server"}
return
}
kf := KeyFamily{
Contextified: NewContextified(g),
pgp2kid: make(map[PGPFingerprint]keybase1.KID),
kid2pgp: make(map[keybase1.KID]PGPFingerprint),
}
// Fill in AllKeys. Somewhat wasteful but probably faster than
// using Jsonw wrappers, and less error-prone.
var rkf RawKeyFamily
if err = jw.UnmarshalAgain(&rkf); err != nil {
return
}
kf.BundlesForTesting = rkf.AllBundles
// Parse the keys, and collect the PGP keys to map their fingerprints.
kf.AllKIDs = make(map[keybase1.KID]bool)
kf.PGPKeySets = make(map[keybase1.KID]*PGPKeySet)
kf.SingleKeys = make(map[keybase1.KID]GenericKey)
for i, bundle := range rkf.AllBundles {
newKey, err := ParseGenericKey(bundle)
// Some users have some historical bad keys, so no reason to crap
// out if we can't parse them, especially if there are others than
// can do just as well.
if err != nil {
g.Log.Notice("Failed to parse public key at position %d", i)
g.Log.Debug("Key parsing error: %s", err)
g.Log.Debug("Full key dump follows")
g.Log.Debug(bundle)
continue
}
kid := newKey.GetKID()
if pgp, isPGP := newKey.(*PGPKeyBundle); isPGP {
ks, ok := kf.PGPKeySets[kid]
if !ok {
ks = &PGPKeySet{NewContextified(g), nil, make(map[string]*PGPKeyBundle)}
kf.PGPKeySets[kid] = ks
fp := pgp.GetFingerprint()
kf.pgp2kid[fp] = kid
kf.kid2pgp[kid] = fp
}
ks.addKey(pgp)
} else {
kf.SingleKeys[kid] = newKey
}
kf.AllKIDs[kid] = true
}
ret = &kf
return
}