libkb

package
v1.0.2-0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 24, 2015 License: BSD-3-Clause, BSD-3-Clause Imports: 66 Imported by: 0

Documentation ¶

Overview ¶

Code used in populating JSON objects to generating Keybase-style signatures.

A KeyFamily is a group of sibling keys that have equal power for a user. A family can consist of 1 PGP keys, and arbitrarily many NaCl Sibkeys. There also can be some subkeys dangling off for ECDH.

A module for syncing secrets with the server, such as SKB PGP keys, and server-halves of our various secret keys.

A module for syncing trackers from the server

Index ¶

Constants ¶

View Source 
const (
	XAPIResJSON = iota
	XAPIResHTML
	XAPIResText
)
View Source 
const (
	NONE = iota
	OR
	AND
	LPAREN
	RPAREN
	URL
	EOF
	ERROR
)
View Source 
const (
	DevelServerURI      = "http://localhost:3000"
	StagingServerURI    = "https://stage0.keybase.io"
	ProductionServerURI = "https://keybase.io"
	TorServerURI        = "http://fncuwbiisyh6ak3i.onion"
)
View Source 
const (
	DevelRunMode      RunMode = "devel"
	StagingRunMode            = "staging"
	ProductionRunMode         = "prod"
	RunModeError              = "error"
	NoRunMode                 = ""
)
View Source 
const (
	ConfigFile  = "config.json"
	SessionFile = "session.json"
	DBFile      = "keybase.leveldb"
	SocketFile  = "keybased.sock"
	PIDFile     = "keybased.pid"

	SecretKeyringTemplate = "secretkeys.%u.mpack"

	APIVersion       = "1.0"
	APIURIPathPrefix = "/_/api/" + APIVersion
	DaemonPort       = 40933
	GoClientID       = "keybase.io go client"
	IdentifyAs       = GoClientID + " v" + Version + " " + runtime.GOOS
)
View Source 
const (
	PermFile          os.FileMode = 0600
	PermDir           os.FileMode = 0700
	UmaskablePermFile os.FileMode = 0666
)
View Source 
const (
	UserCacheMaxAge      = 5 * time.Minute
	PGPFingerprintHexLen = 40

	ProofCacheSize      = 0x1000
	ProofCacheLongDur   = 6 * time.Hour
	ProofCacheMediumDur = 30 * time.Minute
	ProofCacheShortDur  = 1 * time.Minute

	SigShortIDBytes = 27
)
View Source 
const (
	KeybaseKIDV1       = 1 // Uses SHA-256
	KeybaseSignatureV1 = 1
	OneYearInSeconds   = 24 * 60 * 60 * 365

	SigExpireIn       = OneYearInSeconds * 16 // 16 years
	NaclEdDSAExpireIn = OneYearInSeconds * 16 // 16 years
	NaclDHExpireIn    = OneYearInSeconds * 16 // 16 years
	KeyExpireIn       = OneYearInSeconds * 16 // 16 years
	SubkeyExpireIn    = OneYearInSeconds * 16 // 16 years
	AuthExpireIn      = OneYearInSeconds      // 1 year
)
View Source 
const (
	SCOk                     = 0
	SCLoginRequired          = 201
	SCBadSession             = 202
	SCBadLoginPassword       = 204
	SCNotFound               = 205
	SCGeneric                = 218
	SCAlreadyLoggedIn        = 235
	SCCanceled               = 237
	SCReloginRequired        = 274
	SCBadSignupUsernameTaken = 701
	SCKeyNotFound            = 901
	SCKeyInUse               = 907
	SCKeyBadGen              = 913
	SCKeyNoSecret            = 914
	SCKeyBadUIDs             = 915
	SCKeyNoActive            = 916
	SCKeyNoSig               = 917
	SCKeyBadSig              = 918
	SCKeyBadEldest           = 919
	SCKeyNoEldest            = 920
	SCKeyDuplicateUpdate     = 921
	SCSibkeyAlreadyExists    = 922
	SCDecryptionKeyNotFound  = 924
	SCBadTrackSession        = 1301
	SCDeviceNotFound         = 1409
	SCDeviceMismatch         = 1410
	SCDeviceRequired         = 1411
	SCStreamExists           = 1501
	SCStreamNotFound         = 1502
	SCStreamWrongKind        = 1503
	SCStreamEOF              = 1504
	SCAPINetworkError        = 1601
	SCTimeout                = 1602
	SCProofError             = 1701
	SCIdentificationExpired  = 1702
	SCSelfNotFound           = 1703
	SCBadKexPhrase           = 1704
	SCNoUIDelegation         = 1705
)

Status codes. This list should match keybase/lib/constants.iced.

View Source 
const (
	MerkleTreeNode = 1
	MerkleTreeLeaf = 2
)
View Source 
const (
	AuthenticationType    LinkType = "auth"
	CryptocurrencyType             = "cryptocurrency"
	RevokeType                     = "revoke"
	TrackType                      = "track"
	UntrackType                    = "untrack"
	UpdatePassphraseType           = "update_passphrase_hash"
	WebServiceBindingType          = "web_service_binding"

	EldestType    DelegationType = "eldest"
	PGPUpdateType                = "pgp_update"
	SibkeyType                   = "sibkey"
	SubkeyType                   = "subkey"
)
View Source 
const (
	SigTypeNone           = 0
	SigTypeSelfSig        = 1
	SigTypeRemoteProof    = 2
	SigTypeTrack          = 3
	SigTypeUntrack        = 4
	SigTypeRevoke         = 5
	SigTypeCryptocurrency = 6
	SigTypeAnnouncement   = 7
)
View Source 
const (
	KeyTypeNone                  KeyType = 0
	KeyTypeOpenPGPPublic                 = 1
	KeyTypeP3skbPrivate                  = 2
	KeyTypeKbNaclEddsa                   = 3
	KeyTypeKbNaclDH                      = 4
	KeyTypeKbNaclEddsaServerHalf         = 5
	KeyTypeKbNaclDHServerHalf            = 6
)
View Source 
const (
	DeviceStatusNone    = 0
	DeviceStatusActive  = 1
	DeviceStatusDefunct = 2
)
View Source 
const (
	DeviceTypeDesktop = "desktop"
	DeviceTypeMobile  = "mobile"
	DeviceTypePaper   = "backup"
)

these strings need to match the keys in keybase/lib_public/public_constants.iced -> public_constants.device.type

View Source 
const (
	HTTPDefaultTimeout = 60 * time.Second
	HTTPPollMaximum    = 5 * time.Second
)
View Source 
const (
	KeybasePacketV1 = 1
	TagP3skb        = 513
	TagSignature    = 514
	TagEncryption   = 515
)

Packet tags for OpenPGP and also Keybase packets

View Source 
const (
	KIDPGPBase    AlgoType = 0x00
	KIDPGPRsa              = 0x1
	KIDPGPElgamal          = 0x10
	KIDPGPDsa              = 0x11
	KIDPGPEcdh             = 0x12
	KIDPGPEcdsa            = 0x13
	KIDNaclEddsa           = 0x20
	KIDNaclDH              = 0x21
)
View Source 
const (
	HashPGPMd5       = 1
	HashPGPSha1      = 2
	HashPGPRipemd160 = 3
	HashPGPSha256    = 8
	HashPGPSha384    = 9
	HashPGPSha512    = 10
	HashPGPSha224    = 11
)

OpenPGP hash IDs, taken from http://tools.ietf.org/html/rfc4880#section-9.4

View Source 
const (
	RevSimpleDelete = 0
	RevFull         = 1
	RevDated        = 2
)

key_revocation_types

View Source 
const (
	KexScryptCost       = 32768
	KexScryptR          = 8
	KexScryptP          = 1
	KexScryptKeylen     = 32
	KexSessionIDEntropy = 65 // kex doc specifies 65 bits of entropy
)
View Source 
const (
	Kex2PhraseEntropy = 88
	Kex2ScryptCost    = 1 << 17
	Kex2ScryptR       = 8
	Kex2ScryptP       = 1
	Kex2ScryptKeylen  = 32
)
View Source 
const (
	PaperKeyScryptCost    = 32768
	PaperKeyScryptR       = 8
	PaperKeyScryptP       = 1
	PaperKeyScryptKeylen  = 128
	PaperKeySecretEntropy = 117
	PaperKeyIDBits        = 22
	PaperKeyVersionBits   = 4
	PaperKeyVersion       = 0
)
View Source 
const (
	DBUser                    = 0x00
	DBSig                     = 0x0f
	DBLink                    = 0xe0
	DBLocalTrack              = 0xe1
	DBPGPKey                  = 0xe3
	DBSigHints                = 0xe4
	DBProofCheck              = 0xe5
	DBUserSecretKeys          = 0xe6
	DBSigChainTailPublic      = 0xe7
	DBSigChainTailSemiprivate = 0xe8
	DBSigChainTailEncrypted   = 0xe9
	DBMerkleRoot              = 0xf0
	DBTrackers                = 0xf1
)
View Source 
const (
	DBLookupUsername   = 0x00
	DBLookupMerkleRoot = 0x01
)
View Source 
const (
	DeviceIDLen    = 16
	DeviceIDSuffix = 0x18
)
View Source 
const (
	NodeHashLenLong  = sha512.Size // = 64
	NodeHashLenShort = sha256.Size // = 32
)
View Source 
const (
	RedditPrefix = "https://www.reddit.com"
	RedditSub    = RedditPrefix + "/r/keybaseproofs"
)
View Source 
const (
	TrackStatusNone     = 0
	TrackStatusTracking = 1
)
View Source 
const Build = "0"

Build number

View Source 
const CanonicalHost = "keybase.io"
View Source 
const DefaultRunMode = DevelRunMode
View Source 
const DownloadURL = "https://keybase.io/download"
View Source 
const (
	IDSuffixKID = 0x0a
)
View Source 
const IsBrewBuild = false
View Source 
const LKSecVersion = 100
View Source 
const (
	LinkIDLen = 32
)
View Source 
const MinPassphraseLength = 12
View Source 
const NaclDHKeySecretSize = 32

TODO: Ideally, box would expose how many random bytes it needs.

View Source 
const NaclDHKeysize = 32
View Source 
const NaclDHNonceSize = 24

Todo: Ideally, box would specify nonce size

View Source 
const NaclSigningKeySecretSize = 32

TODO: Ideally, ed25519 would expose how many random bytes it needs.

View Source 
const (
	PGPFingerprintLen = 20
)
View Source 
const SHA256Code = 8
View Source 
const (
	ServerUpdateLag = time.Minute
)
View Source 
const (
	SigKbEddsa = KIDNaclEddsa
)
View Source 
const UserSummaryLimit = 500 // max number of user summaries in one request
View Source 
const Version = "1.0.2"

Version as MAJOR.MINOR.PATCH

Variables ¶

View Source 
var AllDeviceTypes = DeviceTypeSet{
	DeviceTypeDesktop: true,
	DeviceTypeMobile:  true,
	DeviceTypePaper:   true,
}
View Source 
var BundledCAs = map[string]string{

	"api.keybase.io": `-----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----`,
}
View Source 
var CheckDeviceName = Checker{
	F: func(s string) bool {
		re := regexp.MustCompile(`^[a-zA-Z0-9][ _'a-zA-Z0-9+-]*$`)
		bad := regexp.MustCompile(`  |[ '+_-]$|['+_-][ ]?['+_-]`)
		return len(s) >= 3 && len(s) <= 64 && re.MatchString(s) && !bad.MatchString(s)
	},
	Hint: "between 3 and 64 characters long",
}
View Source 
var CheckEmail = Checker{
	F: func(s string) bool {
		re := regexp.MustCompile(`^\S+@\S+\.\S+$`)
		return len(s) > 3 && re.MatchString(s)
	},
	Hint: "must be a valid email address",
}
View Source 
var CheckEmailOrUsername = Checker{
	F: func(s string) bool {
		return CheckEmail.F(s) || CheckUsername.F(s)
	},
	Hint: "valid usernames are 2-12 letters long",
}
View Source 
var CheckInviteCode = Checker{
	F: func(s string) bool {
		return len(s) > 4
	},
	Hint: "Invite codes are 4 or more characters",
}
View Source 
var CheckNotEmpty = Checker{
	F: func(s string) bool {
		return len(s) > 0
	},
	Hint: "cannot be empty",
}
View Source 
var CheckPassphraseNew = Checker{
	F: func(s string) bool {
		r := []rune(s)
		if len(r) > 0 && unicode.IsSpace(r[0]) {
			return false
		}
		return len(s) >= MinPassphraseLength
	},
	Hint:          fmt.Sprintf("passphrase must be %d or more characters", MinPassphraseLength),
	PreserveSpace: true,
}
View Source 
var CheckPassphraseSimple = Checker{
	F: func(s string) bool {
		return len(s) > 0
	},
	Hint: "passphrase cannot be empty",
}
View Source 
var CheckUsername = Checker{
	F: func(s string) bool {
		re := regexp.MustCompile(`^([a-zA-Z0-9][a-zA-Z0-9_]?)+$`)
		return len(s) >= 2 && len(s) <= 16 && re.MatchString(s)
	},
	Hint: "between 2 and 16 characters long",
}
View Source 
var CheckYesNo = Checker{
	F: func(s string) bool {
		return IsYes(s) || IsNo(s)
	},
	Hint: "'yes' or 'no'",
}
View Source 
var DefaultDeviceTypes = DeviceTypeSet{
	DeviceTypeDesktop: true,
	DeviceTypeMobile:  true,
}
View Source 
var ErrLoginSessionCleared = errors.New("LoginSession already cleared")
View Source 
var ErrLoginSessionNotLoaded = errors.New("LoginSession not loaded")
View Source 
var ErrNilUser = errors.New("User is nil")
View Source 
var MerkleProdKIDs = []string{
	"010159baae6c7d43c66adf8fb7bb2b8b4cbe408c062cfc369e693ccb18f85631dbcd0a",
}
View Source 
var MerkleStagingKIDs = []string{
	"0101bed85ce72cc315828367c28b41af585b6b7d95646a62ca829691d70f49184fa70a",
}
View Source 
var MerkleTestKIDs = []string{
	"0101be58b6c82db64f6ccabb05088db443c69f87d5d48857d709ed6f73948dabe67d0a",
}
View Source 
var PGPArmorHeaders = map[string]string{
	"Version": PGPVersion,
	"Comment": DownloadURL,
}
View Source 
var PGPVersion = "Keybase Go " + Version + " (" + runtime.GOOS + ")"
View Source 
var ProofErrorDNSOverTor = &ProofErrorImpl{
	Status: keybase1.ProofStatus_TOR_SKIPPED,
	Desc:   "DNS proofs aren't reliable over Tor",
}
View Source 
var ProofErrorHTTPOverTor = &ProofErrorImpl{
	Status: keybase1.ProofStatus_TOR_SKIPPED,
	Desc:   "HTTP proofs aren't reliable over Tor",
}
View Source 
var PublicChain = &ChainType{
	DbType:          DBSigChainTailPublic,
	Private:         false,
	Encrypted:       false,
	GetMerkleTriple: func(u *MerkleUserLeaf) *MerkleTriple { return u.public },
}
View Source 
var RemoteServiceOrder = []keybase1.ProofType{
	keybase1.ProofType_KEYBASE,
	keybase1.ProofType_TWITTER,
	keybase1.ProofType_GITHUB,
	keybase1.ProofType_REDDIT,
	keybase1.ProofType_COINBASE,
	keybase1.ProofType_HACKERNEWS,
	keybase1.ProofType_GENERIC_WEB_SITE,
	keybase1.ProofType_ROOTER,
}
View Source 
var RemoteServiceTypes = map[string]keybase1.ProofType{
	"keybase":    keybase1.ProofType_KEYBASE,
	"twitter":    keybase1.ProofType_TWITTER,
	"github":     keybase1.ProofType_GITHUB,
	"reddit":     keybase1.ProofType_REDDIT,
	"coinbase":   keybase1.ProofType_COINBASE,
	"hackernews": keybase1.ProofType_HACKERNEWS,
	"https":      keybase1.ProofType_GENERIC_WEB_SITE,
	"http":       keybase1.ProofType_GENERIC_WEB_SITE,
	"dns":        keybase1.ProofType_DNS,
	"rooter":     keybase1.ProofType_ROOTER,
}
View Source 
var RunModes = []RunMode{DevelRunMode, StagingRunMode, ProductionRunMode}
View Source 
var ServerLookup = map[RunMode]string{
	DevelRunMode:      DevelServerURI,
	StagingRunMode:    StagingServerURI,
	ProductionRunMode: ProductionServerURI,
}
View Source 
var TorProxy = "localhost:9050"
View Source 
var UserAgent = "Keybase/" + Version + " (" + runtime.Version() + " on " + runtime.GOOS + ")"

Functions ¶

func APIBase ¶ 

func APIBase(un string) string

func AppDataDir ¶ 

func AppDataDir() (string, error)

func AttachedSign ¶ 

func AttachedSign(out io.WriteCloser, signed openpgp.Entity, hints *openpgp.FileHints,
	config *packet.Config) (in io.WriteCloser, err error)

AttachedSign is like openpgp.Encrypt (as in p.crypto/openpgp/write.go), but don't encrypt at all, just sign the literal unencrypted data. Unfortunately we need to duplicate some code here that's already in write.go

func AttachedSignWrapper ¶ 

func AttachedSignWrapper(out io.WriteCloser, key PGPKeyBundle, armored bool) (
	in io.WriteCloser, err error)

func BtcAddrCheck ¶ 

func BtcAddrCheck(s string, opts *BtcOpts) (version int, pkhash []byte, err error)

func CanEncrypt ¶ 

func CanEncrypt(key GenericKey) bool

func CheckKarma ¶ 

func CheckKarma(un string) (int, error)

func CheckPosted ¶ 

func CheckPosted(proofID string) (found bool, status keybase1.ProofStatus, err error)

func CheckPostedViaSigID ¶ 

func CheckPostedViaSigID(sigID keybase1.SigID) (found bool, status keybase1.ProofStatus, err error)

func CheckUIDAgainstCasedUsername ¶ 

func CheckUIDAgainstCasedUsername(uid keybase1.UID, username string) (err error)

CheckUIDAgainstCasedUsername takes the input string, does not convert toLower, and then hashes it to recover a UID. This is a workaround for some users whose UIDs were computed incorrectly.

func CheckUIDAgainstUsername ¶ 

func CheckUIDAgainstUsername(uid keybase1.UID, username string) (err error)

func Cicmp ¶ 

func Cicmp(s1, s2 string) bool

func ClearStoredSecret ¶ 

func ClearStoredSecret(g *GlobalContext, username NormalizedUsername) error

func CombineErrors ¶ 

func CombineErrors(errs ...error) error

CombineErrors returns a single error for multiple errors, or nil if none.

func ComputeSigIDFromSigBody ¶ 

func ComputeSigIDFromSigBody(body []byte) keybase1.SigID

func Decode58 ¶ 

func Decode58(inp string) (outp []byte, err error)

func DelegatorAggregator ¶ 

func DelegatorAggregator(lctx LoginContext, ds []Delegator) (err error)

Run posts an array of delegations to the server. Keeping this simple as we don't need any state (yet)

func DeletePrimary ¶ 

func DeletePrimary() (err error)

func DisplayTrackArg ¶ 

func DisplayTrackArg(sessionID int, stmt string) *keybase1.DisplayTrackStatementArg

func DrainPipe ¶ 

func DrainPipe(rc io.Reader, sink func(string)) error

func Encode58 ¶ 

func Encode58(inp []byte) string

func ErrToOk ¶ 

func ErrToOk(err error) string

func ExportErrorAsStatus ¶ 

func ExportErrorAsStatus(e error) (ret *keybase1.Status)

func ExportPGPIdentity ¶ 

func ExportPGPIdentity(identity *openpgp.Identity) keybase1.PGPIdentity

func ExportProofError ¶ 

func ExportProofError(pe ProofError) (ret keybase1.ProofResult)

func ExportRemoteProof ¶ 

func ExportRemoteProof(p RemoteProofChainLink) keybase1.RemoteProof

func ExportTrackDiff ¶ 

func ExportTrackDiff(d TrackDiff) (res *keybase1.TrackDiff)

func ExportTrackSummary ¶ 

func ExportTrackSummary(l *TrackLookup, username string) *keybase1.TrackSummary

func FastByteArrayEq ¶ 

func FastByteArrayEq(a, b []byte) bool

func FileExists ¶ 

func FileExists(path string) (bool, error)

exists returns whether the given file or directory exists or not

func FindBase64Block ¶ 

func FindBase64Block(s string, pattern []byte, url bool) bool

func FindBase64Blocks ¶ 

func FindBase64Blocks(s string) []string

func FindBase64Snippets ¶ 

func FindBase64Snippets(s string) []string

func FindFirstBase64Block ¶ 

func FindFirstBase64Block(s string) string

func FormatTime ¶ 

func FormatTime(tm time.Time) string

func GenericKeyEqual ¶ 

func GenericKeyEqual(k1, k2 GenericKey) bool

func GetConfiguredAccounts ¶ 

func GetConfiguredAccounts(g *GlobalContext) ([]keybase1.ConfiguredAccount, error)

func GetKID ¶ 

func GetKID(w *jsonw.Wrapper) (kid keybase1.KID, err error)

func GetLinkIDVoid ¶ 

func GetLinkIDVoid(w *jsonw.Wrapper, l *LinkID, e *error)

func GetNodeHashVoid ¶ 

func GetNodeHashVoid(w *jsonw.Wrapper, nhp *NodeHash, errp *error)

func GetPGPFingerprintVoid ¶ 

func GetPGPFingerprintVoid(w *jsonw.Wrapper, p *PGPFingerprint, e *error)

func GetProxyCAs ¶ 

func GetProxyCAs(out *x509.CertPool, r ConfigReader) (ret *x509.CertPool, err error)

func GetSigID ¶ 

func GetSigID(w *jsonw.Wrapper, suffix bool) (keybase1.SigID, error)

func GetTerminalPrompt ¶ 

func GetTerminalPrompt() string

func GetUID ¶ 

func GetUID(w *jsonw.Wrapper) (keybase1.UID, error)

func GetUIDVoid ¶ 

func GetUIDVoid(w *jsonw.Wrapper, u *keybase1.UID, e *error)

func GetUsersWithStoredSecrets ¶ 

func GetUsersWithStoredSecrets(g *GlobalContext) ([]string, error)

func GiveMeAnS ¶ 

func GiveMeAnS(i int) string

func HasSecretStore ¶ 

func HasSecretStore() bool

func HexDecodeQuoted ¶ 

func HexDecodeQuoted(data []byte) ([]byte, error)

func ImportStatusAsError ¶ 

func ImportStatusAsError(s *keybase1.Status) error

func IsArmored ¶ 

func IsArmored(buf []byte) bool

func IsClearsign ¶ 

func IsClearsign(p *Peeker) bool

func IsDirEmpty ¶ 

func IsDirEmpty(dir string) (bool, error)

IsDirEmpty returns whether directory has any files.

func IsEmpty ¶ 

func IsEmpty(s string) bool

func IsIn ¶ 

func IsIn(needle string, haystack []string, ci bool) bool

IsIn checks for needle in haystack, ci means case-insensitive.

func IsNo ¶ 

func IsNo(s string) bool

func IsPGP ¶ 

func IsPGP(key GenericKey) bool

func IsPGPAlgo ¶ 

func IsPGPAlgo(algo AlgoType) bool

func IsSocketClosedError ¶ 

func IsSocketClosedError(e error) bool

net.errClosing isn't exported, so do this.. UGLY!

func IsValidHostname ¶ 

func IsValidHostname(s string) bool

func IsYes ¶ 

func IsYes(s string) bool

func KarmaURL ¶ 

func KarmaURL(un string) string

func KbOpenSig ¶ 

func KbOpenSig(armored string) ([]byte, error)

func KeyMatchesQuery ¶ 

func KeyMatchesQuery(key GenericKey, q string, exact bool) bool

Any valid key matches the empty string.

func KeyProof ¶ 

func KeyProof(arg Delegator) (ret *jsonw.Wrapper, err error)

arg.Me user is used to get the last known seqno in ProofMetadata. If arg.Me == nil, set arg.LastSeqno.

func KeybaseEmailAddress ¶ 

func KeybaseEmailAddress(s string) string

func ListProofCheckers ¶ 

func ListProofCheckers() (proofCheckers []string)

ListProofCheckers returns the supported networks for "keybase prove".

func LoadUserPlusKeys ¶ 

func LoadUserPlusKeys(g *GlobalContext, uid keybase1.UID, cacheOK bool) (keybase1.UserPlusKeys, error)

func MakeParentDirs ¶ 

func MakeParentDirs(filename string) error

func MakeURI ¶ 

func MakeURI(prot string, host string) string

MakeURI makes a URI string out of the given protocol and host strings, adding necessary punctuation in between.

func MsgpackDecodeAll ¶ 

func MsgpackDecodeAll(data []byte, handle *codec.MsgpackHandle, out interface{}) error

Decode data into out, but make sure that all bytes in data are used.

func NameCmp ¶ 

func NameCmp(n1, n2 string) bool

NameCmp removes whitespace and underscores, compares tolower.

func NameTrim ¶ 

func NameTrim(s string) string

func NewAPIEngines ¶ 

func NewAPIEngines(g *GlobalContext) (*InternalAPIEngine, *ExternalAPIEngine, error)

Make a new InternalApiEngine and a new ExternalApiEngine, which share the same network config (i.e., TOR and Proxy parameters)

func NewCoinbaseChecker ¶ 

func NewCoinbaseChecker(p RemoteProofChainLink) (*CoinbaseChecker, ProofError)

func NewDNSChecker ¶ 

func NewDNSChecker(p RemoteProofChainLink) (*DNSChecker, ProofError)

func NewDeviceID ¶ 

func NewDeviceID() (keybase1.DeviceID, error)

func NewGithubChecker ¶ 

func NewGithubChecker(p RemoteProofChainLink) (*GithubChecker, ProofError)

func NewHackerNewsChecker ¶ 

func NewHackerNewsChecker(p RemoteProofChainLink) (*HackerNewsChecker, ProofError)

func NewLoopbackConnPair ¶ 

func NewLoopbackConnPair() (*LoopbackConn, *LoopbackConn)

NewLoopbackConnPair makes a new loopback connection pair

func NewProofChecker ¶ 

func NewProofChecker(l RemoteProofChainLink) (ProofChecker, ProofError)

func NewRedditChecker ¶ 

func NewRedditChecker(p RemoteProofChainLink) (*RedditChecker, ProofError)

func NewRooterChecker ¶ 

func NewRooterChecker(p RemoteProofChainLink) (*RooterChecker, ProofError)

func NewTwitterChecker ¶ 

func NewTwitterChecker(p RemoteProofChainLink) (*TwitterChecker, ProofError)
func NewTypedChainLink(cl *ChainLink) (ret TypedChainLink, w Warning)

func NewWebChecker ¶ 

func NewWebChecker(p RemoteProofChainLink) (*WebChecker, ProofError)

func OpenLogFile ¶ 

func OpenLogFile() (name string, file *os.File, err error)

OpenLogFile opens the standard Keybase logfile, and returns its name, its File object, or an Error if it didn't work out.

func OpenSig ¶ 

func OpenSig(armored string) (ret []byte, id keybase1.SigID, err error)

OpenSig takes an armored PGP or Keybase signature and opens the armor. It will return the body of the signature, the sigID of the body, or an error if it didn't work out.

func PGPDetect ¶ 

func PGPDetect(p *Peeker) (armored, clearsign bool)

func PGPEncrypt ¶ 

func PGPEncrypt(source io.Reader, sink io.WriteCloser, signer *PGPKeyBundle, recipients []*PGPKeyBundle) error

func PGPEncryptString ¶ 

func PGPEncryptString(input string, signer *PGPKeyBundle, recipients []*PGPKeyBundle) ([]byte, error)

func PGPKeyRawToArmored ¶ 

func PGPKeyRawToArmored(raw []byte, priv bool) (ret string, err error)

func PGPLookup ¶ 

func PGPLookup(g *GlobalContext, id uint64) (username, uid string, err error)

func PGPLookupFingerprint ¶ 

func PGPLookupFingerprint(g *GlobalContext, fp *PGPFingerprint) (username, uid string, err error)

func PGPLookupHex ¶ 

func PGPLookupHex(g *GlobalContext, hexID string) (username, uid string, err error)

func PacketArmoredEncode ¶ 

func PacketArmoredEncode(p Packetable) (ret string, err error)

func ParseCA ¶ 

func ParseCA(raw string) (*x509.CertPool, error)

func ParseDNS ¶ 

func ParseDNS(s string) (ret string, err error)

func ParseGpgIndexStream ¶ 

func ParseGpgIndexStream(stream io.Reader) (ki *GpgKeyIndex, w Warnings, err error)

func ParseWeb ¶ 

func ParseWeb(s string) (hostname string, prot string, err error)

func PickFirstError ¶ 

func PickFirstError(errors ...error) error

func Pluralize ¶ 

func Pluralize(n int, singular string, plural string, nshow bool) string

Pluralize returns pluralized string with value. For example, 

Pluralize(1, "zebra", "zebras", true) => "1 zebra"
Pluralize(2, "zebra", "zebras", true) => "2 zebras"
Pluralize(2, "zebra", "zebras", false) => "zebras"

func PosixLineEndings ¶ 

func PosixLineEndings(arg string) string

func PostDeviceLKS ¶ 

func PostDeviceLKS(sr SessionReader, deviceID keybase1.DeviceID, deviceType string, serverHalf []byte,
	ppGen PassphraseGeneration,
	clientHalfRecovery string, clientHalfRecoveryKID keybase1.KID) error

func PostInviteRequest ¶ 

func PostInviteRequest(arg InviteRequestArg) (err error)

func ProofErrorIsSoft ¶ 

func ProofErrorIsSoft(pe ProofError) bool

func ProofErrorToState ¶ 

func ProofErrorToState(pe ProofError) keybase1.ProofState

func RandBytes ¶ 

func RandBytes(length int) ([]byte, error)

func RandInt ¶ 

func RandInt() (int, error)

func RandInt64 ¶ 

func RandInt64() (int64, error)

func RandIntn ¶ 

func RandIntn(n int) int

func RandString ¶ 

func RandString(prefix string, numbytes int) (string, error)

RandString returns random (base32) string with prefix.

func RegisterProofCheckHook ¶ 

func RegisterProofCheckHook(s string, h ProofCheckHook)

func RegisterServiceType ¶ 

func RegisterServiceType(st ServiceType)

func RegisterSocialNetwork ¶ 

func RegisterSocialNetwork(s string)

func RemoveLocalTrack ¶ 

func RemoveLocalTrack(tracker keybase1.UID, trackee keybase1.UID, g *GlobalContext) error

func RemoveNilErrors ¶ 

func RemoveNilErrors(errs []error) []error

RemoveNilErrors returns error slice with ni errors removed.

func RunSyncer ¶ 

func RunSyncer(s Syncer, uid keybase1.UID, loggedIn bool, sr SessionReader) (err error)

func SafeWriteToFile ¶ 

func SafeWriteToFile(t SafeWriter, mode os.FileMode) error

SafeWriteToFile to safely write to a file. Use mode=0 for default permissions.

func SecWordList ¶ 

func SecWordList(entropy int) ([]string, error)

SecWordList returns an array of words from secwords. It returns enough words to satisfy the desired entropy.

func SecureByteArrayEq ¶ 

func SecureByteArrayEq(a, b []byte) bool

func ShortCA ¶ 

func ShortCA(raw string) string

func SigAssertKbPayload ¶ 

func SigAssertKbPayload(armored string, expected []byte) (sigID keybase1.SigID, err error)

func SigAssertPGPPayload ¶ 

func SigAssertPGPPayload(armored string, expected []byte) (sigID keybase1.SigID, err error)

func SigAssertPayload ¶ 

func SigAssertPayload(armored string, expected []byte) (sigID keybase1.SigID, err error)

func SimpleSign ¶ 

func SimpleSign(payload []byte, key PGPKeyBundle) (out string, id keybase1.SigID, err error)

SimpleSign signs the given data stream, outputs an armored string which is the attached signature of the input data

func SplitHost ¶ 

func SplitHost(joined string) (host string, port int, err error)

func StoreLocalTrack ¶ 

func StoreLocalTrack(tracker keybase1.UID, trackee keybase1.UID, statement *jsonw.Wrapper, g *GlobalContext) error

func Tablify ¶ 

func Tablify(writer io.Writer, headings []string, rowfunc func() []string)

func TempFile ¶ 

func TempFile(prefix string, mode os.FileMode) (string, *os.File, error)

TempFile creates a termporary file. Use mode=0 for default permissions.

func TorParseProxy ¶ 

func TorParseProxy(s string) (*url.URL, error)

func TrimCicmp ¶ 

func TrimCicmp(s1, s2 string) bool

func UIDFromHex ¶ 

func UIDFromHex(s string) (keybase1.UID, error)

func UIDWrapper ¶ 

func UIDWrapper(uid keybase1.UID) *jsonw.Wrapper

func Uniquify ¶ 

func Uniquify(inp []string) []string

func UnixToTimeMappingZero ¶ 

func UnixToTimeMappingZero(unixTime int64) time.Time

The standard time.Unix() converter interprets 0 as the Unix epoch (1970). But in PGP, an expiry time of zero indicates that a key never expires, and it would be nice to be able to check for that case with Time.IsZero(). This conversion special-cases 0 to be time.Time's zero-value (1 AD), so that we get that nice property.

func Unquote ¶ 

func Unquote(data []byte) string

func UsernameToUID ¶ 

func UsernameToUID(s string) keybase1.UID

UsernameToUID works for users created after "Fri Feb 6 19:33:08 EST 2015", with some exceptions, since we didn't ToLower() for all UIDs

func UsernameToUIDPreserveCase ¶ 

func UsernameToUIDPreserveCase(s string) keybase1.UID

UsernameToUID works for users created after "Fri Feb 6 19:33:08 EST 2015". Some of them had buggy Username -> UID conversions, in which case we need to hash the original case to recover their UID.

func VersionMessage ¶ 

func VersionMessage(linefn func(string))

func VersionString ¶ 

func VersionString() string

VersionString returns semantic version string.

func WrapError ¶ 

func WrapError(e error) interface{}

func XORBytes ¶ 

func XORBytes(dst, a, b []byte) int

Types ¶

type API ¶ 

type API interface {
	Get(APIArg) (*APIRes, error)
	GetResp(APIArg) (*http.Response, error)
	GetDecode(APIArg, interface{}) error
	Post(APIArg) (*APIRes, error)
	PostJSON(APIArg) (*APIRes, error)
	PostResp(APIArg) (*http.Response, error)
	PostDecode(APIArg, interface{}) error
}

type APIArg ¶ 

type APIArg struct {
	Endpoint string

	Args        HTTPArgs
	JSONPayload JSONPayload
	NeedSession bool
	SessionR    SessionReader
	HTTPStatus  []int
	AppStatus   []string
	DecodeTo    interface{}
	Contextified
	// contains filtered or unexported fields
}

type APIError ¶ 

type APIError struct {
	Msg  string
	Code int
}

func NewAPIErrorFromHTTPResponse ¶ 

func NewAPIErrorFromHTTPResponse(r *http.Response) *APIError

func (*APIError) Error ¶ 

func (a *APIError) Error() string

type APINetError ¶ 

type APINetError struct {
	// contains filtered or unexported fields
}

func (APINetError) Error ¶ 

func (e APINetError) Error() string

func (APINetError) ToStatus ¶ 

func (e APINetError) ToStatus() (s keybase1.Status)

type APIRes ¶ 

type APIRes struct {
	Status     *jsonw.Wrapper
	Body       *jsonw.Wrapper
	HTTPStatus int
	AppStatus  string
}

type APIStatus ¶ 

type APIStatus struct {
	Code int    `json:"code"`
	Name string `json:"name"`
}

type Account ¶ 

type Account struct {
	Contextified
	// contains filtered or unexported fields
}

func NewAccount ¶ 

func NewAccount(g *GlobalContext) *Account

func (*Account) CachedSecretKey ¶ 

func (a *Account) CachedSecretKey(ska SecretKeyArg) (GenericKey, error)

func (*Account) ClearCachedSecretKeys ¶ 

func (a *Account) ClearCachedSecretKeys()

func (*Account) ClearLoginSession ¶ 

func (a *Account) ClearLoginSession()

ClearLoginSession clears out any cached login sessions with the account object

func (*Account) ClearStreamCache ¶ 

func (a *Account) ClearStreamCache()

func (*Account) CreateLoginSessionWithSalt ¶ 

func (a *Account) CreateLoginSessionWithSalt(emailOrUsername string, salt []byte) error

func (*Account) CreateStreamCache ¶ 

func (a *Account) CreateStreamCache(tsec *triplesec.Cipher, pps *PassphraseStream)

func (*Account) CreateStreamCacheViaStretch ¶ 

func (a *Account) CreateStreamCacheViaStretch(passphrase string) error

func (*Account) Dump ¶ 

func (a *Account) Dump()

func (*Account) EnsureUsername ¶ 

func (a *Account) EnsureUsername(username NormalizedUsername)

func (*Account) GetStreamGeneration ¶ 

func (a *Account) GetStreamGeneration() (ret PassphraseGeneration)

GetStreamGeneration() gets the generation of the currently cached passphrase stream

func (*Account) Keyring ¶ 

func (a *Account) Keyring() (*SKBKeyringFile, error)

func (*Account) LoadLoginSession ¶ 

func (a *Account) LoadLoginSession(emailOrUsername string) error

func (*Account) LocalSession ¶ 

func (a *Account) LocalSession() *Session

func (*Account) LockedLocalSecretKey ¶ 

func (a *Account) LockedLocalSecretKey(ska SecretKeyArg) (*SKB, error)

LockedLocalSecretKey looks in the local keyring to find a key for the given user. Returns non-nil if one was found, and nil otherwise.

func (*Account) LoggedIn ¶ 

func (a *Account) LoggedIn() bool

LoggedIn returns true if the user is logged in. It does not try to load the session.

func (*Account) LoggedInAndProvisioined ¶ 

func (a *Account) LoggedInAndProvisioined() bool

func (*Account) LoggedInLoad ¶ 

func (a *Account) LoggedInLoad() (bool, error)

LoggedInLoad will load and check the session with the api server if necessary.

func (*Account) LoggedInProvisionedLoad ¶ 

func (a *Account) LoggedInProvisionedLoad() (bool, error)

func (*Account) LoginSession ¶ 

func (a *Account) LoginSession() *LoginSession

func (*Account) Logout ¶ 

func (a *Account) Logout() error

func (*Account) PassphraseStream ¶ 

func (a *Account) PassphraseStream() *PassphraseStream

PassphraseStream returns a copy of the currently cached passphrase stream, or nil if none is there.

func (*Account) PassphraseStreamCache ¶ 

func (a *Account) PassphraseStreamCache() *PassphraseStreamCache

func (*Account) PassphraseStreamRef ¶ 

func (a *Account) PassphraseStreamRef() *PassphraseStream

PassphraseStreamRef returns a reference to the actual passphrase stream, or nil if none is there.

func (*Account) RunSecretSyncer ¶ 

func (a *Account) RunSecretSyncer(uid keybase1.UID) error

func (*Account) SaveState ¶ 

func (a *Account) SaveState(sessionID, csrf string, username NormalizedUsername, uid keybase1.UID, deviceID keybase1.DeviceID) error

SaveState saves the logins state to memory, and to the user config file.

func (*Account) SaveStateTmp ¶ 

func (a *Account) SaveStateTmp(sessionID, csrf string, username NormalizedUsername, uid keybase1.UID, deviceID keybase1.DeviceID) (filename string, err error)

SaveStateTmp saves the logins state to memory, and to a temporary config file.

func (*Account) SecretSyncer ¶ 

func (a *Account) SecretSyncer() *SecretSyncer

func (*Account) SetCachedSecretKey ¶ 

func (a *Account) SetCachedSecretKey(ska SecretKeyArg, key GenericKey) error

func (*Account) SetStreamGeneration ¶ 

func (a *Account) SetStreamGeneration(gen PassphraseGeneration, nilPPStreamOK bool)

SetStreamGeneration sets the passphrase generation on the cached stream if it exists, and otherwise will wind up warning of a problem.

func (*Account) Shutdown ¶ 

func (a *Account) Shutdown() error

func (*Account) UnloadLocalSession ¶ 

func (a *Account) UnloadLocalSession()

func (*Account) UserInfo ¶ 

func (a *Account) UserInfo() (uid keybase1.UID, username NormalizedUsername,
	token string, deviceSubkey, deviceSibkey GenericKey, err error)

type AlgoType ¶ 

type AlgoType int

type AlreadyRegisteredError ¶ 

type AlreadyRegisteredError struct {
	UID keybase1.UID
}

func (AlreadyRegisteredError) Error ¶ 

func (u AlreadyRegisteredError) Error() string

type AppConfig ¶ 

type AppConfig struct {
	NullConfiguration
	HomeDir                     string
	RunMode                     RunMode
	Debug                       bool
	LocalRPCDebug               string
	ServerURI                   string
	SecurityAccessGroupOverride bool
}

func (AppConfig) GetDebug ¶ 

func (c AppConfig) GetDebug() (bool, bool)

func (AppConfig) GetHome ¶ 

func (c AppConfig) GetHome() string

func (AppConfig) GetLocalRPCDebug ¶ 

func (c AppConfig) GetLocalRPCDebug() string

func (AppConfig) GetRunMode ¶ 

func (c AppConfig) GetRunMode() (RunMode, error)

func (AppConfig) GetSecurityAccessGroupOverride ¶ 

func (c AppConfig) GetSecurityAccessGroupOverride() (bool, bool)

func (AppConfig) GetServerURI ¶ 

func (c AppConfig) GetServerURI() string

type AppStatusError ¶ 

type AppStatusError struct {
	Code   int
	Name   string
	Desc   string
	Fields map[string]string
}

func NewAppStatusError ¶ 

func NewAppStatusError(jw *jsonw.Wrapper) AppStatusError

func (AppStatusError) Error ¶ 

func (a AppStatusError) Error() string

func (AppStatusError) IsBadField ¶ 

func (a AppStatusError) IsBadField(s string) bool

func (AppStatusError) ToStatus ¶ 

func (a AppStatusError) ToStatus() keybase1.Status

type ApplyFn ¶ 

type ApplyFn func(i ConnectionID, xp rpc.Transporter) bool

ApplyFn can be applied to every connection. It is called with the RPC transporter, and also the connectionID. It should return a bool true to keep going and false to stop.

type AssertionAnd ¶ 

type AssertionAnd struct {
	// contains filtered or unexported fields
}

func NewAssertionAnd ¶ 

func NewAssertionAnd(left, right AssertionExpression) AssertionAnd

func (AssertionAnd) CollectUrls ¶ 

func (a AssertionAnd) CollectUrls(v []AssertionURL) []AssertionURL

func (AssertionAnd) HasOr ¶ 

func (a AssertionAnd) HasOr() bool

func (AssertionAnd) MatchSet ¶ 

func (a AssertionAnd) MatchSet(ps ProofSet) bool

func (AssertionAnd) String ¶ 

func (a AssertionAnd) String() string

type AssertionDNS ¶ 

type AssertionDNS struct{ AssertionURLBase }

func (AssertionDNS) Check ¶ 

func (a AssertionDNS) Check() (err error)

func (AssertionDNS) CollectUrls ¶ 

func (a AssertionDNS) CollectUrls(v []AssertionURL) []AssertionURL

func (AssertionDNS) MatchSet ¶ 

func (a AssertionDNS) MatchSet(ps ProofSet) bool

func (AssertionDNS) ToLookup ¶ 

func (a AssertionDNS) ToLookup() (key, value string, err error)

type AssertionExpression ¶ 

type AssertionExpression interface {
	String() string
	MatchSet(ps ProofSet) bool
	HasOr() bool
	CollectUrls([]AssertionURL) []AssertionURL
}

func AssertionParse ¶ 

func AssertionParse(s string) (AssertionExpression, error)

func AssertionParseAndOnly ¶ 

func AssertionParseAndOnly(s string) (AssertionExpression, error)

type AssertionFingerprint ¶ 

type AssertionFingerprint struct{ AssertionURLBase }

func (AssertionFingerprint) CollectUrls ¶ 

func (a AssertionFingerprint) CollectUrls(v []AssertionURL) []AssertionURL

func (AssertionFingerprint) IsFingerprint ¶ 

func (a AssertionFingerprint) IsFingerprint() bool

func (AssertionFingerprint) MatchProof ¶ 

func (a AssertionFingerprint) MatchProof(proof Proof) bool

Fingerprint matching is on the suffixes. If the assertion matches any suffix of the proof, then we're OK

func (AssertionFingerprint) MatchSet ¶ 

func (a AssertionFingerprint) MatchSet(ps ProofSet) bool

func (AssertionFingerprint) ToLookup ¶ 

func (a AssertionFingerprint) ToLookup() (key, value string, err error)

type AssertionHTTP ¶ 

type AssertionHTTP struct{ AssertionURLBase }

func (AssertionHTTP) Check ¶ 

func (a AssertionHTTP) Check() (err error)

func (AssertionHTTP) CollectUrls ¶ 

func (a AssertionHTTP) CollectUrls(v []AssertionURL) []AssertionURL

func (AssertionHTTP) Keys ¶ 

func (a AssertionHTTP) Keys() []string

func (AssertionHTTP) MatchSet ¶ 

func (a AssertionHTTP) MatchSet(ps ProofSet) bool

func (AssertionHTTP) ToLookup ¶ 

func (a AssertionHTTP) ToLookup() (key, value string, err error)

type AssertionHTTPS ¶ 

type AssertionHTTPS struct{ AssertionURLBase }

func (AssertionHTTPS) Check ¶ 

func (a AssertionHTTPS) Check() (err error)

func (AssertionHTTPS) CollectUrls ¶ 

func (a AssertionHTTPS) CollectUrls(v []AssertionURL) []AssertionURL

func (AssertionHTTPS) MatchSet ¶ 

func (a AssertionHTTPS) MatchSet(ps ProofSet) bool

func (AssertionHTTPS) ToLookup ¶ 

func (a AssertionHTTPS) ToLookup() (key, value string, err error)

type AssertionKeybase ¶ 

type AssertionKeybase struct{ AssertionURLBase }

func (AssertionKeybase) CollectUrls ¶ 

func (a AssertionKeybase) CollectUrls(v []AssertionURL) []AssertionURL

func (AssertionKeybase) IsKeybase ¶ 

func (a AssertionKeybase) IsKeybase() bool

func (AssertionKeybase) MatchSet ¶ 

func (a AssertionKeybase) MatchSet(ps ProofSet) bool

func (AssertionKeybase) ToLookup ¶ 

func (a AssertionKeybase) ToLookup() (key, value string, err error)

type AssertionOr ¶ 

type AssertionOr struct {
	// contains filtered or unexported fields
}

func NewAssertionOr ¶ 

func NewAssertionOr(left, right AssertionExpression) AssertionOr

func (AssertionOr) CollectUrls ¶ 

func (a AssertionOr) CollectUrls(v []AssertionURL) []AssertionURL

func (AssertionOr) HasOr ¶ 

func (a AssertionOr) HasOr() bool

func (AssertionOr) MatchSet ¶ 

func (a AssertionOr) MatchSet(ps ProofSet) bool

func (AssertionOr) String ¶ 

func (a AssertionOr) String() string

type AssertionParseError ¶ 

type AssertionParseError struct {
	// contains filtered or unexported fields
}

func NewAssertionParseError ¶ 

func NewAssertionParseError(s string, a ...interface{}) AssertionParseError

func NewNeedInputError ¶ 

func NewNeedInputError(s string, a ...interface{}) AssertionParseError

func (AssertionParseError) Error ¶ 

func (e AssertionParseError) Error() string

type AssertionSocial ¶ 

type AssertionSocial struct{ AssertionURLBase }

func (AssertionSocial) Check ¶ 

func (a AssertionSocial) Check() (err error)

func (AssertionSocial) CollectUrls ¶ 

func (a AssertionSocial) CollectUrls(v []AssertionURL) []AssertionURL

func (AssertionSocial) IsSocial ¶ 

func (a AssertionSocial) IsSocial() bool

func (AssertionSocial) MatchSet ¶ 

func (a AssertionSocial) MatchSet(ps ProofSet) bool

func (AssertionSocial) ToLookup ¶ 

func (a AssertionSocial) ToLookup() (key, value string, err error)

type AssertionUID ¶ 

type AssertionUID struct {
	AssertionURLBase
	// contains filtered or unexported fields
}

func (AssertionUID) Check ¶ 

func (a AssertionUID) Check() (err error)

func (AssertionUID) CollectUrls ¶ 

func (a AssertionUID) CollectUrls(v []AssertionURL) []AssertionURL

func (AssertionUID) IsUID ¶ 

func (a AssertionUID) IsUID() bool

func (AssertionUID) MatchSet ¶ 

func (a AssertionUID) MatchSet(ps ProofSet) bool

func (AssertionUID) ToLookup ¶ 

func (a AssertionUID) ToLookup() (key, value string, err error)

func (AssertionUID) ToUID ¶ 

func (a AssertionUID) ToUID() keybase1.UID

type AssertionURL ¶ 

type AssertionURL interface {
	AssertionExpression
	Keys() []string
	Check() error
	IsKeybase() bool
	IsUID() bool
	ToUID() keybase1.UID
	IsSocial() bool
	IsFingerprint() bool
	MatchProof(p Proof) bool
	ToKeyValuePair() (string, string)
	CacheKey() string
	GetValue() string
	ToLookup() (string, string, error)
}

func ParseAssertionURL ¶ 

func ParseAssertionURL(s string, strict bool) (ret AssertionURL, err error)

func ParseAssertionURLKeyValue ¶ 

func ParseAssertionURLKeyValue(key, val string,
	strict bool) (ret AssertionURL, err error)

type AssertionURLBase ¶ 

type AssertionURLBase struct {
	Key, Value string
}

func (AssertionURLBase) CacheKey ¶ 

func (b AssertionURLBase) CacheKey() string

func (AssertionURLBase) Check ¶ 

func (b AssertionURLBase) Check() error

func (AssertionURLBase) CheckHost ¶ 

func (b AssertionURLBase) CheckHost() (err error)

func (AssertionURLBase) GetValue ¶ 

func (b AssertionURLBase) GetValue() string

func (AssertionURLBase) HasOr ¶ 

func (b AssertionURLBase) HasOr() bool

func (AssertionURLBase) IsFingerprint ¶ 

func (b AssertionURLBase) IsFingerprint() bool

func (AssertionURLBase) IsKeybase ¶ 

func (b AssertionURLBase) IsKeybase() bool

func (AssertionURLBase) IsSocial ¶ 

func (b AssertionURLBase) IsSocial() bool

func (AssertionURLBase) IsUID ¶ 

func (b AssertionURLBase) IsUID() bool

func (AssertionURLBase) Keys ¶ 

func (b AssertionURLBase) Keys() []string

func (AssertionURLBase) MatchProof ¶ 

func (b AssertionURLBase) MatchProof(proof Proof) bool

func (AssertionURLBase) String ¶ 

func (b AssertionURLBase) String() string

func (AssertionURLBase) ToKeyValuePair ¶ 

func (b AssertionURLBase) ToKeyValuePair() (string, string)

func (AssertionURLBase) ToUID ¶ 

func (b AssertionURLBase) ToUID() (ret keybase1.UID)

type AssertionWeb ¶ 

type AssertionWeb struct{ AssertionURLBase }

func (AssertionWeb) Check ¶ 

func (a AssertionWeb) Check() (err error)

func (AssertionWeb) CollectUrls ¶ 

func (a AssertionWeb) CollectUrls(v []AssertionURL) []AssertionURL

func (AssertionWeb) Keys ¶ 

func (a AssertionWeb) Keys() []string

func (AssertionWeb) MatchSet ¶ 

func (a AssertionWeb) MatchSet(ps ProofSet) bool

func (AssertionWeb) ToLookup ¶ 

func (a AssertionWeb) ToLookup() (key, value string, err error)

type B ¶ 

type B struct {
	Val bool
}

func (B) String ¶ 

func (b B) String() string

type BadFingerprintError ¶ 

type BadFingerprintError struct {
	// contains filtered or unexported fields
}

func (BadFingerprintError) Error ¶ 

func (b BadFingerprintError) Error() string

type BadKeyError ¶ 

type BadKeyError struct {
	Msg string
}

func (BadKeyError) Error ¶ 

func (p BadKeyError) Error() string

type BadRevocationError ¶ 

type BadRevocationError struct {
	// contains filtered or unexported fields
}

func (BadRevocationError) Error ¶ 

func (e BadRevocationError) Error() string

type BadServiceError ¶ 

type BadServiceError struct {
	Service string
}

func (BadServiceError) Error ¶ 

func (e BadServiceError) Error() string

type BadSigError ¶ 

type BadSigError struct {
	E string
}

func (BadSigError) Error ¶ 

func (e BadSigError) Error() string

type BadUsernameError ¶ 

type BadUsernameError struct {
	// contains filtered or unexported fields
}

func (BadUsernameError) Error ¶ 

func (e BadUsernameError) Error() string

type Base ¶ 

type Base struct {
	// contains filtered or unexported fields
}

func (Base) Join ¶ 

func (b Base) Join(elem ...string) string

func (Base) Unsplit ¶ 

func (b Base) Unsplit(v []string) string

type Base64Finder ¶ 

type Base64Finder struct {
	// contains filtered or unexported fields
}

func NewBase64Finder ¶ 

func NewBase64Finder(i string) *Base64Finder

func (*Base64Finder) Run ¶ 

func (s *Base64Finder) Run() []string

type BaseAPIEngine ¶ 

type BaseAPIEngine struct {
	Contextified
	// contains filtered or unexported fields
}

Shared code across Internal and External APIs

func (*BaseAPIEngine) PrepareGet ¶ 

func (api *BaseAPIEngine) PrepareGet(url url.URL, arg APIArg) (*http.Request, error)

func (*BaseAPIEngine) PreparePost ¶ 

func (api *BaseAPIEngine) PreparePost(url url.URL, arg APIArg, sendJSON bool) (*http.Request, error)

type BaseServiceType ¶ 

type BaseServiceType struct{}

func (BaseServiceType) BaseAllStringKeys ¶ 

func (t BaseServiceType) BaseAllStringKeys(st ServiceType) []string

func (BaseServiceType) BaseCheckProofForURL ¶ 

func (t BaseServiceType) BaseCheckProofForURL(text string, id keybase1.SigID) (err error)

func (BaseServiceType) BaseCheckProofTextFull ¶ 

func (t BaseServiceType) BaseCheckProofTextFull(text string, id keybase1.SigID, sig string) (err error)

func (BaseServiceType) BaseCheckProofTextShort ¶ 

func (t BaseServiceType) BaseCheckProofTextShort(text string, id keybase1.SigID, med bool) error

func (BaseServiceType) BaseGetProofType ¶ 

func (t BaseServiceType) BaseGetProofType(st ServiceType) string

func (BaseServiceType) BasePrimaryStringKeys ¶ 

func (t BaseServiceType) BasePrimaryStringKeys(st ServiceType) []string

func (BaseServiceType) BaseRecheckProofPosting ¶ 

func (t BaseServiceType) BaseRecheckProofPosting(tryNumber int, status keybase1.ProofStatus) (warning *Markup, err error)

func (BaseServiceType) BaseToChecker ¶ 

func (t BaseServiceType) BaseToChecker(st ServiceType, hint string) Checker

func (BaseServiceType) BaseToServiceJSON ¶ 

func (t BaseServiceType) BaseToServiceJSON(st ServiceType, un string) *jsonw.Wrapper

func (BaseServiceType) FormatProofText ¶ 

func (t BaseServiceType) FormatProofText(ppr *PostProofRes) (string, error)

func (BaseServiceType) GetAPIArgKey ¶ 

func (t BaseServiceType) GetAPIArgKey() string

func (BaseServiceType) LastWriterWins ¶ 

func (t BaseServiceType) LastWriterWins() bool

func (BaseServiceType) NormalizeUsername ¶ 

func (t BaseServiceType) NormalizeUsername(s string) (string, error)

func (BaseServiceType) PreProofCheck ¶ 

func (t BaseServiceType) PreProofCheck(string) (*Markup, error)

func (BaseServiceType) PreProofWarning ¶ 

func (t BaseServiceType) PreProofWarning(remotename string) *Markup

type BtcOpts ¶ 

type BtcOpts struct {
	// contains filtered or unexported fields
}

type BucketDict ¶ 

type BucketDict struct {
	// contains filtered or unexported fields
}

func NewBuckDict ¶ 

func NewBuckDict() *BucketDict

func (*BucketDict) Add ¶ 

func (bd *BucketDict) Add(k string, v *GpgPrimaryKey)

func (BucketDict) Get ¶ 

func (bd BucketDict) Get(k string) []*GpgPrimaryKey

func (BucketDict) Get0Or1 ¶ 

func (bd BucketDict) Get0Or1(k string) (ret *GpgPrimaryKey, err error)

type BufferCloser ¶ 

type BufferCloser struct {
	*bytes.Buffer
}

BufferCloser is a Buffer that satisfies the io.Closer interface.

func NewBufferCloser ¶ 

func NewBufferCloser() *BufferCloser

func (*BufferCloser) Close ¶ 

func (b *BufferCloser) Close() error

type CanceledError ¶ 

type CanceledError struct {
	M string
}

func (CanceledError) Error ¶ 

func (c CanceledError) Error() string

func (CanceledError) ToStatus ¶ 

func (c CanceledError) ToStatus() (s keybase1.Status)
type ChainLink struct {
	// contains filtered or unexported fields
}

func ImportLinkFromServer ¶ 

func ImportLinkFromServer(parent *SigChain, jw *jsonw.Wrapper, selfUID keybase1.UID) (ret *ChainLink, err error)

func ImportLinkFromStorage ¶ 

func ImportLinkFromStorage(id LinkID, selfUID keybase1.UID, g *GlobalContext) (*ChainLink, error)
func NewChainLink(parent *SigChain, id LinkID, jw *jsonw.Wrapper) *ChainLink

func (*ChainLink) CheckNameAndID ¶ 

func (c *ChainLink) CheckNameAndID(s NormalizedUsername, i keybase1.UID) error

func (*ChainLink) GetCTime ¶ 

func (c *ChainLink) GetCTime() time.Time

func (*ChainLink) GetETime ¶ 

func (c *ChainLink) GetETime() time.Time

func (*ChainLink) GetKID ¶ 

func (c *ChainLink) GetKID() keybase1.KID

func (*ChainLink) GetMerkleSeqno ¶ 

func (c *ChainLink) GetMerkleSeqno() int

func (*ChainLink) GetPGPFingerprint ¶ 

func (c *ChainLink) GetPGPFingerprint() *PGPFingerprint

func (*ChainLink) GetPayloadJSON ¶ 

func (c *ChainLink) GetPayloadJSON() *jsonw.Wrapper

func (*ChainLink) GetPrev ¶ 

func (c *ChainLink) GetPrev() LinkID

func (*ChainLink) GetRevocations ¶ 

func (c *ChainLink) GetRevocations() []keybase1.SigID

func (*ChainLink) GetRevokeKids ¶ 

func (c *ChainLink) GetRevokeKids() []keybase1.KID

func (*ChainLink) GetSeqno ¶ 

func (c *ChainLink) GetSeqno() Seqno

func (*ChainLink) GetSigCheckCache ¶ 

func (c *ChainLink) GetSigCheckCache() (cki *ComputedKeyInfos)

func (*ChainLink) GetSigID ¶ 

func (c *ChainLink) GetSigID() keybase1.SigID

func (*ChainLink) GetUID ¶ 

func (c *ChainLink) GetUID() keybase1.UID

func (*ChainLink) IsBad ¶ 

func (c *ChainLink) IsBad() (isBad bool, reason string)

Returns whether or not this chain link is bad, and if so, what the reason is.

func (*ChainLink) IsInCurrentFamily ¶ 

func (c *ChainLink) IsInCurrentFamily(u *User) bool

========================================================================= IsInCurrentFamily checks to see if the given chainlink was signed by a key in the current family.

func (*ChainLink) MatchFingerprint ¶ 

func (c *ChainLink) MatchFingerprint(fp PGPFingerprint) bool

func (*ChainLink) Pack ¶ 

func (c *ChainLink) Pack() error

func (*ChainLink) Parent ¶ 

func (c *ChainLink) Parent() *SigChain

func (*ChainLink) PutSigCheckCache ¶ 

func (c *ChainLink) PutSigCheckCache(cki *ComputedKeyInfos)

func (*ChainLink) SetParent ¶ 

func (c *ChainLink) SetParent(parent *SigChain)

func (*ChainLink) Store ¶ 

func (c *ChainLink) Store(g *GlobalContext) (didStore bool, err error)

func (*ChainLink) ToEldestKID ¶ 

func (c *ChainLink) ToEldestKID() keybase1.KID

func (ChainLink) ToMerkleTriple ¶ 

func (c ChainLink) ToMerkleTriple() *MerkleTriple

ToLinkSummary converts a ChainLink into a MerkleTriple object.

func (*ChainLink) Typed ¶ 

func (c *ChainLink) Typed() TypedChainLink

func (*ChainLink) Unpack ¶ 

func (c *ChainLink) Unpack(trusted bool, selfUID keybase1.UID) (err error)

func (*ChainLink) UnpackComputedKeyInfos ¶ 

func (c *ChainLink) UnpackComputedKeyInfos(jw *jsonw.Wrapper) (err error)

func (*ChainLink) UnpackLocal ¶ 

func (c *ChainLink) UnpackLocal() (err error)

func (*ChainLink) UnpackPayloadJSON ¶ 

func (c *ChainLink) UnpackPayloadJSON(tmp *ChainLinkUnpacked) (err error)

func (*ChainLink) VerifyHash ¶ 

func (c *ChainLink) VerifyHash() error
func (c *ChainLink) VerifyLink() error

func (*ChainLink) VerifyPayload ¶ 

func (c *ChainLink) VerifyPayload() error

func (*ChainLink) VerifySigWithKeyFamily ¶ 

func (c *ChainLink) VerifySigWithKeyFamily(ckf ComputedKeyFamily) (cached bool, err error)

type ChainLinkError ¶ 

type ChainLinkError struct {
	// contains filtered or unexported fields
}

func (ChainLinkError) Error ¶ 

func (c ChainLinkError) Error() string

type ChainLinkFingerprintMismatchError ¶ 

type ChainLinkFingerprintMismatchError struct {
	Msg string
}

func (ChainLinkFingerprintMismatchError) Error ¶ 

func (e ChainLinkFingerprintMismatchError) Error() string

type ChainLinkKIDMismatchError ¶ 

type ChainLinkKIDMismatchError struct {
	Msg string
}

func (ChainLinkKIDMismatchError) Error ¶ 

func (e ChainLinkKIDMismatchError) Error() string

type ChainLinkPrevHashMismatchError ¶ 

type ChainLinkPrevHashMismatchError struct {
	Msg string
}

func (ChainLinkPrevHashMismatchError) Error ¶ 

func (e ChainLinkPrevHashMismatchError) Error() string

type ChainLinkUnpacked ¶ 

type ChainLinkUnpacked struct {
	// contains filtered or unexported fields
}

type ChainLinkWrongSeqnoError ¶ 

type ChainLinkWrongSeqnoError struct {
	Msg string
}

func (ChainLinkWrongSeqnoError) Error ¶ 

func (e ChainLinkWrongSeqnoError) Error() string

type ChainType ¶ 

type ChainType struct {
	DbType          ObjType
	Private         bool
	Encrypted       bool
	GetMerkleTriple func(u *MerkleUserLeaf) *MerkleTriple
}

type CheckMember ¶ 

type CheckMember struct {
	Set []string
}

func (CheckMember) Checker ¶ 

func (c CheckMember) Checker() Checker

type CheckResult ¶ 

type CheckResult struct {
	Contextified
	Status ProofError // Or nil if it was a success
	Time   time.Time  // When the last check was
}

func NewCheckResult ¶ 

func NewCheckResult(g *GlobalContext, jw *jsonw.Wrapper) (res *CheckResult, err error)

func NewNowCheckResult ¶ 

func NewNowCheckResult(g *GlobalContext, pe ProofError) *CheckResult

func (CheckResult) Export ¶ 

func (cr CheckResult) Export() *keybase1.CheckResult

func (CheckResult) IsFresh ¶ 

func (cr CheckResult) IsFresh() bool

func (CheckResult) Pack ¶ 

func (cr CheckResult) Pack() *jsonw.Wrapper

func (CheckResult) ToDisplayString ¶ 

func (cr CheckResult) ToDisplayString() string

type Checker ¶ 

type Checker struct {
	F             func(string) bool
	Hint          string
	PreserveSpace bool
}

type Client ¶ 

type Client struct {
	// contains filtered or unexported fields
}

func NewClient ¶ 

func NewClient(e *Env, config *ClientConfig, needCookie bool) *Client

type ClientConfig ¶ 

type ClientConfig struct {
	Host       string
	Port       int
	UseTLS     bool // XXX unused?
	URL        *url.URL
	RootCAs    *x509.CertPool
	Prefix     string
	UseCookies bool
	Timeout    time.Duration
}

type CoinbaseChecker ¶ 

type CoinbaseChecker struct {
	// contains filtered or unexported fields
}

func (*CoinbaseChecker) CheckHint ¶ 

func (rc *CoinbaseChecker) CheckHint(h SigHint) ProofError

func (*CoinbaseChecker) CheckStatus ¶ 

func (rc *CoinbaseChecker) CheckStatus(h SigHint) ProofError

func (*CoinbaseChecker) GetTorError ¶ 

func (rc *CoinbaseChecker) GetTorError() ProofError

func (*CoinbaseChecker) ProfileURL ¶ 

func (rc *CoinbaseChecker) ProfileURL() string

type CoinbaseServiceType ¶ 

type CoinbaseServiceType struct{ BaseServiceType }

func (CoinbaseServiceType) AllStringKeys ¶ 

func (t CoinbaseServiceType) AllStringKeys() []string

func (CoinbaseServiceType) CheckProofText ¶ 

func (t CoinbaseServiceType) CheckProofText(text string, id keybase1.SigID, sig string) (err error)

func (CoinbaseServiceType) CheckUsername ¶ 

func (t CoinbaseServiceType) CheckUsername(s string) (err error)

func (CoinbaseServiceType) DisplayName ¶ 

func (t CoinbaseServiceType) DisplayName(un string) string

func (CoinbaseServiceType) GetPrompt ¶ 

func (t CoinbaseServiceType) GetPrompt() string

func (CoinbaseServiceType) GetProofType ¶ 

func (t CoinbaseServiceType) GetProofType() string

func (CoinbaseServiceType) GetTypeName ¶ 

func (t CoinbaseServiceType) GetTypeName() string

func (CoinbaseServiceType) PostInstructions ¶ 

func (t CoinbaseServiceType) PostInstructions(un string) *Markup

func (CoinbaseServiceType) PrimaryStringKeys ¶ 

func (t CoinbaseServiceType) PrimaryStringKeys() []string

func (CoinbaseServiceType) RecheckProofPosting ¶ 

func (t CoinbaseServiceType) RecheckProofPosting(tryNumber int, status keybase1.ProofStatus, _ string) (warning *Markup, err error)

func (CoinbaseServiceType) ToChecker ¶ 

func (t CoinbaseServiceType) ToChecker() Checker

func (CoinbaseServiceType) ToServiceJSON ¶ 

func (t CoinbaseServiceType) ToServiceJSON(un string) *jsonw.Wrapper

type Command ¶ 

type Command interface {
	GetUsage() Usage
}

type CommandLine ¶ 

type CommandLine interface {
	GetHome() string
	GetServerURI() string
	GetConfigFilename() string
	GetSessionFilename() string
	GetDbFilename() string
	GetDebug() (bool, bool)
	GetProxy() string
	GetLogFormat() string
	GetGpgHome() string
	GetAPIDump() (bool, bool)
	GetUserCacheMaxAge() (time.Duration, bool)
	GetProofCacheSize() (int, bool)
	GetMerkleKIDs() []string
	GetPinentry() string
	GetGpg() string
	GetGpgOptions() []string
	GetPGPFingerprint() *PGPFingerprint
	GetSecretKeyringTemplate() string
	GetSocketFile() string
	GetPidFile() string
	GetStandalone() (bool, bool)
	GetAutoFork() (bool, bool)
	GetNoAutoFork() (bool, bool)
	GetLocalRPCDebug() string
	GetTimers() string
	GetSplitLogOutput() (bool, bool)
	GetLogFile() string
	GetRunMode() (RunMode, error)

	GetScraperTimeout() (time.Duration, bool)
	GetAPITimeout() (time.Duration, bool)

	GetTorMode() (TorMode, error)
	GetTorHiddenAddress() string
	GetTorProxy() string

	// Lower-level functions
	GetGString(string) string
	GetString(string) string
	GetBool(string, bool) (bool, bool)
}

type ComputedKeyFamily ¶ 

type ComputedKeyFamily struct {
	Contextified
	// contains filtered or unexported fields
}

ComputedKeyFamily is a joining of two sets of data; the KeyFamily is what the server returned and is not to be trusted; the ComputedKeyInfos is what we compute as a result of playing the user's sigchain forward.

func (*ComputedKeyFamily) Delegate ¶ 

func (ckf *ComputedKeyFamily) Delegate(tcl TypedChainLink) (err error)

Delegate performs a delegation to the key described in the given TypedChainLink. This maybe be a sub- or sibkey delegation.

func (ComputedKeyFamily) Export ¶ 

func (ckf ComputedKeyFamily) Export() []keybase1.PublicKey

func (ComputedKeyFamily) ExportDeviceKeys ¶ 

func (ckf ComputedKeyFamily) ExportDeviceKeys() []keybase1.PublicKey

func (ComputedKeyFamily) FindActiveEncryptionSubkey ¶ 

func (ckf ComputedKeyFamily) FindActiveEncryptionSubkey(kid keybase1.KID) (GenericKey, error)

FindActiveEncryptionSubkey takes a given KID and finds the corresponding active encryption subkey in the current key family. If for any reason it cannot find the key, it will return an error saying why. Otherwise, it will return the key. In this case either key is non-nil, or err is non-nil.

func (ComputedKeyFamily) FindActiveSibkey ¶ 

func (ckf ComputedKeyFamily) FindActiveSibkey(kid keybase1.KID) (key GenericKey, cki ComputedKeyInfo, err error)

FindActiveSibkey takes a given KID and finds the corresponding active sibkey in the current key family. If it cannot find the key, or if the key is no longer active (either by revocation, or by expiring), it will return an error saying why. Otherwise, it will return the key. In this case either key is non-nil, or err is non-nil.

func (ComputedKeyFamily) FindActiveSibkeyAtTime ¶ 

func (ckf ComputedKeyFamily) FindActiveSibkeyAtTime(kid keybase1.KID, t time.Time) (key GenericKey, cki ComputedKeyInfo, err error)

As FindActiveSibkey, but for a specific time. Note that going back in time only affects expiration, not revocation. Thus this function is mainly useful for validating the sigchain, when each delegation and revocation is getting replayed in order.

func (ComputedKeyFamily) FindKIDFromFingerprint ¶ 

func (ckf ComputedKeyFamily) FindKIDFromFingerprint(fp PGPFingerprint) (kid keybase1.KID, err error)

func (ComputedKeyFamily) FindKeyWithKIDUnsafe ¶ 

func (ckf ComputedKeyFamily) FindKeyWithKIDUnsafe(kid keybase1.KID) (GenericKey, error)

FindKeyWithKIDUnsafe returns a key given a KID. It doesn't check if the key is expired or revoked, so most callers should use the FindActive* methods.

func (ComputedKeyFamily) FindKeybaseName ¶ 

func (ckf ComputedKeyFamily) FindKeybaseName(s string) bool

FindKeybaseName looks at all PGP keys in this key family that are active sibkeys to find a key with a signed identity of <name@keybase.io>. IF found return true, and otherwise false.

func (ComputedKeyFamily) GetActivePGPKeys ¶ 

func (ckf ComputedKeyFamily) GetActivePGPKeys(sibkey bool) (ret []*PGPKeyBundle)

GetActivePGPKeys gets the active PGP keys from the ComputedKeyFamily. If sibkey is False it will return all active PGP keys. Otherwise, it will return only the Sibkeys. Note the keys need to be non-canceled, and non-expired.

func (ComputedKeyFamily) GetAllActiveKeysForDevice ¶ 

func (ckf ComputedKeyFamily) GetAllActiveKeysForDevice(deviceID keybase1.DeviceID) ([]keybase1.KID, error)

func (ComputedKeyFamily) GetAllActiveKeysWithRoleAtTime ¶ 

func (ckf ComputedKeyFamily) GetAllActiveKeysWithRoleAtTime(role KeyRole, t time.Time) (ret []GenericKey)

GetAllActiveSibkeys gets all active Sibkeys from given ComputedKeyFamily.

func (ComputedKeyFamily) GetAllActiveSibkeys ¶ 

func (ckf ComputedKeyFamily) GetAllActiveSibkeys() []GenericKey

GetAllActiveSibkeys gets all active Sibkeys from given ComputedKeyFamily.

func (ComputedKeyFamily) GetAllActiveSibkeysAtTime ¶ 

func (ckf ComputedKeyFamily) GetAllActiveSibkeysAtTime(t time.Time) []GenericKey

GetAllActiveSibkeys gets all active Sibkeys from given ComputedKeyFamily.

func (ComputedKeyFamily) GetAllActiveSubkeys ¶ 

func (ckf ComputedKeyFamily) GetAllActiveSubkeys() []GenericKey

func (ComputedKeyFamily) GetAllActiveSubkeysAtTime ¶ 

func (ckf ComputedKeyFamily) GetAllActiveSubkeysAtTime(t time.Time) (ret []GenericKey)

func (*ComputedKeyFamily) GetAllDevices ¶ 

func (ckf *ComputedKeyFamily) GetAllDevices() []*Device

func (*ComputedKeyFamily) GetCurrentDevice ¶ 

func (ckf *ComputedKeyFamily) GetCurrentDevice(g *GlobalContext) (*Device, error)

GetCurrentDevice returns the current device.

func (*ComputedKeyFamily) GetDeviceForKey ¶ 

func (ckf *ComputedKeyFamily) GetDeviceForKey(key GenericKey) (*Device, error)

GetDeviceForKey gets the device that this key is bound to, if any.

func (*ComputedKeyFamily) GetEncryptionSubkeyForDevice ¶ 

func (ckf *ComputedKeyFamily) GetEncryptionSubkeyForDevice(did keybase1.DeviceID) (key GenericKey, err error)

GetEncryptionSubkeyForDevice gets the current encryption subkey for the given device. Note that many devices might share an encryption public key but might have different secret keys.

func (ComputedKeyFamily) GetKeyRole ¶ 

func (ckf ComputedKeyFamily) GetKeyRole(kid keybase1.KID) (ret KeyRole)

GetKeyRole returns the KeyRole (sibkey/subkey/none), taking into account whether the key has been cancelled.

func (ComputedKeyFamily) GetKeyRoleAtTime ¶ 

func (ckf ComputedKeyFamily) GetKeyRoleAtTime(kid keybase1.KID, t time.Time) (ret KeyRole)

GetKeyRoleAtTime returns the KeyRole (sibkey/subkey/none), taking into account whether the key has been cancelled at time t.

func (*ComputedKeyFamily) GetSibkeyForDevice ¶ 

func (ckf *ComputedKeyFamily) GetSibkeyForDevice(did keybase1.DeviceID) (key GenericKey, err error)

GetSibkeyForDevice gets the current per-device key for the given Device. Will return nil if one isn't found, and set err for a real error. The sibkey should be a signing key, not an encryption key of course.

func (ComputedKeyFamily) HasActiveKey ¶ 

func (ckf ComputedKeyFamily) HasActiveKey() bool

HasActiveKey returns if the given ComputeKeyFamily has any active keys. The key has to be in the server-given KeyFamily and also in our ComputedKeyFamily. The former check is so that we can handle the case nuked sigchains. 

func (ckf ComputedKeyFamily) InsertEldestLink(tcl TypedChainLink, username NormalizedUsername) (err error)

func (*ComputedKeyFamily) Revoke ¶ 

func (ckf *ComputedKeyFamily) Revoke(tcl TypedChainLink) (err error)

Revoke examines a TypeChainLink and applies any revocations in the link to the current ComputedKeyInfos.

func (*ComputedKeyFamily) RevokeKid ¶ 

func (ckf *ComputedKeyFamily) RevokeKid(kid keybase1.KID, tcl TypedChainLink) (err error)

func (*ComputedKeyFamily) RevokeSig ¶ 

func (ckf *ComputedKeyFamily) RevokeSig(sig keybase1.SigID, tcl TypedChainLink) (err error)

func (*ComputedKeyFamily) SetActivePGPHash ¶ 

func (ckf *ComputedKeyFamily) SetActivePGPHash(kid keybase1.KID, hash string)

SetPGPHash sets the authoritative version (by hash) of a PGP key

func (*ComputedKeyFamily) UpdateDevices ¶ 

func (ckf *ComputedKeyFamily) UpdateDevices(tcl TypedChainLink) (err error)

UpdateDevices takes the Device object from the given ChainLink and updates keys to reflects any device changes encoded therein.

type ComputedKeyInfo ¶ 

type ComputedKeyInfo struct {
	Status KeyStatus
	Eldest bool
	Sibkey bool

	// These have to be ints so they can be written to disk and read
	// back in.
	CTime int64 // In Seconds since the Epoch
	ETime int64 // In Seconds since the Epoch or 0 if none

	// For subkeys, the KID of our parent (if valid)
	Parent keybase1.KID

	// For sibkeys, the KID of last-added subkey (if valid)
	Subkey keybase1.KID

	// Map of SigID -> KID
	Delegations map[keybase1.SigID]keybase1.KID
	DelegatedAt *KeybaseTime
	RevokedAt   *KeybaseTime

	// For PGP keys, the active version of the key. If unspecified, use the
	// legacy behavior of combining every instance of this key that we got from
	// the server minus revocations.
	ActivePGPHash string

	Contextified
}

ComputedKeyInfo is a set of annotations that we apply to a ServerKeyRecord. Everything here has been checked by the client. Each ComputedKeyInfo refers to exactly one ServerKeyInfo.

func NewComputedKeyInfo ¶ 

func NewComputedKeyInfo(eldest, sibkey bool, status KeyStatus, ctime, etime int64, activePGPHash string) ComputedKeyInfo

func (ComputedKeyInfo) GetCTime ¶ 

func (cki ComputedKeyInfo) GetCTime() time.Time

func (ComputedKeyInfo) GetETime ¶ 

func (cki ComputedKeyInfo) GetETime() time.Time

type ComputedKeyInfos ¶ 

type ComputedKeyInfos struct {

	// Map of KID to a computed info
	Infos map[keybase1.KID]*ComputedKeyInfo

	// Map of a SigID (in binary) to the ComputedKeyInfo describing when the key was
	// delegated.
	Sigs map[keybase1.SigID]*ComputedKeyInfo

	// Map of DeviceID to the most current device object
	Devices map[keybase1.DeviceID]*Device

	// Map of KID -> DeviceID
	KIDToDeviceID map[keybase1.KID]keybase1.DeviceID
	// contains filtered or unexported fields
}

When we play a sigchain forward, it yields ComputedKeyInfos (CKIs). We're going to store CKIs separately from the keys, since the server can clobber the former. We should rewrite CKIs every time we (re)check a user's SigChain

func NewComputedKeyInfos ¶ 

func NewComputedKeyInfos() *ComputedKeyInfos

func (*ComputedKeyInfos) Delegate ¶ 

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)

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 (*ComputedKeyInfos) Insert ¶ 

func (cki *ComputedKeyInfos) Insert(k keybase1.KID, i *ComputedKeyInfo)

Insert inserts the given ComputedKeyInfo object 1 or 2 times, depending on if a KID or PGPFingerprint or both are available.

func (ComputedKeyInfos) InsertLocalEldestKey ¶ 

func (cki ComputedKeyInfos) InsertLocalEldestKey(kid keybase1.KID)

func (ComputedKeyInfos) InsertServerEldestKey ¶ 

func (cki ComputedKeyInfos) InsertServerEldestKey(eldestKey GenericKey, un NormalizedUsername) error

For use when there are no chain links at all, so all we can do is trust the eldest key that the server reported.

func (*ComputedKeyInfos) PaperDevices ¶ 

func (cki *ComputedKeyInfos) PaperDevices() []*Device

PaperDevices returns a list of all the paperkey devices.

func (ComputedKeyInfos) ShallowCopy ¶ 

func (cki ComputedKeyInfos) ShallowCopy() *ComputedKeyInfos

TODO: Figure out whether this needs to be a deep copy. See https://github.com/keybase/client/issues/414 .

type ConfigError ¶ 

type ConfigError struct {
	// contains filtered or unexported fields
}

func (ConfigError) Error ¶ 

func (c ConfigError) Error() string

type ConfigGetter ¶ 

type ConfigGetter func() string

type ConfigReader ¶ 

type ConfigReader interface {
	GetHome() string
	GetServerURI() string
	GetConfigFilename() string
	GetSessionFilename() string
	GetDbFilename() string
	GetDebug() (bool, bool)
	GetAutoFork() (bool, bool)
	GetUserConfig() (*UserConfig, error)
	GetUserConfigForUsername(s NormalizedUsername) (*UserConfig, error)
	GetProxy() string
	GetLogFormat() string
	GetGpgHome() string
	GetBundledCA(host string) string
	GetStringAtPath(string) (string, bool)
	GetBoolAtPath(string) (bool, bool)
	GetIntAtPath(string) (int, bool)
	GetNullAtPath(string) bool
	GetUserCacheMaxAge() (time.Duration, bool)
	GetProofCacheSize() (int, bool)
	GetProofCacheLongDur() (time.Duration, bool)
	GetProofCacheMediumDur() (time.Duration, bool)
	GetProofCacheShortDur() (time.Duration, bool)
	GetMerkleKIDs() []string
	GetPinentry() string
	GetNoPinentry() (bool, bool)
	GetGpg() string
	GetGpgOptions() []string
	GetSecretKeyringTemplate() string
	GetSalt() []byte
	GetSocketFile() string
	GetPidFile() string
	GetStandalone() (bool, bool)
	GetLocalRPCDebug() string
	GetTimers() string
	GetDeviceID() keybase1.DeviceID
	GetUsername() NormalizedUsername
	GetAllUsernames() (current NormalizedUsername, others []NormalizedUsername, err error)
	GetUID() keybase1.UID
	GetProxyCACerts() ([]string, error)
	GetSplitLogOutput() (bool, bool)
	GetLogFile() string
	GetRunMode() (RunMode, error)
	GetScraperTimeout() (time.Duration, bool)
	GetAPITimeout() (time.Duration, bool)
	GetSecurityAccessGroupOverride() (bool, bool)

	GetTorMode() (TorMode, error)
	GetTorHiddenAddress() string
	GetTorProxy() string
}

type ConfigWriter ¶ 

type ConfigWriter interface {
	SetUserConfig(cfg *UserConfig, overwrite bool) error
	SwitchUser(un NormalizedUsername) error
	NukeUser(un NormalizedUsername) error
	SetDeviceID(keybase1.DeviceID) error
	SetStringAtPath(string, string) error
	SetBoolAtPath(string, bool) error
	SetIntAtPath(string, int) error
	SetNullAtPath(string) error
	DeleteAtPath(string)
	Reset()
	Write() error
	SaveTmp(suffix string) (string, error)
	SwapTmp(filename string) error
}

type ConnectionID ¶ 

type ConnectionID int

ConnectionID is a sequential integer assigned to each RPC connection that this process serves. No IDs are reused.

type ConnectionManager ¶ 

type ConnectionManager struct {
	// contains filtered or unexported fields
}

ConnectionManager manages all connections active for a given service. It can be called from multiple goroutines.

func NewConnectionManager ¶ 

func NewConnectionManager() *ConnectionManager

NewConnectionManager makes a new ConnectionManager and starts its internal routing loop running.

func (*ConnectionManager) AddConnection ¶ 

func (c *ConnectionManager) AddConnection(xp rpc.Transporter, closeListener chan error) ConnectionID

AddConnection adds a new connection to the table of Connection object, with a related closeListener. We'll listen for a close on that channel, and when one occurs, we'll remove the connection from the pool.

func (*ConnectionManager) ApplyAll ¶ 

func (c *ConnectionManager) ApplyAll(f ApplyFn)

ApplyAll applies the given function f to all connections in the table. If you're going to do something blocking, please do it in a GoRoutine, since we're holding the lock for all connections as we do this.

func (*ConnectionManager) LookupConnection ¶ 

func (c *ConnectionManager) LookupConnection(i ConnectionID) rpc.Transporter

LookupConnection looks up a connection given a connectionID, or returns nil if no such connection was found.

func (*ConnectionManager) Shutdown ¶ 

func (c *ConnectionManager) Shutdown()

type Contexitifier ¶ 

type Contexitifier interface {
	G() *GlobalContext
}

type Contextified ¶ 

type Contextified struct {
	// contains filtered or unexported fields
}

Contextified objects have explicit references to the GlobalContext, so that G can be swapped out for something else. We're going to incrementally start moving objects over to this system.

func NewContextified ¶ 

func NewContextified(gc *GlobalContext) Contextified

func (Contextified) G ¶ 

func (c Contextified) G() *GlobalContext

func (Contextified) GStrict ¶ 

func (c Contextified) GStrict() *GlobalContext

func (*Contextified) SetGlobalContext ¶ 

func (c *Contextified) SetGlobalContext(g *GlobalContext)
type CryptocurrencyChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseCryptocurrencyChainLink(b GenericChainLink) (
	cl *CryptocurrencyChainLink, err error)

func (CryptocurrencyChainLink) Display ¶ 

func (c CryptocurrencyChainLink) Display(ui IdentifyUI)

func (CryptocurrencyChainLink) Export ¶ 

func (c CryptocurrencyChainLink) Export() (ret keybase1.Cryptocurrency)

func (CryptocurrencyChainLink) GetAddress ¶ 

func (c CryptocurrencyChainLink) GetAddress() string

func (*CryptocurrencyChainLink) ToDisplayString ¶ 

func (c *CryptocurrencyChainLink) ToDisplayString() string

func (*CryptocurrencyChainLink) Type ¶ 

func (c *CryptocurrencyChainLink) Type() string

type CtimeMismatchError ¶ 

type CtimeMismatchError struct {
	Msg string
}

func (CtimeMismatchError) Error ¶ 

func (e CtimeMismatchError) Error() string

type CurrentStatus ¶ 

type CurrentStatus struct {
	Configured bool
	Registered bool
	LoggedIn   bool
	User       *User
}

func GetCurrentStatus ¶ 

func GetCurrentStatus(g *GlobalContext) (res CurrentStatus, err error)

func (CurrentStatus) Export ¶ 

func (c CurrentStatus) Export() (ret keybase1.GetCurrentStatusRes)

type DNSChecker ¶ 

type DNSChecker struct {
	// contains filtered or unexported fields
}

func (*DNSChecker) CheckDomain ¶ 

func (rc *DNSChecker) CheckDomain(sig string, domain string) ProofError

func (*DNSChecker) CheckHint ¶ 

func (rc *DNSChecker) CheckHint(h SigHint) ProofError

func (*DNSChecker) CheckStatus ¶ 

func (rc *DNSChecker) CheckStatus(h SigHint) ProofError

func (*DNSChecker) GetTorError ¶ 

func (rc *DNSChecker) GetTorError() ProofError

type DNSServiceType ¶ 

type DNSServiceType struct{ BaseServiceType }

func (DNSServiceType) AllStringKeys ¶ 

func (t DNSServiceType) AllStringKeys() []string

func (DNSServiceType) CheckProofText ¶ 

func (t DNSServiceType) CheckProofText(text string, id keybase1.SigID, sig string) (err error)

func (DNSServiceType) CheckUsername ¶ 

func (t DNSServiceType) CheckUsername(s string) error

func (DNSServiceType) DisplayName ¶ 

func (t DNSServiceType) DisplayName(un string) string

func (DNSServiceType) FormatProofText ¶ 

func (t DNSServiceType) FormatProofText(ppr *PostProofRes) (string, error)

func (DNSServiceType) GetAPIArgKey ¶ 

func (t DNSServiceType) GetAPIArgKey() string

func (DNSServiceType) GetPrompt ¶ 

func (t DNSServiceType) GetPrompt() string

func (DNSServiceType) GetProofType ¶ 

func (t DNSServiceType) GetProofType() string

func (DNSServiceType) GetTypeName ¶ 

func (t DNSServiceType) GetTypeName() string

func (DNSServiceType) LastWriterWins ¶ 

func (t DNSServiceType) LastWriterWins() bool

func (DNSServiceType) NormalizeUsername ¶ 

func (t DNSServiceType) NormalizeUsername(s string) (string, error)

func (DNSServiceType) PostInstructions ¶ 

func (t DNSServiceType) PostInstructions(un string) *Markup

func (DNSServiceType) PrimaryStringKeys ¶ 

func (t DNSServiceType) PrimaryStringKeys() []string

func (DNSServiceType) RecheckProofPosting ¶ 

func (t DNSServiceType) RecheckProofPosting(tryNumber int, status keybase1.ProofStatus, dn string) (warning *Markup, err error)

func (DNSServiceType) ToChecker ¶ 

func (t DNSServiceType) ToChecker() Checker

func (DNSServiceType) ToServiceJSON ¶ 

func (t DNSServiceType) ToServiceJSON(un string) *jsonw.Wrapper

type Darwin ¶ 

type Darwin struct {
	Base
}

func (Darwin) CacheDir ¶ 

func (d Darwin) CacheDir() string

func (Darwin) ConfigDir ¶ 

func (d Darwin) ConfigDir() string

func (Darwin) DataDir ¶ 

func (d Darwin) DataDir() string

func (Darwin) Home ¶ 

func (d Darwin) Home(emptyOk bool) string

func (Darwin) LogDir ¶ 

func (d Darwin) LogDir() string

func (Darwin) Normalize ¶ 

func (d Darwin) Normalize(s string) string

func (Darwin) RuntimeDir ¶ 

func (d Darwin) RuntimeDir() string

func (Darwin) ServiceSpawnDir ¶ 

func (d Darwin) ServiceSpawnDir() (string, error)

type DbKey ¶ 

type DbKey struct {
	Typ ObjType
	Key string
}

func DbKeyParse ¶ 

func DbKeyParse(s string) (string, *DbKey, error)

func DbKeyUID ¶ 

func DbKeyUID(t ObjType, uid keybase1.UID) DbKey

func LocalTrackDBKey ¶ 

func LocalTrackDBKey(tracker, trackee keybase1.UID) DbKey

func (DbKey) ToBytes ¶ 

func (k DbKey) ToBytes(table string) []byte

func (DbKey) ToString ¶ 

func (k DbKey) ToString(table string) string

type DecryptBadNonceError ¶ 

type DecryptBadNonceError struct{}

func (DecryptBadNonceError) Error ¶ 

func (d DecryptBadNonceError) Error() string

type DecryptBadPacketTypeError ¶ 

type DecryptBadPacketTypeError struct{}

func (DecryptBadPacketTypeError) Error ¶ 

func (d DecryptBadPacketTypeError) Error() string

type DecryptBadSenderError ¶ 

type DecryptBadSenderError struct{}

func (DecryptBadSenderError) Error ¶ 

func (d DecryptBadSenderError) Error() string

type DecryptOpenError ¶ 

type DecryptOpenError struct{}

func (DecryptOpenError) Error ¶ 

func (d DecryptOpenError) Error() string

type DecryptWrongReceiverError ¶ 

type DecryptWrongReceiverError struct{}

func (DecryptWrongReceiverError) Error ¶ 

func (d DecryptWrongReceiverError) Error() string

type DecryptionError ¶ 

type DecryptionError struct{}

func (DecryptionError) Error ¶ 

func (e DecryptionError) Error() string

type DelegationType ¶ 

type DelegationType LinkType

type Delegator ¶ 

type Delegator struct {
	Contextified

	// Set these fields
	NewKey            GenericKey
	ExistingKey       GenericKey
	EldestKID         keybase1.KID
	Me                *User
	Expire            int
	Device            *Device
	RevSig            string
	ServerHalf        []byte
	EncodedPrivateKey string
	Ctime             int64
	DelegationType    DelegationType
	Aggregated        bool // During aggregation we skip some steps (posting, updating some state)

	// Optional precalculated values used by KeyProof
	LastSeqno   Seqno     // kex2 HandleDidCounterSign needs to sign subkey without a user but we know what the last seqno was
	PrevLinkID  LinkID    // kex2 HandleDidCounterSign calculates previous link id without a user
	SigningUser UserBasic // kex2 doesn't have a full user, but does have basic user info
	// contains filtered or unexported fields
}

func (*Delegator) CheckArgs ¶ 

func (d *Delegator) CheckArgs() (err error)

func (Delegator) GetMerkleTriple ¶ 

func (d Delegator) GetMerkleTriple() MerkleTriple

GetMerkleTriple gets the new MerkleTriple that came about as a result of performing the key delegation.

func (Delegator) GetSigningKey ¶ 

func (d Delegator) GetSigningKey() GenericKey

func (Delegator) IsEldest ¶ 

func (d Delegator) IsEldest() bool

func (Delegator) IsSibkeyOrEldest ¶ 

func (d Delegator) IsSibkeyOrEldest() bool

func (*Delegator) LoadSigningKey ¶ 

func (d *Delegator) LoadSigningKey(lctx LoginContext, ui SecretUI) (err error)

LoadSigningKey can be called before Run() to load the signing key into the delegator. This will check the given key first, then a device Key if we have one, and otherwise will leave the signing key unset so that we will set it as the eldest key on upload. lctx can be nil.

func (*Delegator) Run ¶ 

func (d *Delegator) Run(lctx LoginContext) (err error)

Run the Delegator, performing all necessary internal operations. Return err on failure and nil on success.

func (*Delegator) SignAndPost ¶ 

func (d *Delegator) SignAndPost(lctx LoginContext, jw *jsonw.Wrapper) (err error)

type Device ¶ 

type Device struct {
	ID          keybase1.DeviceID `json:"id"`
	Kid         keybase1.KID      `json:"kid,omitempty"`
	Description *string           `json:"name,omitempty"`
	Status      *int              `json:"status,omitempty"`
	Type        string            `json:"type"`
}

func NewPaperDevice ¶ 

func NewPaperDevice(passphrasePrefix string) (*Device, error)

NewPaperDevice creates a new paper backup key device

func ParseDevice ¶ 

func ParseDevice(jw *jsonw.Wrapper) (ret *Device, err error)

func (*Device) Export ¶ 

func (d *Device) Export(lt LinkType) (*jsonw.Wrapper, error)

func (*Device) IsActive ¶ 

func (d *Device) IsActive() bool

func (*Device) Merge ¶ 

func (d *Device) Merge(d2 *Device)

func (*Device) ProtExport ¶ 

func (d *Device) ProtExport() *keybase1.Device
type DeviceChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseDeviceChainLink(b GenericChainLink) (ret *DeviceChainLink, err error)

func (*DeviceChainLink) GetDevice ¶ 

func (s *DeviceChainLink) GetDevice() *Device

type DeviceKey ¶ 

type DeviceKey struct {
	Type          string               `json:"type"`
	CTime         int64                `json:"ctime"`
	MTime         int64                `json:"mtime"`
	Description   string               `json:"name"`
	Status        int                  `json:"status"`
	LksServerHalf string               `json:"lks_server_half"`
	PPGen         PassphraseGeneration `json:"passphrase_generation"`
}

func (DeviceKey) Display ¶ 

func (d DeviceKey) Display() string

type DeviceKeyMap ¶ 

type DeviceKeyMap map[keybase1.DeviceID]DeviceKey

type DeviceRequiredError ¶ 

type DeviceRequiredError struct{}

func (DeviceRequiredError) Error ¶ 

func (e DeviceRequiredError) Error() string

func (DeviceRequiredError) ToStatus ¶ 

func (e DeviceRequiredError) ToStatus() keybase1.Status

type DeviceStatus ¶ 

type DeviceStatus struct {
	Provisioned  bool
	Keyed        bool
	KeyAvailable bool
}

type DeviceTypeSet ¶ 

type DeviceTypeSet map[string]bool

type DumbOutputUI ¶ 

type DumbOutputUI interface {
	Printf(fmt string, args ...interface{}) (int, error)
	PrintfStderr(fmt string, args ...interface{}) (int, error)
}

type EmptyKeyRing ¶ 

type EmptyKeyRing struct{}

func (EmptyKeyRing) DecryptionKeys ¶ 

func (k EmptyKeyRing) DecryptionKeys() []openpgp.Key

func (EmptyKeyRing) KeysById ¶ 

func (k EmptyKeyRing) KeysById(id uint64) []openpgp.Key

func (EmptyKeyRing) KeysByIdUsage ¶ 

func (k EmptyKeyRing) KeysByIdUsage(id uint64, usage byte) []openpgp.Key

type Env ¶ 

type Env struct {
	sync.RWMutex

	Test TestParameters
	// contains filtered or unexported fields
}

func NewEnv ¶ 

func NewEnv(cmd CommandLine, config ConfigReader) *Env

func (*Env) GenClientConfigForInternalAPI ¶ 

func (e *Env) GenClientConfigForInternalAPI() (*ClientConfig, error)

GenClientConfigForInternalAPI pulls the information out of the environment configuration, and build a Client config that will be used in all API server requests

func (*Env) GenClientConfigForScrapers ¶ 

func (e *Env) GenClientConfigForScrapers() (*ClientConfig, error)

func (*Env) GetAPIDump ¶ 

func (e *Env) GetAPIDump() bool

func (*Env) GetAPITimeout ¶ 

func (e *Env) GetAPITimeout() time.Duration

func (*Env) GetAutoFork ¶ 

func (e *Env) GetAutoFork() bool

func (*Env) GetBool ¶ 

func (e *Env) GetBool(def bool, flist ...func() (bool, bool)) bool

func (*Env) GetBundledCA ¶ 

func (e *Env) GetBundledCA(host string) string

func (*Env) GetCacheDir ¶ 

func (e *Env) GetCacheDir() string

func (*Env) GetCommandLine ¶ 

func (e *Env) GetCommandLine() CommandLine

func (*Env) GetConfig ¶ 

func (e *Env) GetConfig() ConfigReader

func (*Env) GetConfigDir ¶ 

func (e *Env) GetConfigDir() string

func (*Env) GetConfigFilename ¶ 

func (e *Env) GetConfigFilename() string

func (*Env) GetConfigWriter ¶ 

func (e *Env) GetConfigWriter() ConfigWriter

func (*Env) GetDataDir ¶ 

func (e *Env) GetDataDir() string

func (*Env) GetDbFilename ¶ 

func (e *Env) GetDbFilename() string

func (*Env) GetDebug ¶ 

func (e *Env) GetDebug() bool

func (*Env) GetDeviceID ¶ 

func (e *Env) GetDeviceID() keybase1.DeviceID

func (*Env) GetDoLogForward ¶ 

func (e *Env) GetDoLogForward() bool

func (*Env) GetDuration ¶ 

func (e *Env) GetDuration(def time.Duration, flist ...func() (time.Duration, bool)) time.Duration

func (*Env) GetEmail ¶ 

func (e *Env) GetEmail() string

func (*Env) GetEmailOrUsername ¶ 

func (e *Env) GetEmailOrUsername() string

func (*Env) GetGpg ¶ 

func (e *Env) GetGpg() string

func (*Env) GetGpgHome ¶ 

func (e *Env) GetGpgHome() string

func (*Env) GetGpgOptions ¶ 

func (e *Env) GetGpgOptions() []string

func (*Env) GetHome ¶ 

func (e *Env) GetHome() string

func (*Env) GetInt ¶ 

func (e *Env) GetInt(def int, flist ...func() (int, bool)) int

func (*Env) GetLabel ¶ 

func (e *Env) GetLabel() string

func (*Env) GetLocalRPCDebug ¶ 

func (e *Env) GetLocalRPCDebug() string

func (*Env) GetLogDir ¶ 

func (e *Env) GetLogDir() string

func (*Env) GetLogFile ¶ 

func (e *Env) GetLogFile() string

func (*Env) GetLogFormat ¶ 

func (e *Env) GetLogFormat() string

func (*Env) GetMerkleKIDs ¶ 

func (e *Env) GetMerkleKIDs() []keybase1.KID

func (*Env) GetNegBool ¶ 

func (e *Env) GetNegBool(def bool, flist []NegBoolFunc) bool

GetNegBool gets a negatable bool. You can give it a list of functions, and also possible negations for those functions.

func (*Env) GetNoPinentry ¶ 

func (e *Env) GetNoPinentry() bool

func (*Env) GetPidFile ¶ 

func (e *Env) GetPidFile() (ret string, err error)

func (*Env) GetPinentry ¶ 

func (e *Env) GetPinentry() string

func (*Env) GetProofCacheLongDur ¶ 

func (e *Env) GetProofCacheLongDur() time.Duration

func (*Env) GetProofCacheMediumDur ¶ 

func (e *Env) GetProofCacheMediumDur() time.Duration

func (*Env) GetProofCacheShortDur ¶ 

func (e *Env) GetProofCacheShortDur() time.Duration

func (*Env) GetProofCacheSize ¶ 

func (e *Env) GetProofCacheSize() int

func (*Env) GetProxy ¶ 

func (e *Env) GetProxy() string

func (*Env) GetRunMode ¶ 

func (e *Env) GetRunMode() RunMode

func (*Env) GetRuntimeDir ¶ 

func (e *Env) GetRuntimeDir() string

func (*Env) GetSalt ¶ 

func (e *Env) GetSalt() []byte

func (*Env) GetScraperTimeout ¶ 

func (e *Env) GetScraperTimeout() time.Duration

func (*Env) GetSecretKeyringTemplate ¶ 

func (e *Env) GetSecretKeyringTemplate() string

func (*Env) GetServerURI ¶ 

func (e *Env) GetServerURI() string

func (*Env) GetServiceSpawnDir ¶ 

func (e *Env) GetServiceSpawnDir() (string, error)

func (*Env) GetSessionFilename ¶ 

func (e *Env) GetSessionFilename() string

func (*Env) GetSocketFile ¶ 

func (e *Env) GetSocketFile() (ret string, err error)

func (*Env) GetSplitLogOutput ¶ 

func (e *Env) GetSplitLogOutput() bool

func (*Env) GetStandalone ¶ 

func (e *Env) GetStandalone() bool

func (*Env) GetStoredSecretAccessGroup ¶ 

func (e *Env) GetStoredSecretAccessGroup() string

func (*Env) GetStoredSecretServiceName ¶ 

func (e *Env) GetStoredSecretServiceName() string

func (*Env) GetString ¶ 

func (e *Env) GetString(flist ...(func() string)) string

func (*Env) GetStringList ¶ 

func (e *Env) GetStringList(list ...(func() []string)) []string

func (*Env) GetTimers ¶ 

func (e *Env) GetTimers() string

func (*Env) GetTorHiddenAddress ¶ 

func (e *Env) GetTorHiddenAddress() string

func (*Env) GetTorMode ¶ 

func (e *Env) GetTorMode() TorMode

func (*Env) GetTorProxy ¶ 

func (e *Env) GetTorProxy() string

func (*Env) GetUID ¶ 

func (e *Env) GetUID() keybase1.UID

func (*Env) GetUserCacheMaxAge ¶ 

func (e *Env) GetUserCacheMaxAge() time.Duration

func (*Env) GetUsername ¶ 

func (e *Env) GetUsername() NormalizedUsername

func (*Env) SetCommandLine ¶ 

func (e *Env) SetCommandLine(cmd CommandLine)

func (*Env) SetConfig ¶ 

func (e *Env) SetConfig(config ConfigReader)

func (*Env) SetConfigWriter ¶ 

func (e *Env) SetConfigWriter(writer ConfigWriter)

type ErrorUnwrapper ¶ 

type ErrorUnwrapper struct{}

func (ErrorUnwrapper) MakeArg ¶ 

func (eu ErrorUnwrapper) MakeArg() interface{}

func (ErrorUnwrapper) UnwrapError ¶ 

func (eu ErrorUnwrapper) UnwrapError(arg interface{}) (appError error, dispatchError error)

type ExportableError ¶ 

type ExportableError interface {
	error
	ToStatus() keybase1.Status
}

type ExportedStream ¶ 

type ExportedStream struct {
	// contains filtered or unexported fields
}

func (*ExportedStream) Export ¶ 

func (s *ExportedStream) Export() keybase1.Stream

type ExportedStreams ¶ 

type ExportedStreams struct {
	sync.Mutex
	// contains filtered or unexported fields
}

func NewExportedStreams ¶ 

func NewExportedStreams() *ExportedStreams

func (*ExportedStreams) Close ¶ 

func (s *ExportedStreams) Close(_ context.Context, a keybase1.CloseArg) (err error)

func (*ExportedStreams) ExportReader ¶ 

func (s *ExportedStreams) ExportReader(r io.ReadCloser) keybase1.Stream

func (*ExportedStreams) ExportWriter ¶ 

func (s *ExportedStreams) ExportWriter(w io.WriteCloser) keybase1.Stream

func (*ExportedStreams) GetReader ¶ 

func (s *ExportedStreams) GetReader(st keybase1.Stream) (ret io.ReadCloser, err error)

func (*ExportedStreams) GetWriter ¶ 

func (s *ExportedStreams) GetWriter(st keybase1.Stream) (ret io.WriteCloser, err error)

func (*ExportedStreams) Read ¶ 

func (s *ExportedStreams) Read(_ context.Context, a keybase1.ReadArg) (buf []byte, err error)

func (*ExportedStreams) Write ¶ 

func (s *ExportedStreams) Write(_ context.Context, a keybase1.WriteArg) (n int, err error)

type ExternalAPI ¶ 

type ExternalAPI interface {
	Get(APIArg) (*ExternalAPIRes, error)
	Post(APIArg) (*ExternalAPIRes, error)
	GetHTML(APIArg) (*ExternalHTMLRes, error)
	GetText(APIArg) (*ExternalTextRes, error)
	PostHTML(APIArg) (*ExternalHTMLRes, error)
}

type ExternalAPIEngine ¶ 

type ExternalAPIEngine struct {
	BaseAPIEngine
}

func (*ExternalAPIEngine) DoRequest ¶ 

func (api *ExternalAPIEngine) DoRequest(
	arg APIArg, req *http.Request, restype int) (
	ar *ExternalAPIRes, hr *ExternalHTMLRes, tr *ExternalTextRes, err error)

func (*ExternalAPIEngine) Get ¶ 

func (api *ExternalAPIEngine) Get(arg APIArg) (res *ExternalAPIRes, err error)

func (*ExternalAPIEngine) GetHTML ¶ 

func (api *ExternalAPIEngine) GetHTML(arg APIArg) (res *ExternalHTMLRes, err error)

func (*ExternalAPIEngine) GetText ¶ 

func (api *ExternalAPIEngine) GetText(arg APIArg) (res *ExternalTextRes, err error)

func (*ExternalAPIEngine) Post ¶ 

func (api *ExternalAPIEngine) Post(arg APIArg) (res *ExternalAPIRes, err error)

func (*ExternalAPIEngine) PostHTML ¶ 

func (api *ExternalAPIEngine) PostHTML(arg APIArg) (res *ExternalHTMLRes, err error)

type ExternalAPIRes ¶ 

type ExternalAPIRes struct {
	HTTPStatus int
	Body       *jsonw.Wrapper
}

type ExternalHTMLRes ¶ 

type ExternalHTMLRes struct {
	HTTPStatus int
	GoQuery    *goquery.Document
}

type ExternalTextRes ¶ 

type ExternalTextRes struct {
	HTTPStatus int
	Body       string
}

type FailedAssertionError ¶ 

type FailedAssertionError struct {
	// contains filtered or unexported fields
}

func (FailedAssertionError) Error ¶ 

func (u FailedAssertionError) Error() string

type File ¶ 

type File struct {
	// contains filtered or unexported fields
}

File defines a default SafeWriter implementation

func NewFile ¶ 

func NewFile(filename string, data []byte, perm os.FileMode) File

NewFile returns a File

func (File) GetFilename ¶ 

func (f File) GetFilename() string

GetFilename is for SafeWriter

func (File) Save ¶ 

func (f File) Save() error

Save file

func (File) WriteTo ¶ 

func (f File) WriteTo(w io.Writer) (int64, error)

WriteTo is for SafeWriter

type FirstErrorPicker ¶ 

type FirstErrorPicker struct {
	// contains filtered or unexported fields
}

func (*FirstErrorPicker) Error ¶ 

func (p *FirstErrorPicker) Error() error

func (*FirstErrorPicker) Push ¶ 

func (p *FirstErrorPicker) Push(e error)

type FishyMsgpackError ¶ 

type FishyMsgpackError struct {
	// contains filtered or unexported fields
}

func (FishyMsgpackError) Error ¶ 

func (e FishyMsgpackError) Error() string

type GPGKey ¶ 

type GPGKey struct {
	Contextified
	// contains filtered or unexported fields
}

GPGKey is a shell around gpg cli commands that implements the GenericKey interface.

func NewGPGKey ¶ 

func NewGPGKey(g *GlobalContext, fp *PGPFingerprint, kid keybase1.KID) *GPGKey

func (*GPGKey) CanDecrypt ¶ 

func (g *GPGKey) CanDecrypt() bool

func (*GPGKey) CanEncrypt ¶ 

func (g *GPGKey) CanEncrypt() bool

func (*GPGKey) CanSign ¶ 

func (g *GPGKey) CanSign() bool

func (*GPGKey) CheckSecretKey ¶ 

func (g *GPGKey) CheckSecretKey() error

func (*GPGKey) DecryptFromString ¶ 

func (g *GPGKey) DecryptFromString(ciphertext string) (msg []byte, sender keybase1.KID, err error)

func (*GPGKey) Encode ¶ 

func (g *GPGKey) Encode() (string, error)

func (*GPGKey) EncryptToString ¶ 

func (g *GPGKey) EncryptToString(plaintext []byte, sender GenericKey) (ciphertext string, err error)

func (*GPGKey) GetAlgoType ¶ 

func (g *GPGKey) GetAlgoType() AlgoType

func (*GPGKey) GetFingerprintP ¶ 

func (g *GPGKey) GetFingerprintP() *PGPFingerprint

func (*GPGKey) GetKID ¶ 

func (g *GPGKey) GetKID() keybase1.KID

func (*GPGKey) HasSecretKey ¶ 

func (g *GPGKey) HasSecretKey() bool

func (*GPGKey) SignToString ¶ 

func (g *GPGKey) SignToString(msg []byte) (sig string, id keybase1.SigID, err error)

func (*GPGKey) ToLksSKB ¶ 

func (g *GPGKey) ToLksSKB(lks *LKSec) (*SKB, error)

func (*GPGKey) ToServerSKB ¶ 

func (g *GPGKey) ToServerSKB(gc *GlobalContext, ts *triplesec.Cipher, gen PassphraseGeneration) (*SKB, error)

func (*GPGKey) VerboseDescription ¶ 

func (g *GPGKey) VerboseDescription() string

func (*GPGKey) VerifyString ¶ 

func (g *GPGKey) VerifyString(sig string, msg []byte) (id keybase1.SigID, err error)

func (*GPGKey) VerifyStringAndExtract ¶ 

func (g *GPGKey) VerifyStringAndExtract(sig string) (msg []byte, id keybase1.SigID, err error)

type GPGUI ¶ 

type GPGUI interface {
	keybase1.GpgUiInterface
}
type GenericChainLink struct {
	*ChainLink
}

func (*GenericChainLink) BaseToTrackingStatement ¶ 

func (g *GenericChainLink) BaseToTrackingStatement(state keybase1.ProofState) *jsonw.Wrapper

func (*GenericChainLink) GetArmoredSig ¶ 

func (g *GenericChainLink) GetArmoredSig() string

func (*GenericChainLink) GetDelegatedKid ¶ 

func (g *GenericChainLink) GetDelegatedKid() (kid keybase1.KID)

func (*GenericChainLink) GetDevice ¶ 

func (g *GenericChainLink) GetDevice() *Device

func (*GenericChainLink) GetPGPFingerprint ¶ 

func (g *GenericChainLink) GetPGPFingerprint() *PGPFingerprint

func (*GenericChainLink) GetPGPFullHash ¶ 

func (g *GenericChainLink) GetPGPFullHash() string

func (*GenericChainLink) GetParentKid ¶ 

func (g *GenericChainLink) GetParentKid() (kid keybase1.KID)

func (*GenericChainLink) GetRole ¶ 

func (g *GenericChainLink) GetRole() KeyRole

func (*GenericChainLink) GetSeqno ¶ 

func (g *GenericChainLink) GetSeqno() Seqno

func (*GenericChainLink) GetSigID ¶ 

func (g *GenericChainLink) GetSigID() keybase1.SigID

func (*GenericChainLink) GetUID ¶ 

func (g *GenericChainLink) GetUID() keybase1.UID

func (*GenericChainLink) GetUsername ¶ 

func (g *GenericChainLink) GetUsername() string

func (*GenericChainLink) IsRevocationIsh ¶ 

func (g *GenericChainLink) IsRevocationIsh() bool

func (*GenericChainLink) IsRevoked ¶ 

func (g *GenericChainLink) IsRevoked() bool

func (*GenericChainLink) ToDebugString ¶ 

func (g *GenericChainLink) ToDebugString() string

func (*GenericChainLink) ToDisplayString ¶ 

func (g *GenericChainLink) ToDisplayString() string

func (*GenericChainLink) Type ¶ 

func (g *GenericChainLink) Type() string

func (*GenericChainLink) VerifyReverseSig ¶ 

func (g *GenericChainLink) VerifyReverseSig(ckf ComputedKeyFamily) error

type GenericKey ¶ 

type GenericKey interface {
	GetKID() keybase1.KID
	GetFingerprintP() *PGPFingerprint
	GetAlgoType() AlgoType

	// Sign to an ASCII signature (which includes the message
	// itself) and return it, along with a derived ID.
	SignToString(msg []byte) (sig string, id keybase1.SigID, err error)

	// Verify that the given signature is valid and extracts the
	// embedded message from it. Also returns the signature ID.
	VerifyStringAndExtract(sig string) (msg []byte, id keybase1.SigID, err error)

	// Verify that the given signature is valid and that its
	// embedded message matches the given one. Also returns the
	// signature ID.
	VerifyString(sig string, msg []byte) (id keybase1.SigID, err error)

	// Encrypt to an ASCII armored encryption; optionally include a sender's
	// (private) key so that we can provably see who sent the message.
	EncryptToString(plaintext []byte, sender GenericKey) (ciphertext string, err error)

	// Decrypt the output of Encrypt above; provide the plaintext and also
	// the KID of the key that sent the message (if applicable).
	DecryptFromString(ciphertext string) (msg []byte, sender keybase1.KID, err error)

	ToServerSKB(gc *GlobalContext, ts *triplesec.Cipher, gen PassphraseGeneration) (*SKB, error)
	ToLksSKB(lks *LKSec) (*SKB, error)
	VerboseDescription() string
	CheckSecretKey() error
	CanSign() bool
	CanEncrypt() bool
	CanDecrypt() bool
	HasSecretKey() bool
	Encode() (string, error) // encode public key to string
}

func ImportKeypairFromKID ¶ 

func ImportKeypairFromKID(k keybase1.KID) (key GenericKey, err error)

func NaclVerifyAndExtract ¶ 

func NaclVerifyAndExtract(s string) (key GenericKey, payload []byte, fullBody []byte, err error)

NaclVerifyAndExtract interprets the given string as a NaCl-signed messaged, in the keybase NaclSigInfo (v1) format. It will check that the signature verified, and if so, will return the key that was used for the verification, the payload of the signature, the full body of the decoded SignInfo, and an error

func ParseGenericKey ¶ 

func ParseGenericKey(bundle string) (GenericKey, error)

type GithubChecker ¶ 

type GithubChecker struct {
	// contains filtered or unexported fields
}

func (*GithubChecker) CheckHint ¶ 

func (rc *GithubChecker) CheckHint(h SigHint) ProofError

func (*GithubChecker) CheckStatus ¶ 

func (rc *GithubChecker) CheckStatus(h SigHint) ProofError

func (*GithubChecker) GetTorError ¶ 

func (rc *GithubChecker) GetTorError() ProofError

type GithubServiceType ¶ 

type GithubServiceType struct{ BaseServiceType }

func (GithubServiceType) AllStringKeys ¶ 

func (t GithubServiceType) AllStringKeys() []string

func (GithubServiceType) CheckProofText ¶ 

func (t GithubServiceType) CheckProofText(text string, id keybase1.SigID, sig string) (err error)

func (GithubServiceType) CheckUsername ¶ 

func (t GithubServiceType) CheckUsername(s string) (err error)

func (GithubServiceType) DisplayName ¶ 

func (t GithubServiceType) DisplayName(un string) string

func (GithubServiceType) GetPrompt ¶ 

func (t GithubServiceType) GetPrompt() string

func (GithubServiceType) GetProofType ¶ 

func (t GithubServiceType) GetProofType() string

func (GithubServiceType) GetTypeName ¶ 

func (t GithubServiceType) GetTypeName() string

func (GithubServiceType) PostInstructions ¶ 

func (t GithubServiceType) PostInstructions(un string) *Markup

func (GithubServiceType) PrimaryStringKeys ¶ 

func (t GithubServiceType) PrimaryStringKeys() []string

func (GithubServiceType) RecheckProofPosting ¶ 

func (t GithubServiceType) RecheckProofPosting(tryNumber int, status keybase1.ProofStatus, _ string) (warning *Markup, err error)

func (GithubServiceType) ToChecker ¶ 

func (t GithubServiceType) ToChecker() Checker

func (GithubServiceType) ToServiceJSON ¶ 

func (t GithubServiceType) ToServiceJSON(un string) *jsonw.Wrapper

type GlobalContext ¶ 

type GlobalContext struct {
	Log           logger.Logger   // Handles all logging
	Env           *Env            // Env variables, cmdline args & config
	Keyrings      *Keyrings       // Gpg Keychains holding keys
	API           API             // How to make a REST call to the server
	ResolveCache  *ResolveCache   // cache of resolve results
	LocalDb       *JSONLocalDb    // Local DB for cache
	MerkleClient  *MerkleClient   // client for querying server's merkle sig tree
	XAPI          ExternalAPI     // for contacting Twitter, Github, etc.
	Output        io.Writer       // where 'Stdout'-style output goes
	ProofCache    *ProofCache     // where to cache proof results
	FavoriteCache *favcache.Cache // where to cache favorite folders
	GpgClient     *GpgCLI         // A standard GPG-client (optional)
	ShutdownHooks []ShutdownHook  // on shutdown, fire these...
	SocketInfo    Socket          // which socket to bind/connect to

	SocketWrapper    *SocketWrapper    // only need one connection per
	LoopbackListener *LoopbackListener // If we're in loopback mode, we'll connect through here
	XStreams         *ExportedStreams  // a table of streams we've exported to the daemon (or vice-versa)
	Timers           *TimerSet         // Which timers are currently configured on
	IdentifyCache    *IdentifyCache    // cache of IdentifyOutcomes
	UserCache        *UserCache        // cache of Users
	UI               UI                // Interact with the UI
	Service          bool              // whether we're in server mode

	ConnectionManager *ConnectionManager // keep tabs on all active client connections
	NotifyRouter      *NotifyRouter      // How to route notifications
	UIRouter          UIRouter           // How to route UIs
	ExitCode          keybase1.ExitCode  // Value to return to OS on Exit()
	// contains filtered or unexported fields
}
var G *GlobalContext

func NewGlobalContext ¶ 

func NewGlobalContext() *GlobalContext

func (*GlobalContext) BindToSocket ¶ 

func (g *GlobalContext) BindToSocket() (net.Listener, error)

func (*GlobalContext) ConfigReload ¶ 

func (g *GlobalContext) ConfigReload() error

func (*GlobalContext) Configure ¶ 

func (g *GlobalContext) Configure(line CommandLine, usage Usage) error

func (*GlobalContext) ConfigureAPI ¶ 

func (g *GlobalContext) ConfigureAPI() error

func (*GlobalContext) ConfigureCaches ¶ 

func (g *GlobalContext) ConfigureCaches() error

func (*GlobalContext) ConfigureCommand ¶ 

func (g *GlobalContext) ConfigureCommand(line CommandLine, cmd Command) error

func (*GlobalContext) ConfigureConfig ¶ 

func (g *GlobalContext) ConfigureConfig() error

func (*GlobalContext) ConfigureExportedStreams ¶ 

func (g *GlobalContext) ConfigureExportedStreams() error

func (*GlobalContext) ConfigureKeyring ¶ 

func (g *GlobalContext) ConfigureKeyring() error

func (*GlobalContext) ConfigureLogging ¶ 

func (g *GlobalContext) ConfigureLogging() error

func (*GlobalContext) ConfigureMerkleClient ¶ 

func (g *GlobalContext) ConfigureMerkleClient() error

func (*GlobalContext) ConfigureSocketInfo ¶ 

func (g *GlobalContext) ConfigureSocketInfo() (err error)

func (*GlobalContext) ConfigureTimers ¶ 

func (g *GlobalContext) ConfigureTimers() error

func (*GlobalContext) ConfigureUsage ¶ 

func (g *GlobalContext) ConfigureUsage(usage Usage) error

func (*GlobalContext) GetGpgClient ¶ 

func (g *GlobalContext) GetGpgClient() *GpgCLI

func (*GlobalContext) GetMyUID ¶ 

func (g *GlobalContext) GetMyUID() keybase1.UID

func (*GlobalContext) GetSocket ¶ 

func (g *GlobalContext) GetSocket(clearError bool) (net.Conn, rpc.Transporter, error)

func (*GlobalContext) Init ¶ 

func (g *GlobalContext) Init()

func (*GlobalContext) LoginState ¶ 

func (g *GlobalContext) LoginState() *LoginState

func (*GlobalContext) Logout ¶ 

func (g *GlobalContext) Logout() error

func (*GlobalContext) MakeLoopbackServer ¶ 

func (g *GlobalContext) MakeLoopbackServer() (l net.Listener, err error)

func (*GlobalContext) OutputBytes ¶ 

func (g *GlobalContext) OutputBytes(b []byte)

func (*GlobalContext) OutputString ¶ 

func (g *GlobalContext) OutputString(s string)

func (*GlobalContext) PushShutdownHook ¶ 

func (g *GlobalContext) PushShutdownHook(sh ShutdownHook)

func (*GlobalContext) SKBFilenameForUser ¶ 

func (g *GlobalContext) SKBFilenameForUser(un NormalizedUsername) string

func (*GlobalContext) SetCommandLine ¶ 

func (g *GlobalContext) SetCommandLine(cmd CommandLine)

func (*GlobalContext) SetService ¶ 

func (g *GlobalContext) SetService()

func (*GlobalContext) SetUI ¶ 

func (g *GlobalContext) SetUI(u UI)

func (*GlobalContext) SetUIRouter ¶ 

func (g *GlobalContext) SetUIRouter(u UIRouter)

func (*GlobalContext) Shutdown ¶ 

func (g *GlobalContext) Shutdown() error

Shutdown is called exactly once per-process and does whatever cleanup is necessary to shut down the server.

func (*GlobalContext) StartupMessage ¶ 

func (g *GlobalContext) StartupMessage()

type GpgBaseKey ¶ 

type GpgBaseKey struct {
	Type    string
	Trust   string
	Bits    int
	Algo    int
	ID64    string
	Created int64
	Expires int64
	// contains filtered or unexported fields
}

func (GpgBaseKey) AlgoString ¶ 

func (k GpgBaseKey) AlgoString() string

func (GpgBaseKey) CreatedString ¶ 

func (k GpgBaseKey) CreatedString() string

func (GpgBaseKey) ExpirationString ¶ 

func (k GpgBaseKey) ExpirationString() string

func (*GpgBaseKey) ParseBase ¶ 

func (k *GpgBaseKey) ParseBase(line *GpgIndexLine) (err error)

func (*GpgBaseKey) SetFingerprint ¶ 

func (k *GpgBaseKey) SetFingerprint(pgp *PGPFingerprint)

type GpgCLI ¶ 

type GpgCLI struct {
	// contains filtered or unexported fields
}

func NewGpgCLI ¶ 

func NewGpgCLI(arg GpgCLIArg) *GpgCLI

func (*GpgCLI) CanExec ¶ 

func (g *GpgCLI) CanExec() (bool, error)

CanExec returns true if a gpg executable exists.

func (*GpgCLI) Configure ¶ 

func (g *GpgCLI) Configure() (err error)

func (*GpgCLI) ExportKey ¶ 

func (g *GpgCLI) ExportKey(k PGPKeyBundle) (err error)

func (*GpgCLI) ImportKey ¶ 

func (g *GpgCLI) ImportKey(secret bool, fp PGPFingerprint) (*PGPKeyBundle, error)

func (*GpgCLI) Index ¶ 

func (g *GpgCLI) Index(secret bool, query string) (ki *GpgKeyIndex, w Warnings, err error)

func (*GpgCLI) MakeCmd ¶ 

func (g *GpgCLI) MakeCmd(args []string) *exec.Cmd

func (*GpgCLI) Path ¶ 

func (g *GpgCLI) Path() string

Path returns the path of the gpg executable. Path is only available if CanExec() is true.

func (*GpgCLI) Run ¶ 

func (g *GpgCLI) Run(arg RunGpgArg) (res RunGpgRes)

func (*GpgCLI) Run2 ¶ 

func (g *GpgCLI) Run2(arg RunGpg2Arg) (res RunGpg2Res)

func (*GpgCLI) Sign ¶ 

func (g *GpgCLI) Sign(fp PGPFingerprint, payload []byte) (string, error)

func (*GpgCLI) Version ¶ 

func (g *GpgCLI) Version() (string, error)

type GpgCLIArg ¶ 

type GpgCLIArg struct {
	LogUI LogUI // If nil, use the global
}

type GpgError ¶ 

type GpgError struct {
	// contains filtered or unexported fields
}

func ErrorToGpgError ¶ 

func ErrorToGpgError(e error) GpgError

func (GpgError) Error ¶ 

func (e GpgError) Error() string

type GpgFingerprinter ¶ 

type GpgFingerprinter interface {
	SetFingerprint(pgp *PGPFingerprint)
}

type GpgIndexElement ¶ 

type GpgIndexElement interface {
	ToKey() *GpgPrimaryKey
}

type GpgIndexError ¶ 

type GpgIndexError struct {
	// contains filtered or unexported fields
}

func ErrorToGpgIndexError ¶ 

func ErrorToGpgIndexError(l int, e error) GpgIndexError

func (GpgIndexError) Error ¶ 

func (e GpgIndexError) Error() string

type GpgIndexLine ¶ 

type GpgIndexLine struct {
	// contains filtered or unexported fields
}

func ParseLine ¶ 

func ParseLine(s string, i int) (ret *GpgIndexLine, err error)

func (GpgIndexLine) At ¶ 

func (g GpgIndexLine) At(i int) string

func (GpgIndexLine) IsNewKey ¶ 

func (g GpgIndexLine) IsNewKey() bool

func (GpgIndexLine) Len ¶ 

func (g GpgIndexLine) Len() int

type GpgIndexParser ¶ 

type GpgIndexParser struct {
	// contains filtered or unexported fields
}

func NewGpgIndexParser ¶ 

func NewGpgIndexParser() *GpgIndexParser

func (*GpgIndexParser) GetLine ¶ 

func (p *GpgIndexParser) GetLine() (ret *GpgIndexLine, err error)

func (*GpgIndexParser) Parse ¶ 

func (p *GpgIndexParser) Parse(stream io.Reader) (ki *GpgKeyIndex, err error)

func (*GpgIndexParser) ParseElement ¶ 

func (p *GpgIndexParser) ParseElement() (ret GpgIndexElement, err error)

func (*GpgIndexParser) ParseKey ¶ 

func (p *GpgIndexParser) ParseKey(l *GpgIndexLine) (ret *GpgPrimaryKey, err error)

func (*GpgIndexParser) PutbackLine ¶ 

func (p *GpgIndexParser) PutbackLine(line *GpgIndexLine)

func (*GpgIndexParser) Warn ¶ 

func (p *GpgIndexParser) Warn(w Warning)

type GpgKeyIndex ¶ 

type GpgKeyIndex struct {
	Keys                        []*GpgPrimaryKey
	Emails, Fingerprints, ID64s *BucketDict
}

func NewGpgKeyIndex ¶ 

func NewGpgKeyIndex() *GpgKeyIndex

func (*GpgKeyIndex) AllFingerprints ¶ 

func (ki *GpgKeyIndex) AllFingerprints() []PGPFingerprint

func (*GpgKeyIndex) GetRowFunc ¶ 

func (ki *GpgKeyIndex) GetRowFunc() func() []string

func (*GpgKeyIndex) IndexKey ¶ 

func (ki *GpgKeyIndex) IndexKey(k *GpgPrimaryKey)

func (*GpgKeyIndex) Len ¶ 

func (ki *GpgKeyIndex) Len() int

func (*GpgKeyIndex) Less ¶ 

func (ki *GpgKeyIndex) Less(i, j int) bool

func (*GpgKeyIndex) PushElement ¶ 

func (ki *GpgKeyIndex) PushElement(e GpgIndexElement)

func (*GpgKeyIndex) Sort ¶ 

func (ki *GpgKeyIndex) Sort()

func (*GpgKeyIndex) Swap ¶ 

func (ki *GpgKeyIndex) Swap(i, j int)

type GpgPrimaryKey ¶ 

type GpgPrimaryKey struct {
	GpgBaseKey
	// contains filtered or unexported fields
}

func NewGpgPrimaryKey ¶ 

func NewGpgPrimaryKey() *GpgPrimaryKey

func ParseGpgPrimaryKey ¶ 

func ParseGpgPrimaryKey(l *GpgIndexLine) (key *GpgPrimaryKey, err error)

func (*GpgPrimaryKey) AddFingerprint ¶ 

func (k *GpgPrimaryKey) AddFingerprint(l *GpgIndexLine) (err error)

func (*GpgPrimaryKey) AddLine ¶ 

func (k *GpgPrimaryKey) AddLine(l *GpgIndexLine) (err error)

func (*GpgPrimaryKey) AddSubkey ¶ 

func (k *GpgPrimaryKey) AddSubkey(l *GpgIndexLine) (err error)

func (*GpgPrimaryKey) AddUID ¶ 

func (k *GpgPrimaryKey) AddUID(l *GpgIndexLine) (err error)

func (*GpgPrimaryKey) GetAllID64s ¶ 

func (k *GpgPrimaryKey) GetAllID64s() []string

func (*GpgPrimaryKey) GetEmails ¶ 

func (k *GpgPrimaryKey) GetEmails() []string

func (*GpgPrimaryKey) GetFingerprint ¶ 

func (k *GpgPrimaryKey) GetFingerprint() *PGPFingerprint

func (*GpgPrimaryKey) GetPGPIdentities ¶ 

func (k *GpgPrimaryKey) GetPGPIdentities() []keybase1.PGPIdentity

func (*GpgPrimaryKey) IsValid ¶ 

func (k *GpgPrimaryKey) IsValid() bool

func (*GpgPrimaryKey) Parse ¶ 

func (k *GpgPrimaryKey) Parse(l *GpgIndexLine) error

func (*GpgPrimaryKey) ToKey ¶ 

func (k *GpgPrimaryKey) ToKey() *GpgPrimaryKey

func (*GpgPrimaryKey) ToRow ¶ 

func (k *GpgPrimaryKey) ToRow(i int) []string

type GpgSubKey ¶ 

type GpgSubKey struct {
	GpgBaseKey
}

func ParseGpgSubKey ¶ 

func ParseGpgSubKey(l *GpgIndexLine) (sk *GpgSubKey, err error)

type HTTPArgs ¶ 

type HTTPArgs map[string]HTTPValue

func HTTPArgsFromKeyValuePair ¶ 

func HTTPArgsFromKeyValuePair(key string, val HTTPValue) HTTPArgs

func NewHTTPArgs ¶ 

func NewHTTPArgs() HTTPArgs

func (*HTTPArgs) Add ¶ 

func (a *HTTPArgs) Add(s string, v HTTPValue)

func (HTTPArgs) EncodeToString ¶ 

func (a HTTPArgs) EncodeToString() string

func (HTTPArgs) ToValues ¶ 

func (a HTTPArgs) ToValues() url.Values

type HTTPRequest ¶ 

type HTTPRequest interface {
	SetEnvironment(env Env)
}

type HTTPValue ¶ 

type HTTPValue interface {
	String() string
}

func UIDArg ¶ 

func UIDArg(uid keybase1.UID) HTTPValue

type HackerNewsChecker ¶ 

type HackerNewsChecker struct {
	// contains filtered or unexported fields
}

func (*HackerNewsChecker) APIBase ¶ 

func (h *HackerNewsChecker) APIBase() string

func (*HackerNewsChecker) APIURL ¶ 

func (h *HackerNewsChecker) APIURL() string

func (*HackerNewsChecker) CheckHint ¶ 

func (h *HackerNewsChecker) CheckHint(hint SigHint) ProofError

func (*HackerNewsChecker) CheckStatus ¶ 

func (h *HackerNewsChecker) CheckStatus(hint SigHint) ProofError

func (*HackerNewsChecker) GetTorError ¶ 

func (h *HackerNewsChecker) GetTorError() ProofError

func (*HackerNewsChecker) HumanURL ¶ 

func (h *HackerNewsChecker) HumanURL() string

func (*HackerNewsChecker) KarmaURL ¶ 

func (h *HackerNewsChecker) KarmaURL() string

type HackerNewsServiceType ¶ 

type HackerNewsServiceType struct{ BaseServiceType }

func (HackerNewsServiceType) AllStringKeys ¶ 

func (t HackerNewsServiceType) AllStringKeys() []string

func (HackerNewsServiceType) CheckProofText ¶ 

func (t HackerNewsServiceType) CheckProofText(text string, id keybase1.SigID, sig string) (err error)

func (HackerNewsServiceType) CheckUsername ¶ 

func (t HackerNewsServiceType) CheckUsername(s string) (err error)

func (HackerNewsServiceType) DisplayName ¶ 

func (t HackerNewsServiceType) DisplayName(un string) string

func (HackerNewsServiceType) GetPrompt ¶ 

func (t HackerNewsServiceType) GetPrompt() string

func (HackerNewsServiceType) GetProofType ¶ 

func (t HackerNewsServiceType) GetProofType() string

func (HackerNewsServiceType) GetTypeName ¶ 

func (t HackerNewsServiceType) GetTypeName() string

func (HackerNewsServiceType) NormalizeUsername ¶ 

func (t HackerNewsServiceType) NormalizeUsername(s string) (string, error)

HackerNews names are case-sensitive

func (HackerNewsServiceType) PostInstructions ¶ 

func (t HackerNewsServiceType) PostInstructions(un string) *Markup

func (HackerNewsServiceType) PreProofCheck ¶ 

func (t HackerNewsServiceType) PreProofCheck(un string) (markup *Markup, err error)

func (HackerNewsServiceType) PrimaryStringKeys ¶ 

func (t HackerNewsServiceType) PrimaryStringKeys() []string

func (HackerNewsServiceType) RecheckProofPosting ¶ 

func (t HackerNewsServiceType) RecheckProofPosting(tryNumber int, status keybase1.ProofStatus, _ string) (warning *Markup, err error)

func (HackerNewsServiceType) ToChecker ¶ 

func (t HackerNewsServiceType) ToChecker() Checker

func (HackerNewsServiceType) ToServiceJSON ¶ 

func (t HackerNewsServiceType) ToServiceJSON(un string) *jsonw.Wrapper

type HashSummer ¶ 

type HashSummer func() []byte

func ArmoredAttachedSign ¶ 

func ArmoredAttachedSign(out io.WriteCloser, signed openpgp.Entity, hints *openpgp.FileHints, config *packet.Config) (in io.WriteCloser, h HashSummer, err error)

type HashingWriteCloser ¶ 

type HashingWriteCloser struct {
	// contains filtered or unexported fields
}

func (HashingWriteCloser) Close ¶ 

func (h HashingWriteCloser) Close() error

func (HashingWriteCloser) Write ¶ 

func (h HashingWriteCloser) Write(buf []byte) (int, error)

type HomeFinder ¶ 

type HomeFinder interface {
	CacheDir() string
	ConfigDir() string
	Home(emptyOk bool) string
	DataDir() string
	RuntimeDir() string
	Normalize(s string) string
	LogDir() string
	ServiceSpawnDir() (string, error)
}

func NewHomeFinder ¶ 

func NewHomeFinder(appName string, getHome ConfigGetter, osname string, getRunMode RunModeGetter) HomeFinder

type I ¶ 

type I struct {
	Val int
}

func (I) String ¶ 

func (i I) String() string

type IdentifyCache ¶ 

type IdentifyCache struct {
	// contains filtered or unexported fields
}

func NewIdentifyCache ¶ 

func NewIdentifyCache() *IdentifyCache

func (*IdentifyCache) Delete ¶ 

func (c *IdentifyCache) Delete(key IdentifyCacheToken) error

func (*IdentifyCache) Get ¶ 

func (c *IdentifyCache) Get(key IdentifyCacheToken) (*IdentifyOutcome, error)

func (*IdentifyCache) Insert ¶ 

func (c *IdentifyCache) Insert(outcome *IdentifyOutcome) (IdentifyCacheToken, error)

func (*IdentifyCache) Shutdown ¶ 

func (c *IdentifyCache) Shutdown()

type IdentifyCacheToken ¶ 

type IdentifyCacheToken string

func ImportIdentifyCacheToken ¶ 

func ImportIdentifyCacheToken(t string) IdentifyCacheToken

func (IdentifyCacheToken) Export ¶ 

func (t IdentifyCacheToken) Export() string

type IdentifyOutcome ¶ 

type IdentifyOutcome struct {
	Username     string
	Error        error
	KeyDiffs     []TrackDiff
	Revoked      []TrackDiffRevoked
	ProofChecks  []*LinkCheckResult
	Warnings     []Warning
	TrackUsed    *TrackLookup
	TrackEqual   bool // Whether the track statement was equal to what we saw
	MeSet        bool // whether me was set at the time
	TrackOptions keybase1.TrackOptions
	Reason       keybase1.IdentifyReason
}

func NewIdentifyOutcome ¶ 

func NewIdentifyOutcome(m bool) *IdentifyOutcome

func (*IdentifyOutcome) ActiveProofs ¶ 

func (i *IdentifyOutcome) ActiveProofs() []RemoteProofChainLink

func (*IdentifyOutcome) AddProofsToSet ¶ 

func (i *IdentifyOutcome) AddProofsToSet(existing *ProofSet)

func (*IdentifyOutcome) Export ¶ 

func (ir *IdentifyOutcome) Export() *keybase1.IdentifyOutcome

func (IdentifyOutcome) ExportToUncheckedIdentity ¶ 

func (ir IdentifyOutcome) ExportToUncheckedIdentity() *keybase1.Identity

func (IdentifyOutcome) GetError ¶ 

func (i IdentifyOutcome) GetError() error

func (IdentifyOutcome) GetErrorAndWarnings ¶ 

func (i IdentifyOutcome) GetErrorAndWarnings(strict bool) (warnings Warnings, err error)

func (IdentifyOutcome) GetErrorLax ¶ 

func (i IdentifyOutcome) GetErrorLax() (Warnings, error)

func (IdentifyOutcome) NumProofFailures ¶ 

func (i IdentifyOutcome) NumProofFailures() int

The number of proofs that failed.

func (IdentifyOutcome) NumProofSuccesses ¶ 

func (i IdentifyOutcome) NumProofSuccesses() int

The number of proofs that actually worked

func (IdentifyOutcome) NumRevoked ¶ 

func (i IdentifyOutcome) NumRevoked() int

Revoked proofs are those we used to look for but are gone!

func (IdentifyOutcome) NumTrackChanges ¶ 

func (i IdentifyOutcome) NumTrackChanges() int

A "Track Change" isn't necessary a failure, maybe they upgraded a proof from HTTP to HTTPS. But we still should retrack if we can.

func (IdentifyOutcome) NumTrackFailures ¶ 

func (i IdentifyOutcome) NumTrackFailures() int

A "Track Failure" is when we previously tracked this user, and some aspect of their proof changed. Like their key changed, or they changed Twitter names

func (*IdentifyOutcome) ProofChecksSorted ¶ 

func (i *IdentifyOutcome) ProofChecksSorted() []*LinkCheckResult

func (*IdentifyOutcome) TrackSet ¶ 

func (i *IdentifyOutcome) TrackSet() *TrackSet

func (IdentifyOutcome) TrackStatus ¶ 

func (i IdentifyOutcome) TrackStatus() keybase1.TrackStatus

func (IdentifyOutcome) TrackingStatement ¶ 

func (i IdentifyOutcome) TrackingStatement() *jsonw.Wrapper

type IdentifyState ¶ 

type IdentifyState struct {
	// contains filtered or unexported fields
}

func NewIdentifyState ¶ 

func NewIdentifyState(res *IdentifyOutcome, u *User) IdentifyState

func (*IdentifyState) ComputeKeyDiffs ¶ 

func (s *IdentifyState) ComputeKeyDiffs(dhook func(keybase1.IdentifyKey))

func (*IdentifyState) ComputeRevokedProofs ¶ 

func (s *IdentifyState) ComputeRevokedProofs()

func (*IdentifyState) ComputeTrackDiffs ¶ 

func (s *IdentifyState) ComputeTrackDiffs()

func (*IdentifyState) CreateTrackLookup ¶ 

func (s *IdentifyState) CreateTrackLookup(t *TrackChainLink)

func (*IdentifyState) HasPreviousTrack ¶ 

func (s *IdentifyState) HasPreviousTrack() bool

func (*IdentifyState) InitResultList ¶ 

func (s *IdentifyState) InitResultList()

func (*IdentifyState) TrackLookup ¶ 

func (s *IdentifyState) TrackLookup() *TrackLookup

type IdentifyTimeoutError ¶ 

type IdentifyTimeoutError struct{}

func (IdentifyTimeoutError) Error ¶ 

func (e IdentifyTimeoutError) Error() string

func (IdentifyTimeoutError) ToStatus ¶ 

func (e IdentifyTimeoutError) ToStatus() keybase1.Status

type IdentifyUI ¶ 

type IdentifyUI interface {
	Start(string)
	FinishWebProofCheck(keybase1.RemoteProof, keybase1.LinkCheckResult)
	FinishSocialProofCheck(keybase1.RemoteProof, keybase1.LinkCheckResult)
	Confirm(*keybase1.IdentifyOutcome) (keybase1.ConfirmResult, error)
	DisplayCryptocurrency(keybase1.Cryptocurrency)
	DisplayKey(keybase1.IdentifyKey)
	ReportLastTrack(*keybase1.TrackSummary)
	LaunchNetworkChecks(*keybase1.Identity, *keybase1.User)
	DisplayTrackStatement(string) error
	ReportTrackToken(IdentifyCacheToken) error
	SetStrict(b bool)
	Finish()
}

type Identities ¶ 

type Identities []Identity

func ImportPGPIdentities ¶ 

func ImportPGPIdentities(ids []keybase1.PGPIdentity) (ret Identities)

func (Identities) Export ¶ 

func (ids Identities) Export() (res []keybase1.PGPIdentity)

type Identity ¶ 

type Identity struct {
	Username string
	Comment  string
	Email    string
}

func ImportPGPIdentity ¶ 

func ImportPGPIdentity(arg keybase1.PGPIdentity) (ret Identity)

func KeybaseIdentity ¶ 

func KeybaseIdentity(un NormalizedUsername) Identity

func ParseIdentity ¶ 

func ParseIdentity(s string) (*Identity, error)

func (Identity) Export ¶ 

func (id Identity) Export() (ret keybase1.PGPIdentity)

func (Identity) Format ¶ 

func (i Identity) Format() string

func (Identity) String ¶ 

func (i Identity) String() string

func (Identity) ToPGPUserID ¶ 

func (i Identity) ToPGPUserID() *packet.UserId

type IdentityTable ¶ 

type IdentityTable struct {
	Order []TypedChainLink

	Contextified
	// contains filtered or unexported fields
}

func NewIdentityTable ¶ 

func NewIdentityTable(g *GlobalContext, eldest keybase1.KID, sc *SigChain, h *SigHints) (*IdentityTable, error)

func (*IdentityTable) ActiveCryptocurrency ¶ 

func (idt *IdentityTable) ActiveCryptocurrency() *CryptocurrencyChainLink

func (*IdentityTable) GetActiveProofsFor ¶ 

func (idt *IdentityTable) GetActiveProofsFor(st ServiceType) (ret []RemoteProofChainLink)

func (*IdentityTable) GetRevokedCryptocurrencyForTesting ¶ 

func (idt *IdentityTable) GetRevokedCryptocurrencyForTesting() []CryptocurrencyChainLink

func (*IdentityTable) GetTrackList ¶ 

func (idt *IdentityTable) GetTrackList() (ret []*TrackChainLink)

func (*IdentityTable) GetTrackMap ¶ 

func (idt *IdentityTable) GetTrackMap() map[string][]*TrackChainLink

func (*IdentityTable) Identify ¶ 

func (idt *IdentityTable) Identify(is IdentifyState, forceRemoteCheck bool, ui IdentifyUI)

func (*IdentityTable) Len ¶ 

func (idt *IdentityTable) Len() int

func (*IdentityTable) MarkCheckResult ¶ 

func (idt *IdentityTable) MarkCheckResult(err ProofError)

func (*IdentityTable) TrackChainLinkFor ¶ 

func (idt *IdentityTable) TrackChainLinkFor(username string, uid keybase1.UID) (*TrackChainLink, error)

func (*IdentityTable) VerifySelfSig ¶ 

func (idt *IdentityTable) VerifySelfSig(s string, uid keybase1.UID) bool

type InactiveKeyError ¶ 

type InactiveKeyError struct {
	// contains filtered or unexported fields
}

func (InactiveKeyError) Error ¶ 

func (i InactiveKeyError) Error() string

type InsufficientKarmaError ¶ 

type InsufficientKarmaError struct {
	// contains filtered or unexported fields
}

func (InsufficientKarmaError) Error ¶ 

func (e InsufficientKarmaError) Error() string

type InternalAPIEngine ¶ 

type InternalAPIEngine struct {
	BaseAPIEngine
}

func NewInternalAPIEngine ¶ 

func NewInternalAPIEngine(g *GlobalContext) (*InternalAPIEngine, error)

NewInternalAPIEngine makes an API engine for internally querying the keybase API server

func (*InternalAPIEngine) DoRequest ¶ 

func (a *InternalAPIEngine) DoRequest(arg APIArg, req *http.Request) (*APIRes, error)

func (*InternalAPIEngine) Get ¶ 

func (a *InternalAPIEngine) Get(arg APIArg) (*APIRes, error)

func (*InternalAPIEngine) GetDecode ¶ 

func (a *InternalAPIEngine) GetDecode(arg APIArg, v interface{}) error

GetDecode performs a GET request and decodes the response via JSON into the value pointed to by v.

func (*InternalAPIEngine) GetResp ¶ 

func (a *InternalAPIEngine) GetResp(arg APIArg) (*http.Response, error)

GetResp performs a GET request and returns the http response.

func (*InternalAPIEngine) Post ¶ 

func (a *InternalAPIEngine) Post(arg APIArg) (*APIRes, error)

func (*InternalAPIEngine) PostDecode ¶ 

func (a *InternalAPIEngine) PostDecode(arg APIArg, v interface{}) error

func (*InternalAPIEngine) PostJSON ¶ 

func (a *InternalAPIEngine) PostJSON(arg APIArg) (*APIRes, error)

func (*InternalAPIEngine) PostResp ¶ 

func (a *InternalAPIEngine) PostResp(arg APIArg) (*http.Response, error)

PostResp performs a POST request and returns the http response.

type InternalError ¶ 

type InternalError struct {
	Msg string
}

func (InternalError) Error ¶ 

func (e InternalError) Error() string

type InvalidArgumentError ¶ 

type InvalidArgumentError struct {
	Msg string
}

func (InvalidArgumentError) Error ¶ 

func (e InvalidArgumentError) Error() string

type InvalidHostnameError ¶ 

type InvalidHostnameError struct {
	// contains filtered or unexported fields
}

func (InvalidHostnameError) Error ¶ 

func (e InvalidHostnameError) Error() string

type InvalidKexPhraseError ¶ 

type InvalidKexPhraseError struct{}

func (InvalidKexPhraseError) Error ¶ 

func (e InvalidKexPhraseError) Error() string

func (InvalidKexPhraseError) ToStatus ¶ 

func (e InvalidKexPhraseError) ToStatus() keybase1.Status

type InviteRequestArg ¶ 

type InviteRequestArg struct {
	Email    string
	Fullname string
	Notes    string
}

type JSONConfigFile ¶ 

type JSONConfigFile struct {
	*JSONFile
	// contains filtered or unexported fields
}

func NewJSONConfigFile ¶ 

func NewJSONConfigFile(g *GlobalContext, s string) *JSONConfigFile

func (JSONConfigFile) Check ¶ 

func (f JSONConfigFile) Check() error

Check looks inside the JSON file to see if any fields are poorly specified

func (*JSONConfigFile) DeleteAtPath ¶ 

func (f *JSONConfigFile) DeleteAtPath(p string)

func (JSONConfigFile) GetAPITimeout ¶ 

func (f JSONConfigFile) GetAPITimeout() (time.Duration, bool)

func (JSONConfigFile) GetAllUsernames ¶ 

func (f JSONConfigFile) GetAllUsernames() (current NormalizedUsername, others []NormalizedUsername, err error)

func (JSONConfigFile) GetAutoFork ¶ 

func (f JSONConfigFile) GetAutoFork() (bool, bool)

func (JSONConfigFile) GetBoolAtPath ¶ 

func (f JSONConfigFile) GetBoolAtPath(p string) (ret bool, isSet bool)

func (JSONConfigFile) GetBundledCA ¶ 

func (f JSONConfigFile) GetBundledCA(host string) (ret string)

func (JSONConfigFile) GetConfigFilename ¶ 

func (f JSONConfigFile) GetConfigFilename() string

func (JSONConfigFile) GetDbFilename ¶ 

func (f JSONConfigFile) GetDbFilename() string

func (JSONConfigFile) GetDebug ¶ 

func (f JSONConfigFile) GetDebug() (bool, bool)

func (JSONConfigFile) GetDeviceID ¶ 

func (f JSONConfigFile) GetDeviceID() (ret keybase1.DeviceID)

func (JSONConfigFile) GetDurationAtPath ¶ 

func (f JSONConfigFile) GetDurationAtPath(p string) (time.Duration, bool)

func (JSONConfigFile) GetFilename ¶ 

func (f JSONConfigFile) GetFilename() string

func (JSONConfigFile) GetGpg ¶ 

func (f JSONConfigFile) GetGpg() string

func (JSONConfigFile) GetGpgHome ¶ 

func (f JSONConfigFile) GetGpgHome() (ret string)

func (JSONConfigFile) GetGpgOptions ¶ 

func (f JSONConfigFile) GetGpgOptions() []string

func (JSONConfigFile) GetHome ¶ 

func (f JSONConfigFile) GetHome() string

func (JSONConfigFile) GetIntAtPath ¶ 

func (f JSONConfigFile) GetIntAtPath(p string) (ret int, isSet bool)

func (JSONConfigFile) GetLocalRPCDebug ¶ 

func (f JSONConfigFile) GetLocalRPCDebug() string

func (JSONConfigFile) GetLogFile ¶ 

func (f JSONConfigFile) GetLogFile() string

func (JSONConfigFile) GetLogFormat ¶ 

func (f JSONConfigFile) GetLogFormat() string

func (JSONConfigFile) GetMerkleKIDs ¶ 

func (f JSONConfigFile) GetMerkleKIDs() []string

func (JSONConfigFile) GetNoPinentry ¶ 

func (f JSONConfigFile) GetNoPinentry() (bool, bool)

func (JSONConfigFile) GetNullAtPath ¶ 

func (f JSONConfigFile) GetNullAtPath(p string) (isSet bool)

func (JSONConfigFile) GetPidFile ¶ 

func (f JSONConfigFile) GetPidFile() string

func (JSONConfigFile) GetPinentry ¶ 

func (f JSONConfigFile) GetPinentry() string

func (JSONConfigFile) GetProofCacheLongDur ¶ 

func (f JSONConfigFile) GetProofCacheLongDur() (time.Duration, bool)

func (JSONConfigFile) GetProofCacheMediumDur ¶ 

func (f JSONConfigFile) GetProofCacheMediumDur() (time.Duration, bool)

func (JSONConfigFile) GetProofCacheShortDur ¶ 

func (f JSONConfigFile) GetProofCacheShortDur() (time.Duration, bool)

func (JSONConfigFile) GetProofCacheSize ¶ 

func (f JSONConfigFile) GetProofCacheSize() (int, bool)

func (JSONConfigFile) GetProxy ¶ 

func (f JSONConfigFile) GetProxy() string

func (JSONConfigFile) GetProxyCACerts ¶ 

func (f JSONConfigFile) GetProxyCACerts() (ret []string, err error)

func (JSONConfigFile) GetRunMode ¶ 

func (f JSONConfigFile) GetRunMode() (RunMode, error)

func (JSONConfigFile) GetSalt ¶ 

func (f JSONConfigFile) GetSalt() (ret []byte)

func (JSONConfigFile) GetScraperTimeout ¶ 

func (f JSONConfigFile) GetScraperTimeout() (time.Duration, bool)

func (JSONConfigFile) GetSecretKeyringTemplate ¶ 

func (f JSONConfigFile) GetSecretKeyringTemplate() string

func (JSONConfigFile) GetSecurityAccessGroupOverride ¶ 

func (f JSONConfigFile) GetSecurityAccessGroupOverride() (bool, bool)

func (JSONConfigFile) GetServerURI ¶ 

func (f JSONConfigFile) GetServerURI() string

func (JSONConfigFile) GetSessionFilename ¶ 

func (f JSONConfigFile) GetSessionFilename() string

func (JSONConfigFile) GetSocketFile ¶ 

func (f JSONConfigFile) GetSocketFile() string

func (JSONConfigFile) GetSplitLogOutput ¶ 

func (f JSONConfigFile) GetSplitLogOutput() (bool, bool)

func (JSONConfigFile) GetStandalone ¶ 

func (f JSONConfigFile) GetStandalone() (bool, bool)

func (JSONConfigFile) GetStringAtPath ¶ 

func (f JSONConfigFile) GetStringAtPath(p string) (ret string, isSet bool)

func (JSONConfigFile) GetTimers ¶ 

func (f JSONConfigFile) GetTimers() string

func (JSONConfigFile) GetTopLevelBool ¶ 

func (f JSONConfigFile) GetTopLevelBool(s string) (res, isSet bool)

func (JSONConfigFile) GetTopLevelString ¶ 

func (f JSONConfigFile) GetTopLevelString(s string) (ret string)

func (JSONConfigFile) GetTorHiddenAddress ¶ 

func (f JSONConfigFile) GetTorHiddenAddress() string

func (JSONConfigFile) GetTorMode ¶ 

func (f JSONConfigFile) GetTorMode() (ret TorMode, err error)

func (JSONConfigFile) GetTorProxy ¶ 

func (f JSONConfigFile) GetTorProxy() string

func (JSONConfigFile) GetUID ¶ 

func (f JSONConfigFile) GetUID() (ret keybase1.UID)

func (JSONConfigFile) GetUserCacheMaxAge ¶ 

func (f JSONConfigFile) GetUserCacheMaxAge() (time.Duration, bool)

func (JSONConfigFile) GetUserConfig ¶ 

func (f JSONConfigFile) GetUserConfig() (*UserConfig, error)

func (JSONConfigFile) GetUserConfigForUsername ¶ 

func (f JSONConfigFile) GetUserConfigForUsername(nu NormalizedUsername) (*UserConfig, error)

GetUserConfigForUsername sees if there's a UserConfig object for the given username previously stored.

func (JSONConfigFile) GetUsername ¶ 

func (f JSONConfigFile) GetUsername() (ret NormalizedUsername)

func (*JSONConfigFile) NukeUser ¶ 

func (f *JSONConfigFile) NukeUser(nu NormalizedUsername) error

func (*JSONConfigFile) Reset ¶ 

func (f *JSONConfigFile) Reset()

func (*JSONConfigFile) SetBoolAtPath ¶ 

func (f *JSONConfigFile) SetBoolAtPath(p string, v bool) error

func (*JSONConfigFile) SetDeviceID ¶ 

func (f *JSONConfigFile) SetDeviceID(did keybase1.DeviceID) (err error)

SetDeviceID sets the device field of the UserConfig object

func (*JSONConfigFile) SetIntAtPath ¶ 

func (f *JSONConfigFile) SetIntAtPath(p string, v int) error

func (*JSONConfigFile) SetNullAtPath ¶ 

func (f *JSONConfigFile) SetNullAtPath(p string) (err error)

func (*JSONConfigFile) SetStringAtPath ¶ 

func (f *JSONConfigFile) SetStringAtPath(p string, v string) error

func (*JSONConfigFile) SetUserConfig ¶ 

func (f *JSONConfigFile) SetUserConfig(u *UserConfig, overwrite bool) error

SetUserConfig writes this UserConfig to the config file and updates the currently active UserConfig in memory. If the given UserConfig is nil, then just empty everything out and clear the `current_user` field. Note that we never actually overwrite users.<username>, we just write it if it doesn't already exist, and we update the `current_user` pointer.

func (*JSONConfigFile) SwitchUser ¶ 

func (f *JSONConfigFile) SwitchUser(nu NormalizedUsername) error

func (*JSONConfigFile) Write ¶ 

func (f *JSONConfigFile) Write() error

type JSONFile ¶ 

type JSONFile struct {
	Contextified
	// contains filtered or unexported fields
}

func NewJSONFile ¶ 

func NewJSONFile(g *GlobalContext, filename, which string) *JSONFile

func (*JSONFile) Exists ¶ 

func (f *JSONFile) Exists() bool

func (*JSONFile) GetWrapper ¶ 

func (f *JSONFile) GetWrapper() *jsonw.Wrapper

func (*JSONFile) Load ¶ 

func (f *JSONFile) Load(warnOnNotFound bool) error

func (*JSONFile) MaybeSave ¶ 

func (f *JSONFile) MaybeSave(pretty bool, mode os.FileMode) (err error)

func (*JSONFile) Nuke ¶ 

func (f *JSONFile) Nuke() error

func (*JSONFile) Save ¶ 

func (f *JSONFile) Save(pretty bool, mode os.FileMode) error

func (*JSONFile) SaveTmp ¶ 

func (f *JSONFile) SaveTmp(suffix string) (string, error)

SaveTmp saves the config to a temporary file. It returns the filename and any error.

func (*JSONFile) SwapTmp ¶ 

func (f *JSONFile) SwapTmp(filename string) error

type JSONLocalDb ¶ 

type JSONLocalDb struct {
	// contains filtered or unexported fields
}

func NewJSONLocalDb ¶ 

func NewJSONLocalDb(e LocalDb) *JSONLocalDb

func (*JSONLocalDb) Close ¶ 

func (j *JSONLocalDb) Close() error

func (*JSONLocalDb) Delete ¶ 

func (j *JSONLocalDb) Delete(id DbKey) error

func (*JSONLocalDb) ForceOpen ¶ 

func (j *JSONLocalDb) ForceOpen() error

func (*JSONLocalDb) Get ¶ 

func (j *JSONLocalDb) Get(id DbKey) (*jsonw.Wrapper, error)

func (*JSONLocalDb) GetInto ¶ 

func (j *JSONLocalDb) GetInto(obj interface{}, id DbKey) (found bool, err error)

func (*JSONLocalDb) Lookup ¶ 

func (j *JSONLocalDb) Lookup(id DbKey) (*jsonw.Wrapper, error)

func (*JSONLocalDb) Nuke ¶ 

func (j *JSONLocalDb) Nuke() (string, error)

func (*JSONLocalDb) Open ¶ 

func (j *JSONLocalDb) Open() error

func (*JSONLocalDb) Put ¶ 

func (j *JSONLocalDb) Put(id DbKey, aliases []DbKey, val *jsonw.Wrapper) error

func (*JSONLocalDb) PutObj ¶ 

func (j *JSONLocalDb) PutObj(id DbKey, aliases []DbKey, obj interface{}) (err error)

type JSONPayload ¶ 

type JSONPayload map[string]interface{}

type Kex2Secret ¶ 

type Kex2Secret struct {
	// contains filtered or unexported fields
}

func NewKex2Secret ¶ 

func NewKex2Secret() (*Kex2Secret, error)

func NewKex2SecretFromPhrase ¶ 

func NewKex2SecretFromPhrase(phrase string) (*Kex2Secret, error)

func (*Kex2Secret) Phrase ¶ 

func (s *Kex2Secret) Phrase() string

func (*Kex2Secret) Secret ¶ 

func (s *Kex2Secret) Secret() kex2.Secret

type KexRole ¶ 

type KexRole int
const (
	KexRoleProvisioner KexRole = iota
	KexRoleProvisionee
)

type KexRouter ¶ 

type KexRouter struct {
	Contextified
}

KexRouter implements the kex2.MessageRouter interface.

func NewKexRouter ¶ 

func NewKexRouter(g *GlobalContext) *KexRouter

NewKexRouter creates a contextified KexRouter.

func (*KexRouter) Get ¶ 

func (k *KexRouter) Get(sessID kex2.SessionID, receiver kex2.DeviceID, low kex2.Seqno, poll time.Duration) (msgs [][]byte, err error)

Get implements Get in the kex2.MessageRouter interface.

func (*KexRouter) Post ¶ 

func (k *KexRouter) Post(sessID kex2.SessionID, sender kex2.DeviceID, seqno kex2.Seqno, msg []byte) (err error)

Post implements Post in the kex2.MessageRouter interface.

type KeyCannotDecryptError ¶ 

type KeyCannotDecryptError struct{}

func (KeyCannotDecryptError) Error ¶ 

func (k KeyCannotDecryptError) Error() string

type KeyCannotEncryptError ¶ 

type KeyCannotEncryptError struct{}

func (KeyCannotEncryptError) Error ¶ 

func (k KeyCannotEncryptError) Error() string

type KeyCannotSignError ¶ 

type KeyCannotSignError struct{}

func (KeyCannotSignError) Error ¶ 

func (s KeyCannotSignError) Error() string

type KeyCannotVerifyError ¶ 

type KeyCannotVerifyError struct{}

func (KeyCannotVerifyError) Error ¶ 

func (k KeyCannotVerifyError) Error() string

type KeyExistsError ¶ 

type KeyExistsError struct {
	Key *PGPFingerprint
}

func (KeyExistsError) Error ¶ 

func (k KeyExistsError) Error() string

func (KeyExistsError) ToStatus ¶ 

func (c KeyExistsError) ToStatus() (s keybase1.Status)

type KeyExpiredError ¶ 

type KeyExpiredError struct {
	// contains filtered or unexported fields
}

func (KeyExpiredError) Error ¶ 

func (r KeyExpiredError) Error() string

type KeyFamily ¶ 

type KeyFamily struct {
	AllKIDs map[keybase1.KID]bool

	// PGP keys have a permissively merged version and individual versions by
	// hash. See the comment in PGPKeySet.addKey, above, for details.
	PGPKeySets map[keybase1.KID]*PGPKeySet
	SingleKeys map[keybase1.KID]GenericKey // Currently just NaCl keys

	BundlesForTesting []string

	Contextified
	// contains filtered or unexported fields
}

Once the client downloads a RawKeyFamily, it converts it into a KeyFamily, which has some additional information about Fingerprints and PGP keys

func ParseKeyFamily ¶ 

func ParseKeyFamily(jw *jsonw.Wrapper) (ret *KeyFamily, err error)

ParseKeyFamily takes as input a dictionary from a JSON file and returns a parsed version for manipulation in the program.

func (*KeyFamily) LocalDelegate ¶ 

func (kf *KeyFamily) LocalDelegate(key GenericKey) (err error)

LocalDelegate performs a local key delegation, without the server's permissions. We'll need to do this when a key is locally generated.

type KeyFamilyError ¶ 

type KeyFamilyError struct {
	Msg string
}

func (KeyFamilyError) Error ¶ 

func (e KeyFamilyError) Error() string

type KeyGenError ¶ 

type KeyGenError struct {
	Msg string
}

func (KeyGenError) Error ¶ 

func (e KeyGenError) Error() string

func (KeyGenError) ToStatus ¶ 

func (e KeyGenError) ToStatus() (s keybase1.Status)

type KeyRevokedError ¶ 

type KeyRevokedError struct {
	// contains filtered or unexported fields
}

func (KeyRevokedError) Error ¶ 

func (r KeyRevokedError) Error() string

type KeyRole ¶ 

type KeyRole int
const (
	DLGNone KeyRole = iota
	DLGSibkey
	DLGSubkey
)

type KeySection ¶ 

type KeySection struct {
	Key            GenericKey
	EldestKID      keybase1.KID
	ParentKID      keybase1.KID
	HasRevSig      bool
	RevSig         string
	SigningUser    UserBasic
	IncludePGPHash bool
}

func (KeySection) ToJSON ¶ 

func (arg KeySection) ToJSON() (*jsonw.Wrapper, error)

type KeyStatus ¶ 

type KeyStatus int
const (
	KeyUncancelled KeyStatus = iota
	KeyRevoked
	KeyDeleted
	KeySuperseded
)

type KeyType ¶ 

type KeyType int

type KeyUnimplementedError ¶ 

type KeyUnimplementedError struct{}

func (KeyUnimplementedError) Error ¶ 

func (k KeyUnimplementedError) Error() string

type KeyUnlocker ¶ 

type KeyUnlocker struct {
	Tries          int
	Reason         string
	KeyDesc        string
	Which          string
	UseSecretStore bool
	UI             SecretUI
	Unlocker       func(pw string, storeSecret bool) (ret GenericKey, err error)
}

func (KeyUnlocker) Run ¶ 

func (arg KeyUnlocker) Run() (ret GenericKey, err error)

type KeyVersionError ¶ 

type KeyVersionError struct{}

func (KeyVersionError) Error ¶ 

func (k KeyVersionError) Error() string

type KeybasePacket ¶ 

type KeybasePacket struct {
	Body    interface{}        `codec:"body"`
	Hash    *KeybasePacketHash `codec:"hash,omitempty"`
	Tag     int                `codec:"tag"`
	Version int                `codec:"version"`
}

func DecodeArmoredPacket ¶ 

func DecodeArmoredPacket(s string) (*KeybasePacket, error)

func DecodePacket ¶ 

func DecodePacket(data []byte) (ret *KeybasePacket, err error)

func (*KeybasePacket) ArmoredEncode ¶ 

func (p *KeybasePacket) ArmoredEncode() (ret string, err error)

func (*KeybasePacket) Encode ¶ 

func (p *KeybasePacket) Encode() ([]byte, error)

func (*KeybasePacket) EncodeTo ¶ 

func (p *KeybasePacket) EncodeTo(w io.Writer) error

func (*KeybasePacket) HashMe ¶ 

func (p *KeybasePacket) HashMe() error

func (KeybasePacket) ToNaclSigInfo ¶ 

func (p KeybasePacket) ToNaclSigInfo() (*NaclSigInfo, error)

func (KeybasePacket) ToSKB ¶ 

func (p KeybasePacket) ToSKB() (*SKB, error)

type KeybasePacketHash ¶ 

type KeybasePacketHash struct {
	Type  int    `codec:"type"`
	Value []byte `codec:"value"`
}

type KeybasePackets ¶ 

type KeybasePackets []*KeybasePacket

func DecodePacketsUnchecked ¶ 

func DecodePacketsUnchecked(reader io.Reader) (ret KeybasePackets, err error)

DecodePacketsUnchecked decodes an array of packets from `reader`. It does *not* check that the stream was canonical msgpack.

func (KeybasePackets) Encode ¶ 

func (p KeybasePackets) Encode() ([]byte, error)

func (KeybasePackets) EncodeTo ¶ 

func (p KeybasePackets) EncodeTo(w io.Writer) error

func (KeybasePackets) ToListOfSKBs ¶ 

func (p KeybasePackets) ToListOfSKBs() ([]*SKB, error)

type KeybaseTime ¶ 

type KeybaseTime struct {
	Unix  int64 // UTC wallclock time
	Chain int   // Merkle root chain time
}

We have two notions of time we can use -- standard UTC which might be screwy (skewy) based upon local clock problems; or MerkleRoot seqno, which is totally ordered and all clients and server ought to agree on it. The issue is that we're not uniformly signing Merkle roots into signatures, especially those generated on the Web site.

func NowAsKeybaseTime ¶ 

func NowAsKeybaseTime(seqno int) *KeybaseTime

NowAsKeybaseTime makes a representation of now. IF we don't know the MerkleTree chain seqno, just use 0

func TclToKeybaseTime ¶ 

func TclToKeybaseTime(tcl TypedChainLink) *KeybaseTime

TclToKeybaseTime turns a TypedChainLink into a KeybaseTime tuple, looking inside the chainlink for the Unix wallclock and the global MerkleChain seqno.

type KeyringFile ¶ 

type KeyringFile struct {
	Entities openpgp.EntityList

	Contextified
	// contains filtered or unexported fields
}

func (KeyringFile) GetFilename ¶ 

func (k KeyringFile) GetFilename() string

func (*KeyringFile) Index ¶ 

func (k *KeyringFile) Index() error

func (*KeyringFile) Load ¶ 

func (k *KeyringFile) Load() error

func (*KeyringFile) LoadAndIndex ¶ 

func (k *KeyringFile) LoadAndIndex() error

func (KeyringFile) Save ¶ 

func (k KeyringFile) Save() error

func (KeyringFile) WriteTo ¶ 

func (k KeyringFile) WriteTo(w io.Writer) (int64, error)

type Keyrings ¶ 

type Keyrings struct {
	Contextified
}

func NewKeyrings ¶ 

func NewKeyrings(g *GlobalContext) *Keyrings

func (*Keyrings) GetSecretKeyAndSKBWithPrompt ¶ 

func (k *Keyrings) GetSecretKeyAndSKBWithPrompt(lctx LoginContext, ska SecretKeyArg, secretUI SecretUI, reason string) (key GenericKey, skb *SKB, err error)

func (*Keyrings) GetSecretKeyLocked ¶ 

func (k *Keyrings) GetSecretKeyLocked(lctx LoginContext, ska SecretKeyArg) (ret *SKB, which string, err error)

GetSecretKeyLocked gets a secret key for the current user by first looking for keys synced from the server, and if that fails, tries those in the local Keyring that are also active for the user. In any case, the key will be locked.

func (*Keyrings) GetSecretKeyWithPassphrase ¶ 

func (k *Keyrings) GetSecretKeyWithPassphrase(lctx LoginContext, me *User, passphrase string, secretStorer SecretStorer) (key GenericKey, err error)

func (*Keyrings) GetSecretKeyWithPrompt ¶ 

func (k *Keyrings) GetSecretKeyWithPrompt(lctx LoginContext, ska SecretKeyArg, secretUI SecretUI, reason string) (key GenericKey, err error)

TODO: Figure out whether and how to dep-inject the SecretStore.

func (*Keyrings) GetSecretKeyWithStoredSecret ¶ 

func (k *Keyrings) GetSecretKeyWithStoredSecret(lctx LoginContext, ska SecretKeyArg, me *User, secretRetriever SecretRetriever) (key GenericKey, err error)

func (*Keyrings) GetSecretKeyWithoutPrompt ¶ 

func (k *Keyrings) GetSecretKeyWithoutPrompt(lctx LoginContext, ska SecretKeyArg) (key GenericKey, err error)

func (*Keyrings) MakeKeyrings ¶ 

func (k *Keyrings) MakeKeyrings(filenames []string, isPublic bool) []*KeyringFile

type LKSec ¶ 

type LKSec struct {
	Contextified
	// contains filtered or unexported fields
}

func NewLKSForEncrypt ¶ 

func NewLKSForEncrypt(ui SecretUI, uid keybase1.UID, gc *GlobalContext) (ret *LKSec, err error)

NewLKSForEncrypt gets a verified passphrase stream, and returns an LKS that works for encryption.

func NewLKSec ¶ 

func NewLKSec(pps *PassphraseStream, uid keybase1.UID, gc *GlobalContext) *LKSec

func NewLKSecWithClientHalf ¶ 

func NewLKSecWithClientHalf(clientHalf []byte, ppgen PassphraseGeneration, uid keybase1.UID, gc *GlobalContext) *LKSec

func NewLKSecWithFullSecret ¶ 

func NewLKSecWithFullSecret(secret []byte, uid keybase1.UID, gc *GlobalContext) *LKSec

func (*LKSec) Decrypt ¶ 

func (s *LKSec) Decrypt(lctx LoginContext, src []byte) (res []byte, gen PassphraseGeneration, err error)

func (*LKSec) Encrypt ¶ 

func (s *LKSec) Encrypt(src []byte) (res []byte, err error)

func (*LKSec) EncryptClientHalfRecovery ¶ 

func (s *LKSec) EncryptClientHalfRecovery(key GenericKey) (string, error)

EncryptClientHalfRecovery takes the client half of the LKS secret and ecrypts it for the given key. This is for recovery of passphrases on device recovery operations.

func (*LKSec) GenerateServerHalf ¶ 

func (s *LKSec) GenerateServerHalf() error

func (LKSec) Generation ¶ 

func (s LKSec) Generation() PassphraseGeneration

Generation returns the passphrase generation that this local key security object is derived from.

func (*LKSec) GetSecret ¶ 

func (s *LKSec) GetSecret(lctx LoginContext) (secret []byte, err error)

func (*LKSec) GetServerHalf ¶ 

func (s *LKSec) GetServerHalf() []byte

func (*LKSec) Load ¶ 

func (s *LKSec) Load(lctx LoginContext) (err error)

func (*LKSec) SetClientHalf ¶ 

func (s *LKSec) SetClientHalf(b []byte)

func (*LKSec) SetServerHalf ¶ 

func (s *LKSec) SetServerHalf(b []byte)

func (*LKSec) SetUID ¶ 

func (s *LKSec) SetUID(u keybase1.UID)

type LevelDb ¶ 

type LevelDb struct {
	sync.Mutex
	Contextified
	// contains filtered or unexported fields
}

func NewLevelDb ¶ 

func NewLevelDb(g *GlobalContext) *LevelDb

func (*LevelDb) Close ¶ 

func (l *LevelDb) Close() error

func (*LevelDb) Delete ¶ 

func (l *LevelDb) Delete(id DbKey) error

func (*LevelDb) ForceOpen ¶ 

func (l *LevelDb) ForceOpen() error

ForceOpen opens the leveldb file. This is used in situations where we want to get around the lazy open and make sure we can use it later.

func (*LevelDb) Get ¶ 

func (l *LevelDb) Get(id DbKey) ([]byte, bool, error)

func (*LevelDb) GetFilename ¶ 

func (l *LevelDb) GetFilename() string

func (*LevelDb) Lookup ¶ 

func (l *LevelDb) Lookup(id DbKey) ([]byte, bool, error)

func (*LevelDb) Nuke ¶ 

func (l *LevelDb) Nuke() (string, error)

func (*LevelDb) Open ¶ 

func (l *LevelDb) Open() error

Explicit open does nothing we'll wait for a lazy open

func (*LevelDb) Put ¶ 

func (l *LevelDb) Put(id DbKey, aliases []DbKey, value []byte) error

type Lexer ¶ 

type Lexer struct {
	// contains filtered or unexported fields
}

func NewLexer ¶ 

func NewLexer(s string) *Lexer

func (*Lexer) Get ¶ 

func (lx *Lexer) Get() *Token

func (*Lexer) Putback ¶ 

func (lx *Lexer) Putback()

type LinkCheckResult ¶ 

type LinkCheckResult struct {
	// contains filtered or unexported fields
}

func (LinkCheckResult) Export ¶ 

func (l LinkCheckResult) Export() keybase1.LinkCheckResult

func (LinkCheckResult) ExportToIdentifyRow ¶ 

func (l LinkCheckResult) ExportToIdentifyRow(i int) keybase1.IdentifyRow

func (LinkCheckResult) GetCached ¶ 

func (l LinkCheckResult) GetCached() *CheckResult

func (LinkCheckResult) GetDiff ¶ 

func (l LinkCheckResult) GetDiff() TrackDiff

func (LinkCheckResult) GetError ¶ 

func (l LinkCheckResult) GetError() error

func (LinkCheckResult) GetHint ¶ 

func (l LinkCheckResult) GetHint() *SigHint

func (LinkCheckResult) GetPosition ¶ 

func (l LinkCheckResult) GetPosition() int

func (LinkCheckResult) GetTorWarning ¶ 

func (l LinkCheckResult) GetTorWarning() bool

type LinkID ¶ 

type LinkID []byte

func ComputeLinkID ¶ 

func ComputeLinkID(d []byte) LinkID

func GetLinkID ¶ 

func GetLinkID(w *jsonw.Wrapper) (LinkID, error)

func LinkIDFromHex ¶ 

func LinkIDFromHex(s string) (LinkID, error)

func SignJSON ¶ 

func SignJSON(jw *jsonw.Wrapper, key GenericKey) (out string, id keybase1.SigID, lid LinkID, err error)

SimpleSignJson marshals the given Json structure and then signs it.

func (LinkID) Eq ¶ 

func (l LinkID) Eq(i2 LinkID) bool

func (*LinkID) MarshalJSON ¶ 

func (l *LinkID) MarshalJSON() ([]byte, error)

func (LinkID) String ¶ 

func (l LinkID) String() string

func (*LinkID) UnmarshalJSON ¶ 

func (l *LinkID) UnmarshalJSON(b []byte) error

type LinkType ¶ 

type LinkType string

type LoadUserArg ¶ 

type LoadUserArg struct {
	UID               keybase1.UID
	Name              string // Can also be an assertion like foo@twitter
	PublicKeyOptional bool
	NoCacheResult     bool // currently ignore
	Self              bool
	ForceReload       bool
	AllKeys           bool
	LoginContext      LoginContext
	Contextified
}

func NewLoadUserArg ¶ 

func NewLoadUserArg(g *GlobalContext) LoadUserArg

func NewLoadUserByNameArg ¶ 

func NewLoadUserByNameArg(g *GlobalContext, name string) LoadUserArg

func NewLoadUserForceArg ¶ 

func NewLoadUserForceArg(g *GlobalContext) LoadUserArg

func NewLoadUserPubOptionalArg ¶ 

func NewLoadUserPubOptionalArg(g *GlobalContext) LoadUserArg

type LocalDb ¶ 

type LocalDb interface {
	Open() error
	ForceOpen() error
	Close() error
	Nuke() (string, error)
	Put(id DbKey, aliases []DbKey, value []byte) error
	Delete(id DbKey) error
	Get(id DbKey) ([]byte, bool, error)
	Lookup(alias DbKey) ([]byte, bool, error)
}

type LockPIDFile ¶ 

type LockPIDFile struct {
	// contains filtered or unexported fields
}

func NewLockPIDFile ¶ 

func NewLockPIDFile(s string) *LockPIDFile

func (*LockPIDFile) Close ¶ 

func (f *LockPIDFile) Close() (err error)

func (*LockPIDFile) Lock ¶ 

func (f *LockPIDFile) Lock() (err error)

Lock writes the pid to filename after acquiring a lock on the file. When the process exits, the lock will be released.

type LockTable ¶ 

type LockTable struct {
	// contains filtered or unexported fields
}

func NewLockTable ¶ 

func NewLockTable() *LockTable

func (*LockTable) Lock ¶ 

func (t *LockTable) Lock(s string) (ret *NamedLock)

type LogUI ¶ 

type LogUI interface {
	Debug(format string, args ...interface{})
	Info(format string, args ...interface{})
	Warning(format string, args ...interface{})
	Notice(format string, args ...interface{})
	Errorf(format string, args ...interface{})
	Critical(format string, args ...interface{})
}

type LoggedInError ¶ 

type LoggedInError struct{}

func (LoggedInError) Error ¶ 

func (e LoggedInError) Error() string

func (LoggedInError) ToStatus ¶ 

func (e LoggedInError) ToStatus() (s keybase1.Status)

type LoggedInWrongUserError ¶ 

type LoggedInWrongUserError struct {
	ExistingName  NormalizedUsername
	AttemptedName NormalizedUsername
}

func (LoggedInWrongUserError) Error ¶ 

func (e LoggedInWrongUserError) Error() string

func (LoggedInWrongUserError) ToStatus ¶ 

func (e LoggedInWrongUserError) ToStatus() (s keybase1.Status)

type LoginContext ¶ 

type LoginContext interface {
	LoggedInLoad() (bool, error)
	LoggedInProvisionedLoad() (bool, error)
	Logout() error

	CreateStreamCache(tsec *triplesec.Cipher, pps *PassphraseStream)
	CreateStreamCacheViaStretch(passphrase string) error
	PassphraseStreamCache() *PassphraseStreamCache
	ClearStreamCache()
	SetStreamGeneration(gen PassphraseGeneration, nilPPStreamOK bool)
	GetStreamGeneration() PassphraseGeneration

	CreateLoginSessionWithSalt(emailOrUsername string, salt []byte) error
	LoadLoginSession(emailOrUsername string) error
	LoginSession() *LoginSession
	ClearLoginSession()

	LocalSession() *Session
	EnsureUsername(username NormalizedUsername)
	SaveState(sessionID, csrf string, username NormalizedUsername, uid keybase1.UID, deviceID keybase1.DeviceID) error
	SaveStateTmp(sessionID, csrf string, username NormalizedUsername, uid keybase1.UID, deviceID keybase1.DeviceID) (string, error)

	Keyring() (*SKBKeyringFile, error)
	LockedLocalSecretKey(ska SecretKeyArg) (*SKB, error)

	SecretSyncer() *SecretSyncer
	RunSecretSyncer(uid keybase1.UID) error

	CachedSecretKey(ska SecretKeyArg) (GenericKey, error)
	SetCachedSecretKey(ska SecretKeyArg, key GenericKey) error
}

LoginContext is passed to all loginHandler functions. It allows them safe access to various parts of the LoginState during the login process.

type LoginRequiredError ¶ 

type LoginRequiredError struct {
	Context string
}

func (LoginRequiredError) Error ¶ 

func (e LoginRequiredError) Error() string

func (LoginRequiredError) ToStatus ¶ 

func (u LoginRequiredError) ToStatus() (s keybase1.Status)

type LoginSession ¶ 

type LoginSession struct {
	Contextified
	// contains filtered or unexported fields
}

func NewLoginSession ¶ 

func NewLoginSession(emailOrUsername string, g *GlobalContext) *LoginSession

func NewLoginSessionWithSalt ¶ 

func NewLoginSessionWithSalt(emailOrUsername string, salt []byte, g *GlobalContext) *LoginSession

Upon signup, a login session is created with a generated salt.

func (*LoginSession) Clear ¶ 

func (s *LoginSession) Clear() error

func (*LoginSession) Dump ¶ 

func (s *LoginSession) Dump()

func (*LoginSession) ExistsFor ¶ 

func (s *LoginSession) ExistsFor(emailOrUsername string) bool

func (*LoginSession) Load ¶ 

func (s *LoginSession) Load() error

func (*LoginSession) Salt ¶ 

func (s *LoginSession) Salt() ([]byte, error)

func (*LoginSession) Session ¶ 

func (s *LoginSession) Session() ([]byte, error)

func (*LoginSession) SessionEncoded ¶ 

func (s *LoginSession) SessionEncoded() (string, error)

type LoginSessionNotFound ¶ 

type LoginSessionNotFound struct {
	SessionID int
}

func (LoginSessionNotFound) Error ¶ 

func (e LoginSessionNotFound) Error() string

type LoginState ¶ 

type LoginState struct {
	Contextified
	// contains filtered or unexported fields
}

LoginState controls the state of the current user's login session and associated variables. It also serializes access to the various Login functions and requests for the Account object.

func NewLoginState ¶ 

func NewLoginState(g *GlobalContext) *LoginState

NewLoginState creates a LoginState and starts the request handler goroutine.

func (*LoginState) Account ¶ 

func (s *LoginState) Account(h acctHandler, name string) error

Account is a convenience function to allow access to LoginState's Account object. For example: 

e.G().LoginState().Account(func (a *Account) {
    skb = a.LockedLocalSecretKey(ska)
}, "LockedLocalSecretKey")

func (*LoginState) AccountDump ¶ 

func (s *LoginState) AccountDump()

func (*LoginState) ExternalFunc ¶ 

func (s *LoginState) ExternalFunc(f loginHandler, name string) error

ExternalFunc is for having the LoginState handler call a function outside of LoginState. The current use case is for signup, so that no logins/logouts happen while a signup is happening.

func (*LoginState) GetPassphraseStream ¶ 

func (s *LoginState) GetPassphraseStream(ui SecretUI) (pps *PassphraseStream, err error)

GetPassphraseStream either returns a cached, verified passphrase stream (maybe from a previous login) or generates a new one via Login. It will return the current Passphrase stream on success or an error on failure.

func (*LoginState) GetPassphraseStreamForUser ¶ 

func (s *LoginState) GetPassphraseStreamForUser(ui SecretUI, username string) (pps *PassphraseStream, err error)

GetPassphraseStreamForUser either returns a cached, verified passphrase stream (maybe from a previous login) or generates a new one via Login. It will return the current Passphrase stream on success or an error on failure.

func (*LoginState) GetVerifiedTriplesec ¶ 

func (s *LoginState) GetVerifiedTriplesec(ui SecretUI) (ret *triplesec.Cipher, gen PassphraseGeneration, err error)

GetVerifiedTripleSec either returns a cached, verified Triplesec or generates a new one that's verified via Login.

func (*LoginState) Keyring ¶ 

func (s *LoginState) Keyring(h func(*SKBKeyringFile), name string) error

func (*LoginState) LocalSession ¶ 

func (s *LoginState) LocalSession(h func(*Session), name string) error

func (*LoginState) LoggedIn ¶ 

func (s *LoginState) LoggedIn() bool

func (*LoginState) LoggedInLoad ¶ 

func (s *LoginState) LoggedInLoad() (lin bool, err error)

func (*LoginState) LoggedInProvisionedLoad ¶ 

func (s *LoginState) LoggedInProvisionedLoad() (lin bool, err error)

func (*LoginState) LoginSession ¶ 

func (s *LoginState) LoginSession(h func(*LoginSession), name string) error

func (*LoginState) LoginWithKey ¶ 

func (s *LoginState) LoginWithKey(lctx LoginContext, user *User, key GenericKey, after afterFn) (err error)

func (*LoginState) LoginWithPassphrase ¶ 

func (s *LoginState) LoginWithPassphrase(username, passphrase string, storeSecret bool, after afterFn) (err error)

func (*LoginState) LoginWithPrompt ¶ 

func (s *LoginState) LoginWithPrompt(username string, loginUI LoginUI, secretUI SecretUI, after afterFn) (err error)

func (*LoginState) LoginWithStoredSecret ¶ 

func (s *LoginState) LoginWithStoredSecret(username string, after afterFn) (err error)

func (*LoginState) Logout ¶ 

func (s *LoginState) Logout() error

func (*LoginState) PassphraseStream ¶ 

func (s *LoginState) PassphraseStream() (*PassphraseStream, error)

func (*LoginState) PassphraseStreamCache ¶ 

func (s *LoginState) PassphraseStreamCache(h func(*PassphraseStreamCache), name string) error

func (*LoginState) PassphraseStreamGeneration ¶ 

func (s *LoginState) PassphraseStreamGeneration() (PassphraseGeneration, error)

func (*LoginState) RunSecretSyncer ¶ 

func (s *LoginState) RunSecretSyncer(uid keybase1.UID) error

func (*LoginState) SecretSyncer ¶ 

func (s *LoginState) SecretSyncer(h func(*SecretSyncer), name string) error

func (*LoginState) Shutdown ¶ 

func (s *LoginState) Shutdown() error

func (*LoginState) VerifyPlaintextPassphrase ¶ 

func (s *LoginState) VerifyPlaintextPassphrase(pp string) (ppStream *PassphraseStream, err error)

VerifyPlaintextPassphrase verifies that the supplied plaintext passphrase is indeed the correct passphrase for the logged in user. This is accomplished via a login request. The side effect will be that we'll retrieve the correct generation number of the current passphrase from the server.

type LoginUI ¶ 

type LoginUI interface {
	keybase1.LoginUiInterface
}

type LogoutError ¶ 

type LogoutError struct{}

func (LogoutError) Error ¶ 

func (e LogoutError) Error() string

type LoopbackAddr ¶ 

type LoopbackAddr struct{}

LoopbackAddr is an address class that implement the net.Addr interface for loopback devices

func (LoopbackAddr) Network ¶ 

func (la LoopbackAddr) Network() (s string)

Network returns the name of the network

func (LoopbackAddr) String ¶ 

func (la LoopbackAddr) String() (s string)

String returns the string form of address

type LoopbackConn ¶ 

type LoopbackConn struct {
	// contains filtered or unexported fields
}

LoopbackConn implments the net.Conn interface but is used to loopback from a process to itself. It is goroutine safe.

func (*LoopbackConn) Close ¶ 

func (lc *LoopbackConn) Close() (err error)

Close closes the connection. Any blocked Read or Write operations will be unblocked and return errors.

func (*LoopbackConn) LocalAddr ¶ 

func (lc *LoopbackConn) LocalAddr() (addr net.Addr)

LocalAddr returns the local network address.

func (*LoopbackConn) Read ¶ 

func (lc *LoopbackConn) Read(b []byte) (n int, err error)

Read reads data from the connection.

func (*LoopbackConn) RemoteAddr ¶ 

func (lc *LoopbackConn) RemoteAddr() (addr net.Addr)

RemoteAddr returns the remote network address.

func (*LoopbackConn) SetDeadline ¶ 

func (lc *LoopbackConn) SetDeadline(t time.Time) (err error)

SetDeadline sets the read and write deadlines associated with the connection. It is equivalent to calling both SetReadDeadline and SetWriteDeadline.

A deadline is an absolute time after which I/O operations fail with a timeout (see type Error) instead of blocking. The deadline applies to all future I/O, not just the immediately following call to Read or Write.

An idle timeout can be implemented by repeatedly extending the deadline after successful Read or Write calls.

A zero value for t means I/O operations will not time out.

func (*LoopbackConn) SetReadDeadline ¶ 

func (lc *LoopbackConn) SetReadDeadline(t time.Time) (err error)

SetReadDeadline sets the deadline for future Read calls. A zero value for t means Read will not time out.

func (*LoopbackConn) SetWriteDeadline ¶ 

func (lc *LoopbackConn) SetWriteDeadline(t time.Time) (err error)

SetWriteDeadline sets the deadline for future Write calls. Even if write times out, it may return n > 0, indicating that some of the data was successfully written. A zero value for t means Write will not time out.

func (*LoopbackConn) Write ¶ 

func (lc *LoopbackConn) Write(b []byte) (n int, err error)

Write writes data to the connection.

type LoopbackListener ¶ 

type LoopbackListener struct {
	// contains filtered or unexported fields
}

LoopbackListener is a listener that creates new loopback connections. It is goroutine safe.

func NewLoopbackListener ¶ 

func NewLoopbackListener() *LoopbackListener

NewLoopbackListener creates a new Loopback listener

func (*LoopbackListener) Accept ¶ 

func (ll *LoopbackListener) Accept() (ret net.Conn, err error)

Accept waits for and returns the next connection to the listener.

func (*LoopbackListener) Addr ¶ 

func (ll *LoopbackListener) Addr() (addr net.Addr)

Addr returns the listener's network address.

func (*LoopbackListener) Close ¶ 

func (ll *LoopbackListener) Close() (err error)

Close closes the listener. Any blocked Accept operations will be unblocked and return errors

func (*LoopbackListener) Dial ¶ 

func (ll *LoopbackListener) Dial() (net.Conn, error)

LoopbackDial dials the given LoopbackListener and yields an new net.Conn that's a connection to it.

type Markup ¶ 

type Markup struct {
	// contains filtered or unexported fields
}

func FmtMarkup ¶ 

func FmtMarkup(f string, args ...interface{}) *Markup

func NewMarkup ¶ 

func NewMarkup(s string) *Markup

func (*Markup) Append ¶ 

func (m *Markup) Append(s string)

func (Markup) Export ¶ 

func (m Markup) Export() (ret keybase1.Text)

func (Markup) GetRaw ¶ 

func (m Markup) GetRaw() string

func (Markup) ToReader ¶ 

func (m Markup) ToReader() io.Reader

type MerkleClashError ¶ 

type MerkleClashError struct {
	// contains filtered or unexported fields
}

func (MerkleClashError) Error ¶ 

func (m MerkleClashError) Error() string

type MerkleClient ¶ 

type MerkleClient struct {
	Contextified

	// protects whole object
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewMerkleClient ¶ 

func NewMerkleClient(g *GlobalContext) *MerkleClient

func (*MerkleClient) Init ¶ 

func (mc *MerkleClient) Init() error

func (*MerkleClient) LastRootToSigJSON ¶ 

func (mc *MerkleClient) LastRootToSigJSON() (ret *jsonw.Wrapper, err error)

func (*MerkleClient) LastSeqno ¶ 

func (mc *MerkleClient) LastSeqno() Seqno

func (*MerkleClient) LoadRoot ¶ 

func (mc *MerkleClient) LoadRoot() error

func (*MerkleClient) LookupPath ¶ 

func (mc *MerkleClient) LookupPath(q HTTPArgs) (vp *VerificationPath, err error)

func (*MerkleClient) LookupUser ¶ 

func (mc *MerkleClient) LookupUser(q HTTPArgs) (u *MerkleUserLeaf, err error)

func (*MerkleClient) VerifyRoot ¶ 

func (mc *MerkleClient) VerifyRoot(root *MerkleRoot) error

type MerkleClientError ¶ 

type MerkleClientError struct {
	// contains filtered or unexported fields
}

func (MerkleClientError) Error ¶ 

func (m MerkleClientError) Error() string

type MerkleNotFoundError ¶ 

type MerkleNotFoundError struct {
	// contains filtered or unexported fields
}

func (MerkleNotFoundError) Error ¶ 

func (m MerkleNotFoundError) Error() string

type MerkleRoot ¶ 

type MerkleRoot struct {
	Contextified
	// contains filtered or unexported fields
}

func NewMerkleRootFromJSON ¶ 

func NewMerkleRootFromJSON(jw *jsonw.Wrapper, g *GlobalContext) (ret *MerkleRoot, err error)

func (*MerkleRoot) Store ¶ 

func (mr *MerkleRoot) Store() error

func (*MerkleRoot) ToJSON ¶ 

func (mr *MerkleRoot) ToJSON() (jw *jsonw.Wrapper)

func (*MerkleRoot) ToSigJSON ¶ 

func (mr *MerkleRoot) ToSigJSON() (ret *jsonw.Wrapper)

type MerkleTriple ¶ 

type MerkleTriple struct {
	Seqno  Seqno          `json:"seqno"`
	LinkID LinkID         `json:"id"`
	SigID  keybase1.SigID `json:"sigid,omitempty"`
}

func GetMerkleTriple ¶ 

func GetMerkleTriple(jw *jsonw.Wrapper) (ret *MerkleTriple, err error)

func (MerkleTriple) Less ¶ 

func (mt1 MerkleTriple) Less(mt2 MerkleTriple) bool

type MerkleUserLeaf ¶ 

type MerkleUserLeaf struct {
	// contains filtered or unexported fields
}

func (*MerkleUserLeaf) MatchUser ¶ 

func (mul *MerkleUserLeaf) MatchUser(u *User, uid keybase1.UID, un string) (err error)

type MissingDelegationTypeError ¶ 

type MissingDelegationTypeError struct{}

func (MissingDelegationTypeError) Error ¶ 

func (e MissingDelegationTypeError) Error() string

type NaclDHKeyPair ¶ 

type NaclDHKeyPair struct {
	Public  NaclDHKeyPublic
	Private *NaclDHKeyPrivate
}

func GenerateNaclDHKeyPair ¶ 

func GenerateNaclDHKeyPair() (NaclDHKeyPair, error)

func ImportNaclDHKeyPairFromBytes ¶ 

func ImportNaclDHKeyPairFromBytes(pub []byte, priv []byte) (ret NaclDHKeyPair, err error)

func ImportNaclDHKeyPairFromHex ¶ 

func ImportNaclDHKeyPairFromHex(s string) (ret NaclDHKeyPair, err error)

func MakeNaclDHKeyPairFromSecret ¶ 

func MakeNaclDHKeyPairFromSecret(secret [NaclDHKeySecretSize]byte) (NaclDHKeyPair, error)

MakeNaclDHKeyPairFromSecret makes a DH key pair given a secret. Of course, the security of depends entirely on the randomness of the bytes in the secret.

func (NaclDHKeyPair) CanDecrypt ¶ 

func (k NaclDHKeyPair) CanDecrypt() bool

CanDecrypt returns true if there's a private key available

func (NaclDHKeyPair) CanEncrypt ¶ 

func (k NaclDHKeyPair) CanEncrypt() bool

CanEncrypt always returns true for an encryption key pair.

func (NaclDHKeyPair) CanSign ¶ 

func (k NaclDHKeyPair) CanSign() bool

func (NaclDHKeyPair) CheckSecretKey ¶ 

func (k NaclDHKeyPair) CheckSecretKey() error

func (NaclDHKeyPair) Decrypt ¶ 

func (k NaclDHKeyPair) Decrypt(nei *NaclEncryptionInfo) (plaintext []byte, sender keybase1.KID, err error)

Decrypt a NaclEncryptionInfo packet, and on success return the plaintext and the KID of the sender (which might be an ephemeral key).

func (NaclDHKeyPair) DecryptFromString ¶ 

func (k NaclDHKeyPair) DecryptFromString(ciphertext string) (msg []byte, sender keybase1.KID, err error)

DecryptFromString decrypts the output of EncryptToString above, and returns the KID of the other end.

func (NaclDHKeyPair) Encode ¶ 

func (k NaclDHKeyPair) Encode() (string, error)

func (NaclDHKeyPair) Encrypt ¶ 

func (k NaclDHKeyPair) Encrypt(msg []byte, sender *NaclDHKeyPair) (*NaclEncryptionInfo, error)

Encrypt a message for the given sender. If sender is nil, an ephemeral keypair will be invented

func (NaclDHKeyPair) EncryptToString ¶ 

func (k NaclDHKeyPair) EncryptToString(plaintext []byte, sender GenericKey) (string, error)

EncryptToString encrypts the plaintext using DiffieHelman; the this object is the receiver, and the passed sender is optional. If not provided, we'll make up an ephemeral key.

func (NaclDHKeyPair) GetAlgoType ¶ 

func (k NaclDHKeyPair) GetAlgoType() AlgoType

func (NaclDHKeyPair) GetFingerprintP ¶ 

func (k NaclDHKeyPair) GetFingerprintP() *PGPFingerprint

func (NaclDHKeyPair) GetKID ¶ 

func (k NaclDHKeyPair) GetKID() keybase1.KID

func (NaclDHKeyPair) HasSecretKey ¶ 

func (k NaclDHKeyPair) HasSecretKey() bool

func (NaclDHKeyPair) SignToString ¶ 

func (k NaclDHKeyPair) SignToString(msg []byte) (sig string, id keybase1.SigID, err error)

func (NaclDHKeyPair) ToLksSKB ¶ 

func (k NaclDHKeyPair) ToLksSKB(lks *LKSec) (*SKB, error)

func (NaclDHKeyPair) ToServerSKB ¶ 

func (k NaclDHKeyPair) ToServerSKB(gc *GlobalContext, t *triplesec.Cipher, gen PassphraseGeneration) (*SKB, error)

func (NaclDHKeyPair) ToShortIDString ¶ 

func (k NaclDHKeyPair) ToShortIDString() string

func (NaclDHKeyPair) VerboseDescription ¶ 

func (k NaclDHKeyPair) VerboseDescription() string

func (NaclDHKeyPair) VerifyString ¶ 

func (k NaclDHKeyPair) VerifyString(sig string, msg []byte) (id keybase1.SigID, err error)

func (NaclDHKeyPair) VerifyStringAndExtract ¶ 

func (k NaclDHKeyPair) VerifyStringAndExtract(sig string) (msg []byte, id keybase1.SigID, err error)

type NaclDHKeyPrivate ¶ 

type NaclDHKeyPrivate [NaclDHKeysize]byte

type NaclDHKeyPublic ¶ 

type NaclDHKeyPublic [NaclDHKeysize]byte

func (NaclDHKeyPublic) GetKID ¶ 

func (k NaclDHKeyPublic) GetKID() keybase1.KID

type NaclEncryptionInfo ¶ 

type NaclEncryptionInfo struct {
	Ciphertext     []byte `codec:"ciphertext"`
	EncryptionType int    `codec:"enc_type"`
	Nonce          []byte `codec:"nonce"`
	Receiver       []byte `codec:"receiver_key"`
	Sender         []byte `codec:"sender_key"`
}

func (*NaclEncryptionInfo) ToPacket ¶ 

func (k *NaclEncryptionInfo) ToPacket() (ret *KeybasePacket, err error)

ToPacket implements the Packetable interface.

type NaclGenerator ¶ 

type NaclGenerator func() (NaclKeyPair, error)

type NaclKeyGen ¶ 

type NaclKeyGen struct {
	// contains filtered or unexported fields
}

func NewNaclKeyGen ¶ 

func NewNaclKeyGen(arg NaclKeyGenArg) *NaclKeyGen

func (*NaclKeyGen) Generate ¶ 

func (g *NaclKeyGen) Generate() (err error)

func (*NaclKeyGen) GetKeyPair ¶ 

func (g *NaclKeyGen) GetKeyPair() NaclKeyPair

func (*NaclKeyGen) Push ¶ 

func (g *NaclKeyGen) Push(lctx LoginContext, aggregated bool) (d Delegator, err error)

func (*NaclKeyGen) SaveLKS ¶ 

func (g *NaclKeyGen) SaveLKS(lks *LKSec, lctx LoginContext) error

func (*NaclKeyGen) UpdateArg ¶ 

func (g *NaclKeyGen) UpdateArg(signer GenericKey, eldestKID keybase1.KID, sibkey bool, user *User)

type NaclKeyGenArg ¶ 

type NaclKeyGenArg struct {
	Signer      GenericKey // who is going to sign us into the Chain
	ExpiresIn   int
	Generator   NaclGenerator
	Me          *User
	Sibkey      bool
	ExpireIn    int          // how long it lasts
	EldestKeyID keybase1.KID // the eldest KID for this epoch
	Device      *Device
	RevSig      string // optional reverse sig.  set to nil for autogenerate.
}

type NaclKeyPair ¶ 

type NaclKeyPair interface {
	GenericKey
}

type NaclSigInfo ¶ 

type NaclSigInfo struct {
	Kid      []byte        `codec:"key"`
	Payload  []byte        `codec:"payload,omitempty"`
	Sig      NaclSignature `codec:"sig"`
	SigType  int           `codec:"sig_type"`
	HashType int           `codec:"hash_type"`
	Detached bool          `codec:"detached"`
}

func (*NaclSigInfo) ArmoredEncode ¶ 

func (s *NaclSigInfo) ArmoredEncode() (ret string, err error)

func (*NaclSigInfo) ToPacket ¶ 

func (s *NaclSigInfo) ToPacket() (ret *KeybasePacket, err error)

func (NaclSigInfo) Verify ¶ 

func (s NaclSigInfo) Verify() (error, *NaclSigningKeyPublic)

type NaclSignature ¶ 

type NaclSignature [ed25519.SignatureSize]byte

type NaclSigningKeyPair ¶ 

type NaclSigningKeyPair struct {
	Public  NaclSigningKeyPublic
	Private *NaclSigningKeyPrivate
}

func GenerateNaclSigningKeyPair ¶ 

func GenerateNaclSigningKeyPair() (NaclSigningKeyPair, error)

func ImportNaclSigningKeyPairFromBytes ¶ 

func ImportNaclSigningKeyPairFromBytes(pub []byte, priv []byte) (ret NaclSigningKeyPair, err error)

func ImportNaclSigningKeyPairFromHex ¶ 

func ImportNaclSigningKeyPairFromHex(s string) (ret NaclSigningKeyPair, err error)

func MakeNaclSigningKeyPairFromSecret ¶ 

func MakeNaclSigningKeyPairFromSecret(secret [NaclSigningKeySecretSize]byte) (NaclSigningKeyPair, error)

MakeNaclSigningKeyPairFromSecret makes a signing key pair given a secret. Of course, the security of depends entirely on the randomness of the bytes in the secret.

func (NaclSigningKeyPair) CanDecrypt ¶ 

func (k NaclSigningKeyPair) CanDecrypt() bool

CanDecrypt always returns false for a signing key pair.

func (NaclSigningKeyPair) CanEncrypt ¶ 

func (k NaclSigningKeyPair) CanEncrypt() bool

CanEncrypt always returns false for a signing key pair.

func (NaclSigningKeyPair) CanSign ¶ 

func (k NaclSigningKeyPair) CanSign() bool

func (NaclSigningKeyPair) CheckSecretKey ¶ 

func (k NaclSigningKeyPair) CheckSecretKey() error

func (NaclSigningKeyPair) DecryptFromString ¶ 

func (k NaclSigningKeyPair) DecryptFromString(ciphertext string) (msg []byte, sender keybase1.KID, err error)

DecryptFromString fails for this type of key.

func (NaclSigningKeyPair) Encode ¶ 

func (k NaclSigningKeyPair) Encode() (string, error)

func (NaclSigningKeyPair) EncryptToString ¶ 

func (k NaclSigningKeyPair) EncryptToString(plaintext []byte, sender GenericKey) (ciphertext string, err error)

EncryptToString fails for this type of key.

func (NaclSigningKeyPair) GetAlgoType ¶ 

func (k NaclSigningKeyPair) GetAlgoType() AlgoType

func (NaclSigningKeyPair) GetFingerprintP ¶ 

func (k NaclSigningKeyPair) GetFingerprintP() *PGPFingerprint

func (NaclSigningKeyPair) GetKID ¶ 

func (k NaclSigningKeyPair) GetKID() (ret keybase1.KID)

func (NaclSigningKeyPair) HasSecretKey ¶ 

func (k NaclSigningKeyPair) HasSecretKey() bool

func (NaclSigningKeyPair) Sign ¶ 

func (k NaclSigningKeyPair) Sign(msg []byte) (ret *NaclSigInfo, err error)

func (NaclSigningKeyPair) SignToString ¶ 

func (k NaclSigningKeyPair) SignToString(msg []byte) (sig string, id keybase1.SigID, err error)

func (NaclSigningKeyPair) ToLksSKB ¶ 

func (k NaclSigningKeyPair) ToLksSKB(lks *LKSec) (*SKB, error)

func (NaclSigningKeyPair) ToServerSKB ¶ 

func (k NaclSigningKeyPair) ToServerSKB(gc *GlobalContext, t *triplesec.Cipher, gen PassphraseGeneration) (*SKB, error)

NaCl keys are never wrapped for the server.

func (NaclSigningKeyPair) ToShortIDString ¶ 

func (k NaclSigningKeyPair) ToShortIDString() string

func (NaclSigningKeyPair) VerboseDescription ¶ 

func (k NaclSigningKeyPair) VerboseDescription() string

func (NaclSigningKeyPair) VerifyString ¶ 

func (k NaclSigningKeyPair) VerifyString(sig string, msg []byte) (id keybase1.SigID, err error)

func (NaclSigningKeyPair) VerifyStringAndExtract ¶ 

func (k NaclSigningKeyPair) VerifyStringAndExtract(sig string) (msg []byte, id keybase1.SigID, err error)

type NaclSigningKeyPrivate ¶ 

type NaclSigningKeyPrivate [ed25519.PrivateKeySize]byte

func (NaclSigningKeyPrivate) Sign ¶ 

func (k NaclSigningKeyPrivate) Sign(msg []byte) *NaclSignature

type NaclSigningKeyPublic ¶ 

type NaclSigningKeyPublic [ed25519.PublicKeySize]byte

func KIDToNaclSigningKeyPublic ¶ 

func KIDToNaclSigningKeyPublic(bk []byte) *NaclSigningKeyPublic

func (NaclSigningKeyPublic) GetKID ¶ 

func (k NaclSigningKeyPublic) GetKID() keybase1.KID

func (NaclSigningKeyPublic) Verify ¶ 

func (k NaclSigningKeyPublic) Verify(msg []byte, sig *NaclSignature) bool

type NamedLock ¶ 

type NamedLock struct {
	// contains filtered or unexported fields
}

func (*NamedLock) Unlock ¶ 

func (l *NamedLock) Unlock()

type NeedInputError ¶ 

type NeedInputError struct {
	// contains filtered or unexported fields
}

func (NeedInputError) Error ¶ 

func (e NeedInputError) Error() string

type NegBoolFunc ¶ 

type NegBoolFunc struct {
	// contains filtered or unexported fields
}

type NoActiveKeyError ¶ 

type NoActiveKeyError struct {
	Username string
}

func (NoActiveKeyError) Error ¶ 

func (e NoActiveKeyError) Error() string

func (NoActiveKeyError) ToStatus ¶ 

func (c NoActiveKeyError) ToStatus() (s keybase1.Status)

type NoConfigFile ¶ 

type NoConfigFile struct{}

func (NoConfigFile) Error ¶ 

func (n NoConfigFile) Error() string

type NoConfigWriterError ¶ 

type NoConfigWriterError struct{}

func (NoConfigWriterError) Error ¶ 

func (e NoConfigWriterError) Error() string

type NoDeviceError ¶ 

type NoDeviceError struct {
	Reason string
}

func (NoDeviceError) Error ¶ 

func (e NoDeviceError) Error() string

func (NoDeviceError) ToStatus ¶ 

func (e NoDeviceError) ToStatus() keybase1.Status

type NoEldestKeyError ¶ 

type NoEldestKeyError struct {
}

func (NoEldestKeyError) Error ¶ 

func (e NoEldestKeyError) Error() string

type NoKeyError ¶ 

type NoKeyError struct {
	Msg string
}

func (NoKeyError) Error ¶ 

func (u NoKeyError) Error() string

func (NoKeyError) ToStatus ¶ 

func (e NoKeyError) ToStatus() (s keybase1.Status)

type NoKeyringsError ¶ 

type NoKeyringsError struct{}

func (NoKeyringsError) Error ¶ 

func (k NoKeyringsError) Error() string

type NoPaperKeysError ¶ 

type NoPaperKeysError struct {
}

func (NoPaperKeysError) Error ¶ 

func (u NoPaperKeysError) Error() string

type NoSecretKeyError ¶ 

type NoSecretKeyError struct {
}

func (NoSecretKeyError) Error ¶ 

func (u NoSecretKeyError) Error() string

func (NoSecretKeyError) ToStatus ¶ 

func (u NoSecretKeyError) ToStatus() (s keybase1.Status)

type NoSelectedKeyError ¶ 

type NoSelectedKeyError struct {
	// contains filtered or unexported fields
}

func (NoSelectedKeyError) Error ¶ 

func (n NoSelectedKeyError) Error() string

type NoSessionWriterError ¶ 

type NoSessionWriterError struct{}

func (NoSessionWriterError) Error ¶ 

func (e NoSessionWriterError) Error() string

type NoSigChainError ¶ 

type NoSigChainError struct{}

func (NoSigChainError) Error ¶ 

func (e NoSigChainError) Error() string

type NoUIError ¶ 

type NoUIError struct {
	Which string
}

func (NoUIError) Error ¶ 

func (e NoUIError) Error() string

type NoUserConfigError ¶ 

type NoUserConfigError struct{}

func (NoUserConfigError) Error ¶ 

func (n NoUserConfigError) Error() string

type NoUsernameError ¶ 

type NoUsernameError struct{}

func (NoUsernameError) Error ¶ 

func (e NoUsernameError) Error() string

type NodeHash ¶ 

type NodeHash interface {
	Check(s string) bool // Check if the node hashes to this string
	String() string
}

func GetNodeHash ¶ 

func GetNodeHash(w *jsonw.Wrapper) (NodeHash, error)

func NodeHashFromHex ¶ 

func NodeHashFromHex(s string) (NodeHash, error)

type NodeHashLong ¶ 

type NodeHashLong [NodeHashLenLong]byte

func (NodeHashLong) Check ¶ 

func (h1 NodeHashLong) Check(s string) bool

func (NodeHashLong) String ¶ 

func (h1 NodeHashLong) String() string

type NodeHashShort ¶ 

type NodeHashShort [NodeHashLenShort]byte

func (NodeHashShort) Check ¶ 

func (h1 NodeHashShort) Check(s string) bool

func (NodeHashShort) String ¶ 

func (h1 NodeHashShort) String() string

type NopWriteCloser ¶ 

type NopWriteCloser struct {
	W io.Writer
}

NopWriteCloser is like an ioutil.NopCloser, but for an io.Writer. TODO: we have two of these in OpenPGP packages alone. This probably needs to be promoted somewhere more common.

From here: 

https://code.google.com/p/go/source/browse/openpgp/write.go?repo=crypto&r=1e7a3e301825bf9cb32e0535f3761d62d2d369d1#364

func (NopWriteCloser) Close ¶ 

func (c NopWriteCloser) Close() error

func (NopWriteCloser) Write ¶ 

func (c NopWriteCloser) Write(data []byte) (n int, err error)

type NormalizedUsername ¶ 

type NormalizedUsername string

NormalizedUsername is a username that has been normalized (toLowered) and therefore will compare correctly against other normalized usernames.

func NewNormalizedUsername ¶ 

func NewNormalizedUsername(s string) NormalizedUsername

NewNormalizedUsername makes a normalized username out of a non-normalized plain string username

func (NormalizedUsername) Eq ¶ 

func (n NormalizedUsername) Eq(n2 NormalizedUsername) bool

Eq returns true if the given normalized usernames are equal

func (NormalizedUsername) IsNil ¶ 

func (n NormalizedUsername) IsNil() bool

IsNil returns true if the username is the empty string

func (NormalizedUsername) String ¶ 

func (n NormalizedUsername) String() string

String returns the normalized username as a string (in lower case)

type NotConfirmedError ¶ 

type NotConfirmedError struct{}

func (NotConfirmedError) Error ¶ 

func (e NotConfirmedError) Error() string

type NotFoundError ¶ 

type NotFoundError struct {
	// contains filtered or unexported fields
}

func (NotFoundError) Error ¶ 

func (e NotFoundError) Error() string

type NotLatestSubchainError ¶ 

type NotLatestSubchainError struct {
	Msg string
}

func (NotLatestSubchainError) Error ¶ 

func (e NotLatestSubchainError) Error() string

type NotProvisionedError ¶ 

type NotProvisionedError struct{}

func (NotProvisionedError) Error ¶ 

func (e NotProvisionedError) Error() string

type NotifyRouter ¶ 

type NotifyRouter struct {
	Contextified
	// contains filtered or unexported fields
}

NotifyRouter routes notifications to the various active RPC connections. It's careful only to route to those who are interested

func NewNotifyRouter ¶ 

func NewNotifyRouter(g *GlobalContext) *NotifyRouter

NewNotifyRouter makes a new notification router; we should only make one of these per process.

func (*NotifyRouter) AddConnection ¶ 

func (n *NotifyRouter) AddConnection(xp rpc.Transporter, ch chan error) ConnectionID

AddConnection should be called every time there's a new RPC connection established for this server. The caller should pass in the Transporter and also the channel that will get messages when the chanel closes.

func (*NotifyRouter) HandleFSActivity ¶ 

func (n *NotifyRouter) HandleFSActivity(activity keybase1.FSNotification)

HandleFSActivity is called for any KBFS notification. It will broadcast the messages to all curious listeners.

func (*NotifyRouter) HandleLogout ¶ 

func (n *NotifyRouter) HandleLogout()

HandleLogout is called whenever the current user logged out. It will broadcast the message to all connections who care about such a mesasge.

func (*NotifyRouter) HandleUserChanged ¶ 

func (n *NotifyRouter) HandleUserChanged(uid keybase1.UID)

HandleUserChanged is called whenever we know that a given user has changed (and must be cache-busted). It will broadcast the messages to all curious listeners.

func (*NotifyRouter) SetChannels ¶ 

func (n *NotifyRouter) SetChannels(i ConnectionID, nc keybase1.NotificationChannels)

SetChannels sets which notification channels are interested for the connection with the given connection ID.

func (*NotifyRouter) Shutdown ¶ 

func (n *NotifyRouter) Shutdown()

type NullConfiguration ¶ 

type NullConfiguration struct{}

func (NullConfiguration) GetAPIDump ¶ 

func (n NullConfiguration) GetAPIDump() (bool, bool)

func (NullConfiguration) GetAPITimeout ¶ 

func (n NullConfiguration) GetAPITimeout() (time.Duration, bool)

func (NullConfiguration) GetAllUsernames ¶ 

func (n NullConfiguration) GetAllUsernames() (NormalizedUsername, []NormalizedUsername, error)

func (NullConfiguration) GetAutoFork ¶ 

func (n NullConfiguration) GetAutoFork() (bool, bool)

func (NullConfiguration) GetBool ¶ 

func (n NullConfiguration) GetBool(string, bool) (bool, bool)

func (NullConfiguration) GetBoolAtPath ¶ 

func (n NullConfiguration) GetBoolAtPath(string) (bool, bool)

func (NullConfiguration) GetBundledCA ¶ 

func (n NullConfiguration) GetBundledCA(h string) string

func (NullConfiguration) GetConfigFilename ¶ 

func (n NullConfiguration) GetConfigFilename() string

func (NullConfiguration) GetDbFilename ¶ 

func (n NullConfiguration) GetDbFilename() string

func (NullConfiguration) GetDebug ¶ 

func (n NullConfiguration) GetDebug() (bool, bool)

func (NullConfiguration) GetDeviceID ¶ 

func (n NullConfiguration) GetDeviceID() keybase1.DeviceID

func (NullConfiguration) GetEmail ¶ 

func (n NullConfiguration) GetEmail() string

func (NullConfiguration) GetGString ¶ 

func (n NullConfiguration) GetGString(string) string

func (NullConfiguration) GetGpg ¶ 

func (n NullConfiguration) GetGpg() string

func (NullConfiguration) GetGpgHome ¶ 

func (n NullConfiguration) GetGpgHome() string

func (NullConfiguration) GetGpgOptions ¶ 

func (n NullConfiguration) GetGpgOptions() []string

func (NullConfiguration) GetHome ¶ 

func (n NullConfiguration) GetHome() string

func (NullConfiguration) GetIntAtPath ¶ 

func (n NullConfiguration) GetIntAtPath(string) (int, bool)

func (NullConfiguration) GetLocalRPCDebug ¶ 

func (n NullConfiguration) GetLocalRPCDebug() string

func (NullConfiguration) GetLogFile ¶ 

func (n NullConfiguration) GetLogFile() string

func (NullConfiguration) GetLogFormat ¶ 

func (n NullConfiguration) GetLogFormat() string

func (NullConfiguration) GetMerkleKIDs ¶ 

func (n NullConfiguration) GetMerkleKIDs() []string

func (NullConfiguration) GetNoAutoFork ¶ 

func (n NullConfiguration) GetNoAutoFork() (bool, bool)

func (NullConfiguration) GetNoPinentry ¶ 

func (n NullConfiguration) GetNoPinentry() (bool, bool)

func (NullConfiguration) GetNullAtPath ¶ 

func (n NullConfiguration) GetNullAtPath(string) bool

func (NullConfiguration) GetPGPFingerprint ¶ 

func (n NullConfiguration) GetPGPFingerprint() *PGPFingerprint

func (NullConfiguration) GetPidFile ¶ 

func (n NullConfiguration) GetPidFile() string

func (NullConfiguration) GetPinentry ¶ 

func (n NullConfiguration) GetPinentry() string

func (NullConfiguration) GetProofCacheLongDur ¶ 

func (n NullConfiguration) GetProofCacheLongDur() (time.Duration, bool)

func (NullConfiguration) GetProofCacheMediumDur ¶ 

func (n NullConfiguration) GetProofCacheMediumDur() (time.Duration, bool)

func (NullConfiguration) GetProofCacheShortDur ¶ 

func (n NullConfiguration) GetProofCacheShortDur() (time.Duration, bool)

func (NullConfiguration) GetProofCacheSize ¶ 

func (n NullConfiguration) GetProofCacheSize() (int, bool)

func (NullConfiguration) GetProxy ¶ 

func (n NullConfiguration) GetProxy() string

func (NullConfiguration) GetProxyCACerts ¶ 

func (n NullConfiguration) GetProxyCACerts() ([]string, error)

func (NullConfiguration) GetRunMode ¶ 

func (n NullConfiguration) GetRunMode() (RunMode, error)

func (NullConfiguration) GetSalt ¶ 

func (n NullConfiguration) GetSalt() []byte

func (NullConfiguration) GetScraperTimeout ¶ 

func (n NullConfiguration) GetScraperTimeout() (time.Duration, bool)

func (NullConfiguration) GetSecretKeyringTemplate ¶ 

func (n NullConfiguration) GetSecretKeyringTemplate() string

func (NullConfiguration) GetSecurityAccessGroupOverride ¶ 

func (n NullConfiguration) GetSecurityAccessGroupOverride() (bool, bool)

func (NullConfiguration) GetServerURI ¶ 

func (n NullConfiguration) GetServerURI() string

func (NullConfiguration) GetSessionFilename ¶ 

func (n NullConfiguration) GetSessionFilename() string

func (NullConfiguration) GetSocketFile ¶ 

func (n NullConfiguration) GetSocketFile() string

func (NullConfiguration) GetSplitLogOutput ¶ 

func (n NullConfiguration) GetSplitLogOutput() (bool, bool)

func (NullConfiguration) GetStandalone ¶ 

func (n NullConfiguration) GetStandalone() (bool, bool)

func (NullConfiguration) GetString ¶ 

func (n NullConfiguration) GetString(string) string

func (NullConfiguration) GetStringAtPath ¶ 

func (n NullConfiguration) GetStringAtPath(string) (string, bool)

func (NullConfiguration) GetTimers ¶ 

func (n NullConfiguration) GetTimers() string

func (NullConfiguration) GetTorHiddenAddress ¶ 

func (n NullConfiguration) GetTorHiddenAddress() string

func (NullConfiguration) GetTorMode ¶ 

func (n NullConfiguration) GetTorMode() (TorMode, error)

func (NullConfiguration) GetTorProxy ¶ 

func (n NullConfiguration) GetTorProxy() string

func (NullConfiguration) GetUID ¶ 

func (n NullConfiguration) GetUID() (ret keybase1.UID)

func (NullConfiguration) GetUserCacheMaxAge ¶ 

func (n NullConfiguration) GetUserCacheMaxAge() (time.Duration, bool)

func (NullConfiguration) GetUserConfig ¶ 

func (n NullConfiguration) GetUserConfig() (*UserConfig, error)

func (NullConfiguration) GetUserConfigForUsername ¶ 

func (n NullConfiguration) GetUserConfigForUsername(s NormalizedUsername) (*UserConfig, error)

func (NullConfiguration) GetUsername ¶ 

func (n NullConfiguration) GetUsername() NormalizedUsername

type ObjType ¶ 

type ObjType byte

type PGPFingerprint ¶ 

type PGPFingerprint [PGPFingerprintLen]byte

func GetPGPFingerprint ¶ 

func GetPGPFingerprint(w *jsonw.Wrapper) (*PGPFingerprint, error)

func ImportPGPFingerprintSlice ¶ 

func ImportPGPFingerprintSlice(fp []byte) (ret *PGPFingerprint)

func PGPFingerprintFromHex ¶ 

func PGPFingerprintFromHex(s string) (*PGPFingerprint, error)

func PGPFingerprintFromHexNoError ¶ 

func PGPFingerprintFromHexNoError(s string) *PGPFingerprint

func (PGPFingerprint) Eq ¶ 

func (p PGPFingerprint) Eq(p2 PGPFingerprint) bool

func (PGPFingerprint) GetProofState ¶ 

func (p PGPFingerprint) GetProofState() keybase1.ProofState

func (PGPFingerprint) LastWriterWins ¶ 

func (p PGPFingerprint) LastWriterWins() bool

func (*PGPFingerprint) Match ¶ 

func (p *PGPFingerprint) Match(q string, exact bool) bool

func (PGPFingerprint) String ¶ 

func (p PGPFingerprint) String() string

func (PGPFingerprint) ToDisplayString ¶ 

func (p PGPFingerprint) ToDisplayString(verbose bool) string

func (PGPFingerprint) ToIDString ¶ 

func (p PGPFingerprint) ToIDString() string

func (PGPFingerprint) ToKeyID ¶ 

func (p PGPFingerprint) ToKeyID() string

func (PGPFingerprint) ToKeyValuePair ¶ 

func (p PGPFingerprint) ToKeyValuePair() (string, string)

func (PGPFingerprint) ToQuads ¶ 

func (p PGPFingerprint) ToQuads() string

type PGPGenArg ¶ 

type PGPGenArg struct {
	PrimaryBits     int
	SubkeyBits      int
	Ids             Identities
	Config          *packet.Config
	PGPUids         []string
	NoDefPGPUid     bool
	PrimaryLifetime int
	SubkeyLifetime  int
}

func ImportKeyGenArg ¶ 

func ImportKeyGenArg(a keybase1.PGPKeyGenArg) (ret PGPGenArg)

func (*PGPGenArg) AddDefaultUID ¶ 

func (a *PGPGenArg) AddDefaultUID()

func (*PGPGenArg) CreatePGPIDs ¶ 

func (a *PGPGenArg) CreatePGPIDs() error

CreateIDs creates identities for KeyGenArg.Ids if none exist. It uses PGPUids to determine the set of Ids. It does not set the default keybase.io uid. AddDefaultUid() does that.

func (PGPGenArg) ExportTo ¶ 

func (a PGPGenArg) ExportTo(ret *keybase1.PGPKeyGenArg)

func (*PGPGenArg) Init ¶ 

func (a *PGPGenArg) Init() (err error)

func (*PGPGenArg) MakeAllIds ¶ 

func (a *PGPGenArg) MakeAllIds() error

func (*PGPGenArg) PGPUserIDs ¶ 

func (a *PGPGenArg) PGPUserIDs() ([]*packet.UserId, error)

func (*PGPGenArg) PreferredCompression ¶ 

func (a *PGPGenArg) PreferredCompression() []uint8

func (*PGPGenArg) PreferredHash ¶ 

func (a *PGPGenArg) PreferredHash() []uint8

func (*PGPGenArg) PreferredSymmetric ¶ 

func (a *PGPGenArg) PreferredSymmetric() []uint8

type PGPKeyBundle ¶ 

type PGPKeyBundle struct {
	*openpgp.Entity

	// We make the (fairly dangerous) assumption that the key will never be
	// modified. This avoids the issue that encoding an openpgp.Entity is
	// nondeterministic due to Go's randomized iteration order (so different
	// exports of the same key may hash differently).
	//
	// If you're *sure* that you're creating a PGPKeyBundle from an armored
	// *public* key, you can prefill this field and Export() will use it.
	ArmoredPublicKey string
}

func GeneratePGPKeyBundle ¶ 

func GeneratePGPKeyBundle(arg PGPGenArg, logUI LogUI) (*PGPKeyBundle, error)

NewEntity returns an Entity that contains a fresh RSA/RSA keypair with a single identity composed of the given full name, comment and email, any of which may be empty but must not contain any of "()<>\x00". If config is nil, sensible defaults will be used.

Modification of: https://code.google.com/p/go/source/browse/openpgp/keys.go?repo=crypto&r=8fec09c61d5d66f460d227fd1df3473d7e015bc6#456 

From golang.com/x/crypto/openpgp/keys.go

func GetOneKey ¶ 

func GetOneKey(jw *jsonw.Wrapper) (*PGPKeyBundle, error)

func LoadPGPKeyFromLocalDB ¶ 

func LoadPGPKeyFromLocalDB(k keybase1.KID, g *GlobalContext) (*PGPKeyBundle, error)

func NewPGPKeyBundle ¶ 

func NewPGPKeyBundle(entity *openpgp.Entity) *PGPKeyBundle

func ReadOneKeyFromBytes ¶ 

func ReadOneKeyFromBytes(b []byte) (*PGPKeyBundle, error)

func ReadOneKeyFromString ¶ 

func ReadOneKeyFromString(s string) (*PGPKeyBundle, error)

note: openpgp.ReadArmoredKeyRing only returns the first block. It will never return multiple entities.

func ReadPrivateKeyFromString ¶ 

func ReadPrivateKeyFromString(s string) (*PGPKeyBundle, error)

ReadPrivateKeyFromString finds the first private key block in s and decodes it into a PGPKeyBundle. It is useful in the case where s contains multiple key blocks and you want the private key block. For example, the result of gpg export.

func (*PGPKeyBundle) CanDecrypt ¶ 

func (k *PGPKeyBundle) CanDecrypt() bool

CanDecrypt returns false for now, since we haven't implemented PGP encryption of packets for metadata operations

func (*PGPKeyBundle) CanEncrypt ¶ 

func (k *PGPKeyBundle) CanEncrypt() bool

CanEncrypt returns false for now, since we haven't implemented PGP encryption of packets for metadata operations

func (*PGPKeyBundle) CanSign ¶ 

func (k *PGPKeyBundle) CanSign() bool

func (*PGPKeyBundle) CheckFingerprint ¶ 

func (k *PGPKeyBundle) CheckFingerprint(fp *PGPFingerprint) error

func (*PGPKeyBundle) CheckIdentity ¶ 

func (k *PGPKeyBundle) CheckIdentity(kbid Identity) (match bool, ctime int64, etime int64)

func (*PGPKeyBundle) CheckSecretKey ¶ 

func (k *PGPKeyBundle) CheckSecretKey() (err error)

func (*PGPKeyBundle) DecryptFromString ¶ 

func (k *PGPKeyBundle) DecryptFromString(ciphertext string) (msg []byte, sender keybase1.KID, err error)

DecryptFromString fails for this type of key, since we haven't implemented it yet

func (PGPKeyBundle) DecryptionKeys ¶ 

func (k PGPKeyBundle) DecryptionKeys() []openpgp.Key

func (*PGPKeyBundle) Encode ¶ 

func (k *PGPKeyBundle) Encode() (ret string, err error)

func (*PGPKeyBundle) EncodeToStream ¶ 

func (k *PGPKeyBundle) EncodeToStream(wc io.WriteCloser) (err error)

func (*PGPKeyBundle) EncryptToString ¶ 

func (k *PGPKeyBundle) EncryptToString(plaintext []byte, sender GenericKey) (ciphertext string, err error)

EncryptToString fails for this type of key, since we haven't implemented it yet

func (*PGPKeyBundle) Export ¶ 

func (bundle *PGPKeyBundle) Export() keybase1.PublicKey

func (*PGPKeyBundle) FindEmail ¶ 

func (k *PGPKeyBundle) FindEmail(em string) bool

func (*PGPKeyBundle) FindKeybaseUsername ¶ 

func (k *PGPKeyBundle) FindKeybaseUsername(un string) bool

XXX for now this is OK but probably we need a PGP uid parser as in pgp-utils

func (*PGPKeyBundle) FullHash ¶ 

func (k *PGPKeyBundle) FullHash() (string, error)

func (PGPKeyBundle) GetAlgoType ¶ 

func (k PGPKeyBundle) GetAlgoType() AlgoType

func (PGPKeyBundle) GetFingerprint ¶ 

func (k PGPKeyBundle) GetFingerprint() PGPFingerprint

func (PGPKeyBundle) GetFingerprintP ¶ 

func (k PGPKeyBundle) GetFingerprintP() *PGPFingerprint

func (*PGPKeyBundle) GetKID ¶ 

func (k *PGPKeyBundle) GetKID() keybase1.KID

func (*PGPKeyBundle) GetPGPIdentities ¶ 

func (k *PGPKeyBundle) GetPGPIdentities() []keybase1.PGPIdentity

func (PGPKeyBundle) GetPrimaryUID ¶ 

func (k PGPKeyBundle) GetPrimaryUID() string

GetPrimaryUID gets the primary UID in the given key bundle, returned in the 'Max K (foo) <bar@baz.com>' convention.

func (*PGPKeyBundle) HasSecretKey ¶ 

func (k *PGPKeyBundle) HasSecretKey() bool

func (PGPKeyBundle) HumanDescription ¶ 

func (k PGPKeyBundle) HumanDescription() string

func (*PGPKeyBundle) IdentityNames ¶ 

func (k *PGPKeyBundle) IdentityNames() []string

func (PGPKeyBundle) KeyDescription ¶ 

func (k PGPKeyBundle) KeyDescription() string

func (PGPKeyBundle) KeyInfo ¶ 

func (k PGPKeyBundle) KeyInfo() (algorithm, kid, creation string)

func (PGPKeyBundle) KeysById ¶ 

func (k PGPKeyBundle) KeysById(id uint64) []openpgp.Key

func (PGPKeyBundle) KeysByIdUsage ¶ 

func (k PGPKeyBundle) KeysByIdUsage(id uint64, usage byte) []openpgp.Key

func (PGPKeyBundle) MatchesKey ¶ 

func (k PGPKeyBundle) MatchesKey(key *openpgp.Key) bool

func (*PGPKeyBundle) MergeKey ¶ 

func (to *PGPKeyBundle) MergeKey(from *PGPKeyBundle)

MergeKey adds the identities, revocations, and subkeys of another PGPKeyBundle to this key

func (*PGPKeyBundle) SignToString ¶ 

func (k *PGPKeyBundle) SignToString(msg []byte) (sig string, id keybase1.SigID, err error)

func (*PGPKeyBundle) StoreToLocalDb ¶ 

func (k *PGPKeyBundle) StoreToLocalDb(g *GlobalContext) error

func (*PGPKeyBundle) StripRevocations ¶ 

func (k *PGPKeyBundle) StripRevocations() (strippedKey *PGPKeyBundle)

StripRevocations returns a copy of the key with revocations removed

func (*PGPKeyBundle) ToLksSKB ¶ 

func (key *PGPKeyBundle) ToLksSKB(lks *LKSec) (ret *SKB, err error)

func (*PGPKeyBundle) ToServerSKB ¶ 

func (key *PGPKeyBundle) ToServerSKB(gc *GlobalContext, tsec *triplesec.Cipher, gen PassphraseGeneration) (ret *SKB, err error)

func (*PGPKeyBundle) Unlock ¶ 

func (k *PGPKeyBundle) Unlock(reason string, secretUI SecretUI) error

func (PGPKeyBundle) UsersDescription ¶ 

func (k PGPKeyBundle) UsersDescription() []string

func (PGPKeyBundle) VerboseDescription ¶ 

func (k PGPKeyBundle) VerboseDescription() string

func (PGPKeyBundle) VerifyString ¶ 

func (k PGPKeyBundle) VerifyString(sig string, msg []byte) (id keybase1.SigID, err error)

func (PGPKeyBundle) VerifyStringAndExtract ¶ 

func (k PGPKeyBundle) VerifyStringAndExtract(sig string) (msg []byte, id keybase1.SigID, err error)

type PGPKeySet ¶ 

type PGPKeySet struct {
	PermissivelyMergedKey *PGPKeyBundle
	KeysByHash            map[string]*PGPKeyBundle
}

PGPKeySet represents a collection of versions of a PGP key. It includes a merged version of the key without revocations, and each individual version of the key with revocations intact.

type PGPNoDecryptionKeyError ¶ 

type PGPNoDecryptionKeyError struct {
	Msg string
}

func (PGPNoDecryptionKeyError) Error ¶ 

func (e PGPNoDecryptionKeyError) Error() string

func (PGPNoDecryptionKeyError) ToStatus ¶ 

func (e PGPNoDecryptionKeyError) ToStatus() (s keybase1.Status)

type PGPPullLoggedOutError ¶ 

type PGPPullLoggedOutError struct{}

func (PGPPullLoggedOutError) Error ¶ 

func (e PGPPullLoggedOutError) Error() string
type PGPUpdateChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}

PGPUpdateChainLink represents a chain link which marks a new version of a PGP key as current. The KID and a new new full hash are included in the pgp_update section of the body. 

func ParsePGPUpdateChainLink(b GenericChainLink) (ret *PGPUpdateChainLink, err error)

ParsePGPUpdateChainLink creates a PGPUpdateChainLink from a GenericChainLink and verifies that its pgp_update section contains a KID and full_hash

func (*PGPUpdateChainLink) GetPGPFullHash ¶ 

func (l *PGPUpdateChainLink) GetPGPFullHash() string

func (*PGPUpdateChainLink) ToDisplayString ¶ 

func (l *PGPUpdateChainLink) ToDisplayString() string

func (*PGPUpdateChainLink) Type ¶ 

func (l *PGPUpdateChainLink) Type() string

type PIDFileLockError ¶ 

type PIDFileLockError struct {
	Filename string
}

func (PIDFileLockError) Error ¶ 

func (e PIDFileLockError) Error() string

type Packetable ¶ 

type Packetable interface {
	ToPacket() (*KeybasePacket, error)
}

type PaperKeyPhrase ¶ 

type PaperKeyPhrase string

PaperKeyPhrase is the string that can generate a paper key. It is versioned and forced to be lowercase. To make a new random phrase, use MakePaperKeyPhrase. To convert a string to a PaperKeyPhrase, use NewPaperKeyPhrase.

func MakePaperKeyPhrase ¶ 

func MakePaperKeyPhrase(version uint8) (PaperKeyPhrase, error)

MakePaperKeyPhrase creates a new, random paper key phrase for the given version.

func NewPaperKeyPhrase ¶ 

func NewPaperKeyPhrase(phrase string) PaperKeyPhrase

NewPaperKeyPhrase converts a string into a PaperKeyPhrase.

func (PaperKeyPhrase) Bytes ¶ 

func (p PaperKeyPhrase) Bytes() []byte

Bytes returns a byte slice of the phrase.

func (PaperKeyPhrase) Prefix ¶ 

func (p PaperKeyPhrase) Prefix() string

Prefix returns the first two words in the phrase.

func (PaperKeyPhrase) String ¶ 

func (p PaperKeyPhrase) String() string

String returns a string representation of the phrase.

func (PaperKeyPhrase) Version ¶ 

func (p PaperKeyPhrase) Version() uint8

Version calculates the phrase version. 0-15 are possible versions.

type ParsedSig ¶ 

type ParsedSig struct {
	Block       *armor.Block
	SigBody     []byte
	MD          *openpgp.MessageDetails
	LiteralData []byte
}

func PGPOpenSig ¶ 

func PGPOpenSig(armored string) (ps *ParsedSig, err error)

func (*ParsedSig) AssertPayload ¶ 

func (ps *ParsedSig) AssertPayload(expected []byte) error

func (*ParsedSig) ID ¶ 

func (ps *ParsedSig) ID() keybase1.SigID

func (*ParsedSig) Verify ¶ 

func (ps *ParsedSig) Verify(k PGPKeyBundle) (err error)

type Parser ¶ 

type Parser struct {
	// contains filtered or unexported fields
}

func NewParser ¶ 

func NewParser(lexer *Lexer) *Parser

func (*Parser) Parse ¶ 

func (p *Parser) Parse() AssertionExpression

type PassphraseError ¶ 

type PassphraseError struct {
	Msg string
}

func (PassphraseError) Error ¶ 

func (p PassphraseError) Error() string

func (PassphraseError) ToStatus ¶ 

func (p PassphraseError) ToStatus() (s keybase1.Status)

type PassphraseGeneration ¶ 

type PassphraseGeneration int

PassphraseGeneration represents which generation of the passphrase is currently in use. It's used to guard against race conditions in which the passphrase is changed on one device which the other still has it cached.

type PassphraseProvisionImpossibleError ¶ 

type PassphraseProvisionImpossibleError struct{}

func (PassphraseProvisionImpossibleError) Error ¶ 

func (e PassphraseProvisionImpossibleError) Error() string

type PassphraseStream ¶ 

type PassphraseStream struct {
	// contains filtered or unexported fields
}

func NewPassphraseStream ¶ 

func NewPassphraseStream(s []byte) *PassphraseStream

func StretchPassphrase ¶ 

func StretchPassphrase(passphrase string, salt []byte) (tsec *triplesec.Cipher, pps *PassphraseStream, err error)

func (*PassphraseStream) Clone ¶ 

func (ps *PassphraseStream) Clone() *PassphraseStream

Clone a passphrase stream and return a copy.

func (PassphraseStream) DHSeed ¶ 

func (ps PassphraseStream) DHSeed() []byte

func (PassphraseStream) EdDSASeed ¶ 

func (ps PassphraseStream) EdDSASeed() []byte

func (PassphraseStream) Export ¶ 

func (ps PassphraseStream) Export() keybase1.PassphraseStream

func (PassphraseStream) Generation ¶ 

func (ps PassphraseStream) Generation() PassphraseGeneration

Generation returns the generation of this passphrase stream. It is >=0 for valid generation #. If 0, then we assume the passphrase has never been reset.

func (PassphraseStream) LksClientHalf ¶ 

func (ps PassphraseStream) LksClientHalf() []byte

func (PassphraseStream) PWHash ¶ 

func (ps PassphraseStream) PWHash() []byte

func (*PassphraseStream) SetGeneration ¶ 

func (ps *PassphraseStream) SetGeneration(gen PassphraseGeneration)

func (PassphraseStream) String ¶ 

func (ps PassphraseStream) String() string

type PassphraseStreamCache ¶ 

type PassphraseStreamCache struct {
	// contains filtered or unexported fields
}

func NewPassphraseStreamCache ¶ 

func NewPassphraseStreamCache(tsec *triplesec.Cipher, ps *PassphraseStream) *PassphraseStreamCache

func (*PassphraseStreamCache) Clear ¶ 

func (s *PassphraseStreamCache) Clear()

func (*PassphraseStreamCache) Dump ¶ 

func (s *PassphraseStreamCache) Dump()

func (*PassphraseStreamCache) PassphraseStream ¶ 

func (s *PassphraseStreamCache) PassphraseStream() *PassphraseStream

PassphraseStream returns a copy of the currently cached passphrase stream, or nil if none exists.

func (*PassphraseStreamCache) PassphraseStreamRef ¶ 

func (s *PassphraseStreamCache) PassphraseStreamRef() *PassphraseStream

PassphraseStream returns a reference to the currently cached passphrase stream, or nil if none exists.

func (*PassphraseStreamCache) Triplesec ¶ 

func (s *PassphraseStreamCache) Triplesec() *triplesec.Cipher

func (*PassphraseStreamCache) Valid ¶ 

func (s *PassphraseStreamCache) Valid() bool

type PassphraseStreamCacheReader ¶ 

type PassphraseStreamCacheReader interface {
	Triplesec() *triplesec.Cipher
	PassphraseStream() *PassphraseStream
	Valid() bool
}

type PathStep ¶ 

type PathStep struct {
	// contains filtered or unexported fields
}

type PathSteps ¶ 

type PathSteps []*PathStep

func (PathSteps) VerifyPath ¶ 

func (path PathSteps) VerifyPath(curr NodeHash, uidS string) (juser *jsonw.Wrapper, err error)

type Peeker ¶ 

type Peeker struct {
	// contains filtered or unexported fields
}

func NewPeeker ¶ 

func NewPeeker(r io.Reader) *Peeker

func (*Peeker) Peek ¶ 

func (p *Peeker) Peek(d []byte) (int, error)

func (*Peeker) Read ¶ 

func (p *Peeker) Read(d []byte) (int, error)

type PostAuthProofArg ¶ 

type PostAuthProofArg struct {
	// contains filtered or unexported fields
}

type PostAuthProofRes ¶ 

type PostAuthProofRes struct {
	SessionID string `json:"session"`
	AuthID    string `json:"auth_id"`
	CSRFToken string `json:"csrf_token"`
	UIDHex    string `json:"uid"`
	Username  string `json:"username"`
	PPGen     int    `json:"passphrase_generation"`
}

func PostAuthProof ¶ 

func PostAuthProof(arg PostAuthProofArg) (*PostAuthProofRes, error)

type PostProofArg ¶ 

type PostProofArg struct {
	Sig            string
	ID             keybase1.SigID
	RemoteUsername string
	ProofType      string
	Supersede      bool
	RemoteKey      string
	SigningKey     GenericKey
}

type PostProofRes ¶ 

type PostProofRes struct {
	Text     string
	ID       string
	Metadata *jsonw.Wrapper
}

func PostProof ¶ 

func PostProof(arg PostProofArg) (*PostProofRes, error)

type PromptArg ¶ 

type PromptArg struct {
	TerminalPrompt string
	PinentryDesc   string
	PinentryPrompt string
	Checker        *Checker
	RetryMessage   string
	UseSecretStore bool
}

type PromptDefault ¶ 

type PromptDefault int
const (
	PromptDefaultNo PromptDefault = iota
	PromptDefaultYes
	PromptDefaultNeither
)

type PromptDescriptor ¶ 

type PromptDescriptor int

type Proof ¶ 

type Proof struct {
	Key, Value string
}

type ProofAPIError ¶ 

type ProofAPIError struct {
	ProofErrorImpl
	// contains filtered or unexported fields
}

func NewProofAPIError ¶ 

func NewProofAPIError(s keybase1.ProofStatus, u string, d string, a ...interface{}) *ProofAPIError

func XapiError ¶ 

func XapiError(err error, u string) *ProofAPIError

type ProofCache ¶ 

type ProofCache struct {
	Contextified

	sync.RWMutex
	// contains filtered or unexported fields
}

func NewProofCache ¶ 

func NewProofCache(g *GlobalContext, capac int) *ProofCache

func (*ProofCache) Get ¶ 

func (pc *ProofCache) Get(sid keybase1.SigID) *CheckResult

func (*ProofCache) Put ¶ 

func (pc *ProofCache) Put(sid keybase1.SigID, pe ProofError) error

type ProofCheckHook ¶ 

type ProofCheckHook func(l RemoteProofChainLink) (ProofChecker, ProofError)

type ProofChecker ¶ 

type ProofChecker interface {
	CheckHint(h SigHint) ProofError
	CheckStatus(h SigHint) ProofError
	GetTorError() ProofError
}

type ProofError ¶ 

type ProofError interface {
	error
	GetProofStatus() keybase1.ProofStatus
	GetDesc() string
}

func ImportProofError ¶ 

func ImportProofError(e keybase1.ProofResult) ProofError

type ProofErrorImpl ¶ 

type ProofErrorImpl struct {
	Status keybase1.ProofStatus
	Desc   string
}

func NewProofError ¶ 

func NewProofError(s keybase1.ProofStatus, d string, a ...interface{}) *ProofErrorImpl

func (*ProofErrorImpl) Error ¶ 

func (e *ProofErrorImpl) Error() string

func (*ProofErrorImpl) GetDesc ¶ 

func (e *ProofErrorImpl) GetDesc() string

func (*ProofErrorImpl) GetProofStatus ¶ 

func (e *ProofErrorImpl) GetProofStatus() keybase1.ProofStatus

type ProofLinkWithState ¶ 

type ProofLinkWithState struct {
	// contains filtered or unexported fields
}

ProofLinkWithState contains a RemoteProofChainLink and the proof state. In addition, it satisfies the TrackIdComponent interface.

func (ProofLinkWithState) GetProofState ¶ 

func (p ProofLinkWithState) GetProofState() keybase1.ProofState

func (ProofLinkWithState) LastWriterWins ¶ 

func (p ProofLinkWithState) LastWriterWins() bool

func (ProofLinkWithState) ToIDString ¶ 

func (p ProofLinkWithState) ToIDString() string

func (ProofLinkWithState) ToKeyValuePair ¶ 

func (p ProofLinkWithState) ToKeyValuePair() (string, string)

type ProofMetadata ¶ 

type ProofMetadata struct {
	Me             *User
	SigningUser    UserBasic
	LastSeqno      Seqno
	PrevLinkID     LinkID
	LinkType       LinkType
	SigningKey     GenericKey
	Eldest         keybase1.KID
	CreationTime   int64
	ExpireIn       int
	IncludePGPHash bool
}

func (ProofMetadata) ToJSON ¶ 

func (arg ProofMetadata) ToJSON(g *GlobalContext) (ret *jsonw.Wrapper, err error)

type ProofNotFoundForServiceError ¶ 

type ProofNotFoundForServiceError struct {
	Service string
}

func (ProofNotFoundForServiceError) Error ¶ 

func (e ProofNotFoundForServiceError) Error() string

func (ProofNotFoundForServiceError) ToStatus ¶ 

func (e ProofNotFoundForServiceError) ToStatus() (s keybase1.Status)

type ProofNotFoundForUsernameError ¶ 

type ProofNotFoundForUsernameError struct {
	Service  string
	Username string
}

func (ProofNotFoundForUsernameError) Error ¶ 

func (e ProofNotFoundForUsernameError) Error() string

func (ProofNotFoundForUsernameError) ToStatus ¶ 

func (e ProofNotFoundForUsernameError) ToStatus() (s keybase1.Status)

type ProofNotYetAvailableError ¶ 

type ProofNotYetAvailableError struct{}

func (ProofNotYetAvailableError) Error ¶ 

func (e ProofNotYetAvailableError) Error() string

type ProofSet ¶ 

type ProofSet struct {
	// contains filtered or unexported fields
}

func NewProofSet ¶ 

func NewProofSet(proofs []Proof) *ProofSet

func (*ProofSet) Add ¶ 

func (ps *ProofSet) Add(p Proof)

func (ProofSet) Get ¶ 

func (ps ProofSet) Get(keys []string) (ret []Proof)

type ProtocolDowngradeError ¶ 

type ProtocolDowngradeError struct {
	// contains filtered or unexported fields
}

func (ProtocolDowngradeError) Error ¶ 

func (h ProtocolDowngradeError) Error() string

type ProveUI ¶ 

type ProveUI interface {
	PromptOverwrite(context.Context, keybase1.PromptOverwriteArg) (bool, error)
	PromptUsername(context.Context, keybase1.PromptUsernameArg) (string, error)
	OutputPrechecks(context.Context, keybase1.OutputPrechecksArg) error
	PreProofWarning(context.Context, keybase1.PreProofWarningArg) (bool, error)
	OutputInstructions(context.Context, keybase1.OutputInstructionsArg) error
	OkToCheck(context.Context, keybase1.OkToCheckArg) (bool, error)
	DisplayRecheckWarning(context.Context, keybase1.DisplayRecheckWarningArg) error
}

type ProvisionUI ¶ 

type ProvisionUI interface {
	keybase1.ProvisionUiInterface
}

type PublicKeyList ¶ 

type PublicKeyList []keybase1.PublicKey

func (PublicKeyList) Len ¶ 

func (l PublicKeyList) Len() int

func (PublicKeyList) Less ¶ 

func (l PublicKeyList) Less(i, j int) bool

func (PublicKeyList) Swap ¶ 

func (l PublicKeyList) Swap(i, j int)

type RPCLogFactory ¶ 

type RPCLogFactory struct{}

func NewRPCLogFactory ¶ 

func NewRPCLogFactory() *RPCLogFactory

func (*RPCLogFactory) NewLog ¶ 

func (r *RPCLogFactory) NewLog(a net.Addr) rpc.LogInterface

type RPCLogOptions ¶ 

type RPCLogOptions struct {
	// contains filtered or unexported fields
}

func (*RPCLogOptions) ClientTrace ¶ 

func (r *RPCLogOptions) ClientTrace() bool

func (*RPCLogOptions) Profile ¶ 

func (r *RPCLogOptions) Profile() bool

func (*RPCLogOptions) Reload ¶ 

func (r *RPCLogOptions) Reload()

func (*RPCLogOptions) ServerTrace ¶ 

func (r *RPCLogOptions) ServerTrace() bool

func (*RPCLogOptions) ShowAddress ¶ 

func (r *RPCLogOptions) ShowAddress() bool

func (*RPCLogOptions) ShowArg ¶ 

func (r *RPCLogOptions) ShowArg() bool

func (*RPCLogOptions) ShowResult ¶ 

func (r *RPCLogOptions) ShowResult() bool

func (*RPCLogOptions) TransportStart ¶ 

func (r *RPCLogOptions) TransportStart() bool

type RawKeyFamily ¶ 

type RawKeyFamily struct {
	AllBundles []string `json:"all_bundles"`
}

As returned by user/lookup.json

type ReadCloser ¶ 

type ReadCloser struct {
	// contains filtered or unexported fields
}

type ReceiverDeviceError ¶ 

type ReceiverDeviceError struct {
	Msg string
}

func NewReceiverDeviceError ¶ 

func NewReceiverDeviceError(expected, received keybase1.DeviceID) ReceiverDeviceError

func (ReceiverDeviceError) Error ¶ 

func (e ReceiverDeviceError) Error() string

func (ReceiverDeviceError) ToStatus ¶ 

func (e ReceiverDeviceError) ToStatus() keybase1.Status

type RedditChecker ¶ 

type RedditChecker struct {
	// contains filtered or unexported fields
}

func (*RedditChecker) CheckData ¶ 

func (rc *RedditChecker) CheckData(h SigHint, dat *jsonw.Wrapper) ProofError

func (*RedditChecker) CheckHint ¶ 

func (rc *RedditChecker) CheckHint(h SigHint) ProofError

func (*RedditChecker) CheckStatus ¶ 

func (rc *RedditChecker) CheckStatus(h SigHint) ProofError

func (*RedditChecker) GetTorError ¶ 

func (rc *RedditChecker) GetTorError() ProofError

func (*RedditChecker) ScreenNameCompare ¶ 

func (rc *RedditChecker) ScreenNameCompare(s1, s2 string) bool

func (*RedditChecker) UnpackData ¶ 

func (rc *RedditChecker) UnpackData(inp *jsonw.Wrapper) (*jsonw.Wrapper, ProofError)

type RedditServiceType ¶ 

type RedditServiceType struct{ BaseServiceType }

func (RedditServiceType) AllStringKeys ¶ 

func (t RedditServiceType) AllStringKeys() []string

func (RedditServiceType) CheckProofText ¶ 

func (t RedditServiceType) CheckProofText(text string, id keybase1.SigID, sig string) (err error)

func (RedditServiceType) CheckUsername ¶ 

func (t RedditServiceType) CheckUsername(s string) (err error)

func (RedditServiceType) DisplayName ¶ 

func (t RedditServiceType) DisplayName(un string) string

func (RedditServiceType) FormatProofText ¶ 

func (t RedditServiceType) FormatProofText(ppr *PostProofRes) (res string, err error)

func (RedditServiceType) GetPrompt ¶ 

func (t RedditServiceType) GetPrompt() string

func (RedditServiceType) GetProofType ¶ 

func (t RedditServiceType) GetProofType() string

func (RedditServiceType) GetTypeName ¶ 

func (t RedditServiceType) GetTypeName() string

func (RedditServiceType) PostInstructions ¶ 

func (t RedditServiceType) PostInstructions(un string) *Markup

func (RedditServiceType) PrimaryStringKeys ¶ 

func (t RedditServiceType) PrimaryStringKeys() []string

func (RedditServiceType) RecheckProofPosting ¶ 

func (t RedditServiceType) RecheckProofPosting(tryNumber int, status keybase1.ProofStatus, _ string) (warning *Markup, err error)

func (RedditServiceType) ToChecker ¶ 

func (t RedditServiceType) ToChecker() Checker

func (RedditServiceType) ToServiceJSON ¶ 

func (t RedditServiceType) ToServiceJSON(un string) *jsonw.Wrapper

type ReloginRequiredError ¶ 

type ReloginRequiredError struct{}

func (ReloginRequiredError) Error ¶ 

func (e ReloginRequiredError) Error() string

func (ReloginRequiredError) ToStatus ¶ 

func (e ReloginRequiredError) ToStatus() keybase1.Status
type RemoteProofChainLink interface {
	TypedChainLink
	TableKey() string
	LastWriterWins() bool
	GetRemoteUsername() string
	GetHostname() string
	GetProtocol() string
	DisplayCheck(ui IdentifyUI, lcr LinkCheckResult)
	ToTrackingStatement(keybase1.ProofState) (*jsonw.Wrapper, error)
	CheckDataJSON() *jsonw.Wrapper
	ToIDString() string
	ToKeyValuePair() (string, string)
	ComputeTrackDiff(tl *TrackLookup) TrackDiff
	GetProofType() keybase1.ProofType
	ProofText() string
}

========================================================================= Remote, Web and Social

func ParseWebServiceBinding ¶ 

func ParseWebServiceBinding(base GenericChainLink) (ret RemoteProofChainLink, e error)

To be used for signatures in a user's signature chain. 

type RemoteProofLinks struct {
	// contains filtered or unexported fields
}

RemoteProofLinks holds a set of RemoteProofChainLinks, organized by service. 

func NewRemoteProofLinks() *RemoteProofLinks

NewRemoteProofLinks creates a new empty collection of proof links.

func (*RemoteProofLinks) Active ¶ 

func (r *RemoteProofLinks) Active() []RemoteProofChainLink

Active returns all the active proof links, deduplicating any and honoring the LastWriterWins option.

func (*RemoteProofLinks) AddProofsToSet ¶ 

func (r *RemoteProofLinks) AddProofsToSet(existing *ProofSet)

AddProofsToSet adds the active proofs to an existing ProofSet.

func (*RemoteProofLinks) ForService ¶ 

func (r *RemoteProofLinks) ForService(st ServiceType) []RemoteProofChainLink

ForService returns all the active proof links for a service.

func (*RemoteProofLinks) Insert ¶ 

func (r *RemoteProofLinks) Insert(link RemoteProofChainLink, err ProofError)

Insert adds a link to the collection of proof links.

func (*RemoteProofLinks) TrackSet ¶ 

func (r *RemoteProofLinks) TrackSet() *TrackSet

TrackSet creates a new TrackSet with all the active proofs.

func (*RemoteProofLinks) TrackingStatement ¶ 

func (r *RemoteProofLinks) TrackingStatement() *jsonw.Wrapper

TrackingStatement generates the remote proofs portions of the tracking statement from the active proofs.

type RemoteStream ¶ 

type RemoteStream struct {
	Stream    keybase1.Stream
	Cli       *keybase1.StreamUiClient
	SessionID int
}

func (RemoteStream) Close ¶ 

func (ewc RemoteStream) Close() (err error)

func (RemoteStream) Read ¶ 

func (ewc RemoteStream) Read(buf []byte) (n int, err error)

func (RemoteStream) Write ¶ 

func (ewc RemoteStream) Write(buf []byte) (n int, err error)

type RemoteStreamBuffered ¶ 

type RemoteStreamBuffered struct {
	// contains filtered or unexported fields
}

func NewRemoteStreamBuffered ¶ 

func NewRemoteStreamBuffered(s keybase1.Stream, c *keybase1.StreamUiClient, sessionID int) *RemoteStreamBuffered

func (*RemoteStreamBuffered) Close ¶ 

func (x *RemoteStreamBuffered) Close() error

func (*RemoteStreamBuffered) Read ¶ 

func (x *RemoteStreamBuffered) Read(p []byte) (int, error)

func (*RemoteStreamBuffered) Write ¶ 

func (x *RemoteStreamBuffered) Write(p []byte) (int, error)

type ReportingTimer ¶ 

type ReportingTimer interface {
	Report(prefix string)
}

ReportingTimer is an interface shared between ReportingTimerReal and ReportingTimerDummy, to allow for convenient disabling of timer features.

type ReportingTimerDummy ¶ 

type ReportingTimerDummy struct{}

ReportingTimerDummy fulfills the ReportingTimer interface but doesn't do anything when done.

func (ReportingTimerDummy) Report ¶ 

func (r ReportingTimerDummy) Report(prefix string)

Report is a noop.

type ReportingTimerReal ¶ 

type ReportingTimerReal struct {
	SimpleTimer
	Contextified
}

ReportingTimerReal is a SimpleTimer that reports after the timing measurement is done.

func NewReportingTimerReal ¶ 

func NewReportingTimerReal(ctx Contextified) *ReportingTimerReal

NewReportingTimerReal returns an initialized reporting timer that actually reports timing information.

func (*ReportingTimerReal) Report ¶ 

func (r *ReportingTimerReal) Report(prefix string)

Report stops and resets the timer, then logs to Info what the duration was.

type Requester ¶ 

type Requester interface {
	// contains filtered or unexported methods
}

Internal and External APIs both implement these methods, allowing us to share the request-making code below in doRequest

type ResolveCache ¶ 

type ResolveCache struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewResolveCache ¶ 

func NewResolveCache() *ResolveCache

func (*ResolveCache) Get ¶ 

func (c *ResolveCache) Get(key string) *ResolveResult

Get returns a ResolveResult, if present in the cache.

func (*ResolveCache) Put ¶ 

func (c *ResolveCache) Put(key string, res ResolveResult)

Put receives a copy of a ResolveResult, clears out the body to avoid caching data that can go stale, and stores the result.

type ResolveResult ¶ 

type ResolveResult struct {
	// contains filtered or unexported fields
}

func ResolveUID ¶ 

func ResolveUID(input string) (res ResolveResult)

func ResolveUIDValuePair ¶ 

func ResolveUIDValuePair(key, value string) (res ResolveResult)

func (*ResolveResult) GetError ¶ 

func (res *ResolveResult) GetError() error

func (*ResolveResult) GetUID ¶ 

func (res *ResolveResult) GetUID() keybase1.UID

type RetryExhaustedError ¶ 

type RetryExhaustedError struct {
}

func (RetryExhaustedError) Error ¶ 

func (e RetryExhaustedError) Error() string

type ReverseSigError ¶ 

type ReverseSigError struct {
	// contains filtered or unexported fields
}

func (ReverseSigError) Error ¶ 

func (r ReverseSigError) Error() string
type RevokeChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseRevokeChainLink(b GenericChainLink) (ret *RevokeChainLink, err error)

func (*RevokeChainLink) GetDevice ¶ 

func (r *RevokeChainLink) GetDevice() *Device

func (*RevokeChainLink) IsRevocationIsh ¶ 

func (r *RevokeChainLink) IsRevocationIsh() bool

func (*RevokeChainLink) ToDisplayString ¶ 

func (r *RevokeChainLink) ToDisplayString() string

func (*RevokeChainLink) Type ¶ 

func (r *RevokeChainLink) Type() string

type RooterChecker ¶ 

type RooterChecker struct {
	// contains filtered or unexported fields
}

func (*RooterChecker) CheckData ¶ 

func (rc *RooterChecker) CheckData(h SigHint, dat string) ProofError

func (*RooterChecker) CheckHint ¶ 

func (rc *RooterChecker) CheckHint(h SigHint) (err ProofError)

func (*RooterChecker) CheckStatus ¶ 

func (rc *RooterChecker) CheckStatus(h SigHint) (perr ProofError)

func (*RooterChecker) GetTorError ¶ 

func (rc *RooterChecker) GetTorError() ProofError

func (*RooterChecker) ScreenNameCompare ¶ 

func (rc *RooterChecker) ScreenNameCompare(s1, s2 string) bool

func (*RooterChecker) UnpackData ¶ 

func (rc *RooterChecker) UnpackData(inp *jsonw.Wrapper) (string, ProofError)

type RooterServiceType ¶ 

type RooterServiceType struct{ BaseServiceType }

func (RooterServiceType) AllStringKeys ¶ 

func (t RooterServiceType) AllStringKeys() []string

func (RooterServiceType) CheckProofText ¶ 

func (t RooterServiceType) CheckProofText(text string, id keybase1.SigID, sig string) (err error)

func (RooterServiceType) CheckUsername ¶ 

func (t RooterServiceType) CheckUsername(s string) (err error)

func (RooterServiceType) DisplayName ¶ 

func (t RooterServiceType) DisplayName(un string) string

func (RooterServiceType) GetPrompt ¶ 

func (t RooterServiceType) GetPrompt() string

func (RooterServiceType) GetProofType ¶ 

func (t RooterServiceType) GetProofType() string

func (RooterServiceType) GetTypeName ¶ 

func (t RooterServiceType) GetTypeName() string

func (RooterServiceType) NormalizeUsername ¶ 

func (t RooterServiceType) NormalizeUsername(s string) (string, error)

func (RooterServiceType) PostInstructions ¶ 

func (t RooterServiceType) PostInstructions(un string) *Markup

func (RooterServiceType) PrimaryStringKeys ¶ 

func (t RooterServiceType) PrimaryStringKeys() []string

func (RooterServiceType) RecheckProofPosting ¶ 

func (t RooterServiceType) RecheckProofPosting(tryNumber int, status keybase1.ProofStatus, _ string) (warning *Markup, err error)

func (RooterServiceType) ToChecker ¶ 

func (t RooterServiceType) ToChecker() Checker

func (RooterServiceType) ToServiceJSON ¶ 

func (t RooterServiceType) ToServiceJSON(un string) *jsonw.Wrapper

type RunGpg2Arg ¶ 

type RunGpg2Arg struct {
	Arguments []string
	Stdin     bool
	Stderr    bool
	Stdout    bool
}

type RunGpg2Res ¶ 

type RunGpg2Res struct {
	Stdin  io.WriteCloser
	Stdout io.ReadCloser
	Stderr io.ReadCloser
	Wait   func() error
	Err    error
}

type RunGpgArg ¶ 

type RunGpgArg struct {
	Arguments []string
	Stdin     bool
	Stderr    io.WriteCloser
	Stdout    io.WriteCloser
}

type RunGpgRes ¶ 

type RunGpgRes struct {
	Stdin io.WriteCloser
	Err   error
	Wait  func() error
}

type RunMode ¶ 

type RunMode string

func StringToRunMode ¶ 

func StringToRunMode(s string) (RunMode, error)

StringToRunMode turns a string into a run-mode

type RunModeGetter ¶ 

type RunModeGetter func() RunMode

type S ¶ 

type S struct {
	Val string
}

func B64Arg ¶ 

func B64Arg(b []byte) S

func HexArg ¶ 

func HexArg(b []byte) S

func (S) String ¶ 

func (s S) String() string

type SKB ¶ 

type SKB struct {
	Priv SKBPriv  `codec:"priv"`
	Pub  []byte   `codec:"pub"`
	Type AlgoType `codec:"type,omitempty"`

	Contextified

	sync.Mutex // currently only for uid
	// contains filtered or unexported fields
}

func NewSKB ¶ 

func NewSKB(gc *GlobalContext) *SKB

func WriteLksSKBToKeyring ¶ 

func WriteLksSKBToKeyring(k GenericKey, lks *LKSec, lctx LoginContext) (*SKB, error)

func (*SKB) ArmoredEncode ¶ 

func (s *SKB) ArmoredEncode() (ret string, err error)

func (*SKB) Dump ¶ 

func (s *SKB) Dump()

func (*SKB) GetPubKey ¶ 

func (s *SKB) GetPubKey() (key GenericKey, err error)

func (*SKB) HumanDescription ¶ 

func (s *SKB) HumanDescription(owner *User) (string, error)

func (*SKB) PromptAndUnlock ¶ 

func (s *SKB) PromptAndUnlock(lctx LoginContext, reason, which string, secretStore SecretStore, ui SecretUI, lksPreload *LKSec, me *User) (ret GenericKey, err error)

func (*SKB) RawUnlockedKey ¶ 

func (s *SKB) RawUnlockedKey() []byte

func (*SKB) ReadKey ¶ 

func (s *SKB) ReadKey() (g GenericKey, err error)

func (*SKB) SetUID ¶ 

func (s *SKB) SetUID(uid keybase1.UID)

func (*SKB) ToPacket ¶ 

func (s *SKB) ToPacket() (ret *KeybasePacket, err error)

func (*SKB) UnlockNoPrompt ¶ 

func (s *SKB) UnlockNoPrompt(lctx LoginContext, secretStore SecretStore, lksPreload *LKSec) (GenericKey, error)

func (*SKB) UnlockSecretKey ¶ 

func (s *SKB) UnlockSecretKey(lctx LoginContext, passphrase string, tsec *triplesec.Cipher, pps *PassphraseStream, secretStorer SecretStorer, lksPreload *LKSec) (key GenericKey, err error)

func (*SKB) UnlockWithStoredSecret ¶ 

func (s *SKB) UnlockWithStoredSecret(secretRetriever SecretRetriever) (ret GenericKey, err error)

func (*SKB) VerboseDescription ¶ 

func (s *SKB) VerboseDescription() (ret string, err error)

type SKBKeyringFile ¶ 

type SKBKeyringFile struct {
	Blocks []*SKB
	// contains filtered or unexported fields
}

func LoadSKBKeyring ¶ 

func LoadSKBKeyring(un NormalizedUsername, g *GlobalContext) (*SKBKeyringFile, error)

func NewSKBKeyringFile ¶ 

func NewSKBKeyringFile(n string) *SKBKeyringFile

func (SKBKeyringFile) FindSecretKey ¶ 

func (k SKBKeyringFile) FindSecretKey(kids []keybase1.KID) (ret *SKB)

FindSecretKey will, given a list of KIDs, find the first one in the list that has a corresponding secret key in the keyring file.

func (SKBKeyringFile) GetFilename ¶ 

func (k SKBKeyringFile) GetFilename() string

func (*SKBKeyringFile) HasPGPKeys ¶ 

func (k *SKBKeyringFile) HasPGPKeys() bool

func (*SKBKeyringFile) Index ¶ 

func (k *SKBKeyringFile) Index() (err error)

func (*SKBKeyringFile) Load ¶ 

func (k *SKBKeyringFile) Load() (err error)

func (*SKBKeyringFile) LoadAndIndex ¶ 

func (k *SKBKeyringFile) LoadAndIndex() error

func (SKBKeyringFile) LookupByFingerprint ¶ 

func (k SKBKeyringFile) LookupByFingerprint(fp PGPFingerprint) *SKB

func (SKBKeyringFile) LookupByKid ¶ 

func (k SKBKeyringFile) LookupByKid(kid keybase1.KID) *SKB

func (*SKBKeyringFile) Push ¶ 

func (k *SKBKeyringFile) Push(skb *SKB) error

func (*SKBKeyringFile) PushAndSave ¶ 

func (k *SKBKeyringFile) PushAndSave(skb *SKB) error

func (*SKBKeyringFile) Save ¶ 

func (k *SKBKeyringFile) Save() error

func (SKBKeyringFile) SearchWithComputedKeyFamily ¶ 

func (k SKBKeyringFile) SearchWithComputedKeyFamily(ckf *ComputedKeyFamily, ska SecretKeyArg) []*SKB

func (SKBKeyringFile) WriteTo ¶ 

func (k SKBKeyringFile) WriteTo(w io.Writer) (int64, error)

type SKBPriv ¶ 

type SKBPriv struct {
	Data                 []byte `codec:"data"`
	Encryption           int    `codec:"encryption"`
	PassphraseGeneration int    `codec:"passphrase_generation,omitempty"`
}

type SafeWriter ¶ 

type SafeWriter interface {
	GetFilename() string
	WriteTo(io.Writer) (int64, error)
}

type SecretKeyArg ¶ 

type SecretKeyArg struct {
	// Whose keys to use. Must be non-nil.
	Me *User

	// The allowed key types.
	KeyType SecretKeyType

	// For non-device keys, a string that the key has to match. If
	// empty, any valid key is allowed.
	KeyQuery   string
	ExactMatch bool // if set, full equality required
}

type SecretKeyType ¶ 

type SecretKeyType int
const (
	// The current device signing key.
	DeviceSigningKeyType SecretKeyType = iota
	// The current device encryption key.
	DeviceEncryptionKeyType
	// A PGP key (including the synced PGP key, if there is one).
	PGPKeyType
)

func (SecretKeyType) String ¶ 

func (t SecretKeyType) String() string

type SecretRetriever ¶ 

type SecretRetriever interface {
	RetrieveSecret() ([]byte, error)
}

type SecretStore ¶ 

type SecretStore interface {
	SecretRetriever
	SecretStorer
	ClearSecret() error
}

func NewSecretStore ¶ 

func NewSecretStore(g *GlobalContext, username NormalizedUsername) SecretStore

type SecretStoreError ¶ 

type SecretStoreError struct {
	Msg string
}

func (SecretStoreError) Error ¶ 

func (e SecretStoreError) Error() string

type SecretStorer ¶ 

type SecretStorer interface {
	StoreSecret(secret []byte) error
}

type SecretSyncer ¶ 

type SecretSyncer struct {
	sync.Mutex
	Contextified
	// contains filtered or unexported fields
}

func NewSecretSyncer ¶ 

func NewSecretSyncer(g *GlobalContext) *SecretSyncer

func (*SecretSyncer) ActiveDevices ¶ 

func (ss *SecretSyncer) ActiveDevices(includeTypesSet DeviceTypeSet) (DeviceKeyMap, error)

ActiveDevices returns all the active desktop and mobile devices.

func (*SecretSyncer) AllActiveKeys ¶ 

func (ss *SecretSyncer) AllActiveKeys(ckf *ComputedKeyFamily) []*SKB

AllActiveKeys returns all the active synced PGP keys.

func (*SecretSyncer) Clear ¶ 

func (ss *SecretSyncer) Clear() error

func (*SecretSyncer) Devices ¶ 

func (ss *SecretSyncer) Devices() (DeviceKeyMap, error)

func (*SecretSyncer) DumpPrivateKeys ¶ 

func (ss *SecretSyncer) DumpPrivateKeys()

func (*SecretSyncer) FindActiveKey ¶ 

func (ss *SecretSyncer) FindActiveKey(ckf *ComputedKeyFamily) (ret *SKB, err error)

FindActiveKey examines the synced keys, looking for one that's currently active. Returns ret=nil if none was found.

func (*SecretSyncer) FindDevice ¶ 

func (ss *SecretSyncer) FindDevice(id keybase1.DeviceID) (DeviceKey, error)

func (*SecretSyncer) FindPrivateKey ¶ 

func (ss *SecretSyncer) FindPrivateKey(kid string) (ServerPrivateKey, bool)

func (*SecretSyncer) HasActiveDevice ¶ 

func (ss *SecretSyncer) HasActiveDevice(includeTypesSet DeviceTypeSet) (bool, error)

HasActiveDevice returns true if there is an active desktop or mobile device available.

func (*SecretSyncer) HasDevices ¶ 

func (ss *SecretSyncer) HasDevices() bool

func (*SecretSyncer) IsDeviceNameTaken ¶ 

func (ss *SecretSyncer) IsDeviceNameTaken(name string, includeTypesSet DeviceTypeSet) bool

IsDeviceNameTaken returns true if a desktop or mobile device is using a name already.

type SecretUI ¶ 

type SecretUI interface {
	GetSecret(pinentry keybase1.SecretEntryArg, terminal *keybase1.SecretEntryArg) (*keybase1.SecretEntryRes, error)
	GetNewPassphrase(keybase1.GetNewPassphraseArg) (keybase1.GetPassphraseRes, error)
	GetKeybasePassphrase(keybase1.GetKeybasePassphraseArg) (keybase1.GetPassphraseRes, error)
	GetPaperKeyPassphrase(keybase1.GetPaperKeyPassphraseArg) (string, error)
	GetPassphrase(pinentry keybase1.GUIEntryArg, terminal *keybase1.SecretEntryArg) (keybase1.GetPassphraseRes, error)
}

type SelfNotFoundError ¶ 

type SelfNotFoundError struct {
	// contains filtered or unexported fields
}

func (SelfNotFoundError) Error ¶ 

func (e SelfNotFoundError) Error() string

func (SelfNotFoundError) ToStatus ¶ 

func (e SelfNotFoundError) ToStatus() keybase1.Status
type SelfSigChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseSelfSigChainLink(base GenericChainLink) (ret *SelfSigChainLink, err error)

func (*SelfSigChainLink) CheckDataJSON ¶ 

func (s *SelfSigChainLink) CheckDataJSON() *jsonw.Wrapper

func (*SelfSigChainLink) ComputeTrackDiff ¶ 

func (s *SelfSigChainLink) ComputeTrackDiff(tl *TrackLookup) TrackDiff

func (*SelfSigChainLink) DisplayCheck ¶ 

func (s *SelfSigChainLink) DisplayCheck(ui IdentifyUI, lcr LinkCheckResult)

func (*SelfSigChainLink) GetDevice ¶ 

func (s *SelfSigChainLink) GetDevice() *Device

func (*SelfSigChainLink) GetHostname ¶ 

func (s *SelfSigChainLink) GetHostname() string

func (*SelfSigChainLink) GetPGPFullHash ¶ 

func (s *SelfSigChainLink) GetPGPFullHash() string

func (*SelfSigChainLink) GetProofType ¶ 

func (s *SelfSigChainLink) GetProofType() keybase1.ProofType

func (*SelfSigChainLink) GetProtocol ¶ 

func (s *SelfSigChainLink) GetProtocol() string

func (*SelfSigChainLink) GetRemoteUsername ¶ 

func (s *SelfSigChainLink) GetRemoteUsername() string

func (*SelfSigChainLink) LastWriterWins ¶ 

func (s *SelfSigChainLink) LastWriterWins() bool

func (*SelfSigChainLink) ParseDevice ¶ 

func (s *SelfSigChainLink) ParseDevice() (err error)

func (*SelfSigChainLink) ProofText ¶ 

func (s *SelfSigChainLink) ProofText() string

func (*SelfSigChainLink) TableKey ¶ 

func (s *SelfSigChainLink) TableKey() string

func (*SelfSigChainLink) ToDisplayString ¶ 

func (s *SelfSigChainLink) ToDisplayString() string

func (*SelfSigChainLink) ToIDString ¶ 

func (s *SelfSigChainLink) ToIDString() string

func (*SelfSigChainLink) ToKeyValuePair ¶ 

func (s *SelfSigChainLink) ToKeyValuePair() (string, string)

func (*SelfSigChainLink) ToTrackingStatement ¶ 

func (s *SelfSigChainLink) ToTrackingStatement(keybase1.ProofState) (*jsonw.Wrapper, error)

func (*SelfSigChainLink) Type ¶ 

func (s *SelfSigChainLink) Type() string

type SelfTrackError ¶ 

type SelfTrackError struct{}

func (SelfTrackError) Error ¶ 

func (e SelfTrackError) Error() string

type Seqno ¶ 

type Seqno int64

type Server ¶ 

type Server interface {
}

type ServerChainError ¶ 

type ServerChainError struct {
	// contains filtered or unexported fields
}

func NewServerChainError ¶ 

func NewServerChainError(d string, a ...interface{}) ServerChainError

func (ServerChainError) Error ¶ 

func (e ServerChainError) Error() string

type ServerPrivateKey ¶ 

type ServerPrivateKey struct {
	Kid     string `json:"kid"`
	KeyType int    `json:"key_type"`
	Bundle  string `json:"bundle"`
	Mtime   int    `json:"mtime"`
	Ctime   int    `json:"ctime"`
	KeyBits int    `json:"key_bits"`
	KeyAlgo int    `json:"key_algo"`
}

func (*ServerPrivateKey) FindActiveKey ¶ 

func (k *ServerPrivateKey) FindActiveKey(ckf *ComputedKeyFamily) (ret *SKB, err error)

func (ServerPrivateKey) ToSKB ¶ 

func (k ServerPrivateKey) ToSKB(gc *GlobalContext) (*SKB, error)

type ServerPrivateKeyMap ¶ 

type ServerPrivateKeyMap map[string]ServerPrivateKey

type ServerPrivateKeys ¶ 

type ServerPrivateKeys struct {
	Status      APIStatus           `json:"status"`
	Version     int                 `json:"version"`
	Mtime       *int                `json:"mtime"`
	PrivateKeys ServerPrivateKeyMap `json:"private_keys"` // note these are only PGP keys
	Devices     DeviceKeyMap        `json:"devices"`
}

type ServiceBlock ¶ 

type ServiceBlock struct {
	// contains filtered or unexported fields
}

Can be used to either parse a proof `service` JSON block, or a `remote_key_proof` JSON block in a tracking statement.

func ParseServiceBlock ¶ 

func ParseServiceBlock(jw *jsonw.Wrapper) (sb *ServiceBlock, err error)

func (ServiceBlock) GetProofState ¶ 

func (sb ServiceBlock) GetProofState() keybase1.ProofState

func (ServiceBlock) IsSocial ¶ 

func (sb ServiceBlock) IsSocial() bool

func (ServiceBlock) LastWriterWins ¶ 

func (sb ServiceBlock) LastWriterWins() bool

func (ServiceBlock) ToIDString ¶ 

func (sb ServiceBlock) ToIDString() string

func (ServiceBlock) ToKeyValuePair ¶ 

func (sb ServiceBlock) ToKeyValuePair() (string, string)

type ServiceInfo ¶ 

type ServiceInfo struct {
	Version string `json:"version,omitempty"`
	Label   string `json:"label,omitempty"`
	Pid     int    `json:"pid,omitempty"`
}

ServiceInfo describes runtime info for a service. This is primarily used to detect service updates.

func KeybaseServiceInfo ¶ 

func KeybaseServiceInfo(g *GlobalContext) ServiceInfo

KeybaseServiceInfo is runtime info for the Keybase service.

func NewServiceInfo ¶ 

func NewServiceInfo(version string, build string, label string, pid int) ServiceInfo

NewServiceInfo for generating service info for other services (like KBFS).

func WaitForServiceInfoFile ¶ 

func WaitForServiceInfoFile(path string, pid string, maxAttempts int, wait time.Duration, reason string) (*ServiceInfo, error)

WaitForServiceInfoFile tries to wait for a service info file, which should be written on successful service startup.

func (ServiceInfo) WriteFile ¶ 

func (s ServiceInfo) WriteFile(path string) error

WriteFile writes service info as JSON in runtimeDir.

type ServiceType ¶ 

type ServiceType interface {
	AllStringKeys() []string
	PrimaryStringKeys() []string
	CheckUsername(string) error
	NormalizeUsername(string) (string, error)
	ToChecker() Checker
	GetPrompt() string
	LastWriterWins() bool
	PreProofCheck(username string) (*Markup, error)
	PreProofWarning(remotename string) *Markup
	ToServiceJSON(remotename string) *jsonw.Wrapper
	PostInstructions(remotename string) *Markup
	DisplayName(username string) string
	RecheckProofPosting(tryNumber int, status keybase1.ProofStatus, username string) (warning *Markup, err error)
	GetProofType() string
	GetTypeName() string
	CheckProofText(text string, id keybase1.SigID, sig string) error
	FormatProofText(*PostProofRes) (string, error)
	GetAPIArgKey() string
}

func GetServiceType ¶ 

func GetServiceType(s string) ServiceType

type Session ¶ 

type Session struct {
	Contextified
	// contains filtered or unexported fields
}

func NewSessionThin ¶ 

func NewSessionThin(uid keybase1.UID, username NormalizedUsername, token string) *Session

NewSessionThin creates a minimal (thin) session of just the uid and username. Clients of the daemon that use the session protocol need this.

func (*Session) APIArgs ¶ 

func (s *Session) APIArgs() (token, csrf string)

func (*Session) GetCsrf ¶ 

func (s *Session) GetCsrf() string

func (*Session) GetDictionary ¶ 

func (s *Session) GetDictionary() *jsonw.Wrapper

func (*Session) GetToken ¶ 

func (s *Session) GetToken() string

func (*Session) GetUID ¶ 

func (s *Session) GetUID() keybase1.UID

func (*Session) GetUsername ¶ 

func (s *Session) GetUsername() *NormalizedUsername

func (*Session) HasSessionToken ¶ 

func (s *Session) HasSessionToken() bool

func (*Session) Invalidate ¶ 

func (s *Session) Invalidate()

Invalidate marks the session as invalid and posts a logout notification.

func (*Session) IsLoggedIn ¶ 

func (s *Session) IsLoggedIn() bool

func (*Session) IsLoggedInAndProvisioned ¶ 

func (s *Session) IsLoggedInAndProvisioned() bool

true if user is logged in and has a device fully provisioned

func (*Session) IsRecent ¶ 

func (s *Session) IsRecent() bool

func (*Session) IsValid ¶ 

func (s *Session) IsValid() bool

func (*Session) Load ¶ 

func (s *Session) Load() error

func (*Session) Logout ¶ 

func (s *Session) Logout() error

func (*Session) SetCsrf ¶ 

func (s *Session) SetCsrf(t string)

func (*Session) SetDeviceProvisioned ¶ 

func (s *Session) SetDeviceProvisioned(devid keybase1.DeviceID) error

func (*Session) SetLoggedIn ¶ 

func (s *Session) SetLoggedIn(sessionID, csrfToken string, username NormalizedUsername, uid keybase1.UID, deviceID keybase1.DeviceID) error

func (*Session) SetUsername ¶ 

func (s *Session) SetUsername(username NormalizedUsername)

type SessionReader ¶ 

type SessionReader interface {
	APIArgs() (token, csrf string)
	IsLoggedIn() bool
	Invalidate()
}

type ShutdownHook ¶ 

type ShutdownHook func() error

type SibkeyAlreadyExistsError ¶ 

type SibkeyAlreadyExistsError struct{}

func (SibkeyAlreadyExistsError) Error ¶ 

func (e SibkeyAlreadyExistsError) Error() string

func (SibkeyAlreadyExistsError) ToStatus ¶ 

func (e SibkeyAlreadyExistsError) ToStatus() keybase1.Status
type SibkeyChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseSibkeyChainLink(b GenericChainLink) (ret *SibkeyChainLink, err error)

func (*SibkeyChainLink) GetDelegatedKid ¶ 

func (s *SibkeyChainLink) GetDelegatedKid() keybase1.KID

func (*SibkeyChainLink) GetDevice ¶ 

func (s *SibkeyChainLink) GetDevice() *Device

func (*SibkeyChainLink) GetPGPFullHash ¶ 

func (s *SibkeyChainLink) GetPGPFullHash() string

func (*SibkeyChainLink) GetRole ¶ 

func (s *SibkeyChainLink) GetRole() KeyRole

func (*SibkeyChainLink) ToDisplayString ¶ 

func (s *SibkeyChainLink) ToDisplayString() string

func (*SibkeyChainLink) Type ¶ 

func (s *SibkeyChainLink) Type() string

func (*SibkeyChainLink) VerifyReverseSig ¶ 

func (s *SibkeyChainLink) VerifyReverseSig(ckf ComputedKeyFamily) (err error)

VerifyReverseSig checks a SibkeyChainLink's reverse signature using the ComputedKeyFamily provided.

type SigChain ¶ 

type SigChain struct {
	Contextified
	// contains filtered or unexported fields
}

func (*SigChain) Bump ¶ 

func (sc *SigChain) Bump(mt MerkleTriple)

func (*SigChain) CheckFreshness ¶ 

func (sc *SigChain) CheckFreshness(srv *MerkleTriple) (current bool, err error)

func (*SigChain) Dump ¶ 

func (sc *SigChain) Dump(w io.Writer)

Dump prints the sigchain to the writer arg.

func (SigChain) GetComputedKeyInfos ¶ 

func (sc SigChain) GetComputedKeyInfos() (cki *ComputedKeyInfos)

func (*SigChain) GetCurrentSubchain ¶ 

func (sc *SigChain) GetCurrentSubchain(eldest keybase1.KID) (links []*ChainLink, err error)

GetCurrentSubchain takes the given sigchain and walks backward until it finds the start of the current subchain, returning all the links in the subchain. A new subchain starts in one of three ways (from the perspective of walking from oldest to newest):

  1. A link has a new eldest key, usually in the form of reporting no eldest_kid of its own and being signed by a KID that's not the previous eldest. Most resets so far take this form.
  2. A link of type "eldest", regardless of the KIDs involved. We want this to be how everything works in the future.
  3. One of a set of six hardcoded links that made it in back when we allowed repeating eldest keys without using the "eldest" link type.

func (SigChain) GetCurrentTailTriple ¶ 

func (sc SigChain) GetCurrentTailTriple() (ret *MerkleTriple)
func (sc SigChain) GetFirstLink() *ChainLink

func (SigChain) GetFutureChainTail ¶ 

func (sc SigChain) GetFutureChainTail() (ret *MerkleTriple)

func (SigChain) GetLastKnownID ¶ 

func (sc SigChain) GetLastKnownID() (ret LinkID)

func (SigChain) GetLastKnownSeqno ¶ 

func (sc SigChain) GetLastKnownSeqno() (ret Seqno)
func (sc SigChain) GetLastLink() *ChainLink

func (SigChain) GetLastLoadedID ¶ 

func (sc SigChain) GetLastLoadedID() (ret LinkID)

func (SigChain) GetLastLoadedSeqno ¶ 

func (sc SigChain) GetLastLoadedSeqno() (ret Seqno)

func (*SigChain) GetLinkFromSeqno ¶ 

func (sc *SigChain) GetLinkFromSeqno(seqno int) *ChainLink

func (*SigChain) GetLinkFromSigID ¶ 

func (sc *SigChain) GetLinkFromSigID(id keybase1.SigID) *ChainLink

func (SigChain) Len ¶ 

func (sc SigChain) Len() int

func (*SigChain) LoadFromServer ¶ 

func (sc *SigChain) LoadFromServer(t *MerkleTriple, selfUID keybase1.UID) (dirtyTail *MerkleTriple, err error)

func (*SigChain) LocalDelegate ¶ 

func (sc *SigChain) LocalDelegate(kf *KeyFamily, key GenericKey, sigID keybase1.SigID, signingKid keybase1.KID, isSibkey bool) (err error)

func (*SigChain) Store ¶ 

func (sc *SigChain) Store() (err error)
func (sc *SigChain) VerifiedChainLinks(fp PGPFingerprint) (ret []*ChainLink)

func (*SigChain) VerifyChain ¶ 

func (sc *SigChain) VerifyChain() (err error)

func (*SigChain) VerifySigsAndComputeKeys ¶ 

func (sc *SigChain) VerifySigsAndComputeKeys(eldest keybase1.KID, ckf *ComputedKeyFamily) (cached bool, err error)

type SigChainLoader ¶ 

type SigChainLoader struct {
	Contextified
	// contains filtered or unexported fields
}

func (*SigChainLoader) AccessPreload ¶ 

func (l *SigChainLoader) AccessPreload() (cached bool, err error)

func (*SigChainLoader) CheckFreshness ¶ 

func (l *SigChainLoader) CheckFreshness() (current bool, err error)

func (*SigChainLoader) GetKeyFamily ¶ 

func (l *SigChainLoader) GetKeyFamily() (err error)

func (*SigChainLoader) GetMerkleTriple ¶ 

func (l *SigChainLoader) GetMerkleTriple() (ret *MerkleTriple)

func (*SigChainLoader) Load ¶ 

func (l *SigChainLoader) Load() (ret *SigChain, err error)

Load is the main entry point into the SigChain loader. It runs through all of the steps to load a chain in from storage, to refresh it against the server, and to verify its integrity.

func (*SigChainLoader) LoadFromServer ¶ 

func (l *SigChainLoader) LoadFromServer() (err error)

func (*SigChainLoader) LoadLastLinkIDFromStorage ¶ 

func (l *SigChainLoader) LoadLastLinkIDFromStorage() (mt *MerkleTriple, err error)

func (*SigChainLoader) LoadLinksFromStorage ¶ 

func (l *SigChainLoader) LoadLinksFromStorage() (err error)

func (*SigChainLoader) MakeSigChain ¶ 

func (l *SigChainLoader) MakeSigChain() error

func (*SigChainLoader) Store ¶ 

func (l *SigChainLoader) Store() (err error)

Store a SigChain to local storage as a result of having loaded it. We eagerly write loaded chain links to storage if they verify properly.

func (*SigChainLoader) StoreTail ¶ 

func (l *SigChainLoader) StoreTail() (err error)

func (*SigChainLoader) VerifySigsAndComputeKeys ¶ 

func (l *SigChainLoader) VerifySigsAndComputeKeys() (err error)

type SigHint ¶ 

type SigHint struct {
	// contains filtered or unexported fields
}

func NewSigHint ¶ 

func NewSigHint(jw *jsonw.Wrapper) (sh *SigHint, err error)

func (SigHint) Export ¶ 

func (sh SigHint) Export() *keybase1.SigHint

func (SigHint) GetAPIURL ¶ 

func (sh SigHint) GetAPIURL() string

func (SigHint) GetCheckText ¶ 

func (sh SigHint) GetCheckText() string

func (SigHint) GetHumanURL ¶ 

func (sh SigHint) GetHumanURL() string

func (SigHint) MarshalToJSON ¶ 

func (sh SigHint) MarshalToJSON() *jsonw.Wrapper

type SigHints ¶ 

type SigHints struct {
	Contextified
	// contains filtered or unexported fields
}

func LoadAndRefreshSigHints ¶ 

func LoadAndRefreshSigHints(uid keybase1.UID, g *GlobalContext) (sh *SigHints, err error)

func LoadSigHints ¶ 

func LoadSigHints(uid keybase1.UID, g *GlobalContext) (sh *SigHints, err error)

func NewSigHints ¶ 

func NewSigHints(jw *jsonw.Wrapper, uid keybase1.UID, dirty bool, g *GlobalContext) (sh *SigHints, err error)

func (SigHints) Lookup ¶ 

func (sh SigHints) Lookup(i keybase1.SigID) *SigHint

func (SigHints) MarshalToJSON ¶ 

func (sh SigHints) MarshalToJSON() *jsonw.Wrapper

func (*SigHints) PopulateWith ¶ 

func (sh *SigHints) PopulateWith(jw *jsonw.Wrapper) (err error)

func (*SigHints) Refresh ¶ 

func (sh *SigHints) Refresh() error

func (*SigHints) Store ¶ 

func (sh *SigHints) Store() (err error)

type SignatureStatus ¶ 

type SignatureStatus struct {
	IsSigned        bool
	Verified        bool
	SignatureError  error
	KeyID           uint64
	Entity          *openpgp.Entity
	SignatureTime   time.Time
	RecipientKeyIDs []uint64
}

func PGPDecrypt ¶ 

func PGPDecrypt(source io.Reader, sink io.Writer, kr openpgp.KeyRing) (*SignatureStatus, error)

func PGPDecryptWithBundles ¶ 

func PGPDecryptWithBundles(source io.Reader, sink io.Writer, keys []*PGPKeyBundle) (*SignatureStatus, error)

type SimpleTimer ¶ 

type SimpleTimer struct {
	// contains filtered or unexported fields
}

SimpleTimer keeps track of how long something is taking, like a network API call. Meant to be very simple. It is not meant to be goroutine safe and should only be called from one Goroutine.

func (*SimpleTimer) GetTotal ¶ 

func (s *SimpleTimer) GetTotal() int64

GetTotal gets the total duration spent in the timer.

func (*SimpleTimer) Reset ¶ 

func (s *SimpleTimer) Reset()

Reset the internal duration counter.

func (*SimpleTimer) Start ¶ 

func (s *SimpleTimer) Start()

Start the timer running, if it's not already started.

func (*SimpleTimer) Stop ¶ 

func (s *SimpleTimer) Stop() int64

Stop the timer; panic if it hasn't been previously started. Return the total duration spent in the timer. 

type SocialProofChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func NewSocialProofChainLink(b GenericChainLink, s, u, proofText string) *SocialProofChainLink

func (*SocialProofChainLink) CheckDataJSON ¶ 

func (s *SocialProofChainLink) CheckDataJSON() *jsonw.Wrapper

func (*SocialProofChainLink) ComputeTrackDiff ¶ 

func (s *SocialProofChainLink) ComputeTrackDiff(tl *TrackLookup) TrackDiff

func (*SocialProofChainLink) DisplayCheck ¶ 

func (s *SocialProofChainLink) DisplayCheck(ui IdentifyUI, lcr LinkCheckResult)

func (*SocialProofChainLink) GetHostname ¶ 

func (s *SocialProofChainLink) GetHostname() string

func (*SocialProofChainLink) GetProofType ¶ 

func (s *SocialProofChainLink) GetProofType() keybase1.ProofType

func (*SocialProofChainLink) GetProtocol ¶ 

func (s *SocialProofChainLink) GetProtocol() string

func (*SocialProofChainLink) GetRemoteUsername ¶ 

func (s *SocialProofChainLink) GetRemoteUsername() string

func (*SocialProofChainLink) GetService ¶ 

func (s *SocialProofChainLink) GetService() string

func (*SocialProofChainLink) LastWriterWins ¶ 

func (s *SocialProofChainLink) LastWriterWins() bool

func (*SocialProofChainLink) ProofText ¶ 

func (s *SocialProofChainLink) ProofText() string

func (*SocialProofChainLink) TableKey ¶ 

func (s *SocialProofChainLink) TableKey() string

func (*SocialProofChainLink) ToDisplayString ¶ 

func (s *SocialProofChainLink) ToDisplayString() string

func (*SocialProofChainLink) ToIDString ¶ 

func (s *SocialProofChainLink) ToIDString() string

func (*SocialProofChainLink) ToKeyValuePair ¶ 

func (s *SocialProofChainLink) ToKeyValuePair() (string, string)

func (*SocialProofChainLink) ToTrackingStatement ¶ 

func (s *SocialProofChainLink) ToTrackingStatement(state keybase1.ProofState) (*jsonw.Wrapper, error)

func (*SocialProofChainLink) Type ¶ 

func (s *SocialProofChainLink) Type() string

type Socket ¶ 

type Socket interface {
	BindToSocket() (net.Listener, error)
	DialSocket() (net.Conn, error)
	GetFile() string
}

NewSocket() (Socket, err) is defined in the various platform-specific socket_*.go files.

func NewSocket ¶ 

func NewSocket(g *GlobalContext) (ret Socket, err error)

type SocketInfo ¶ 

type SocketInfo struct {
	Contextified
	// contains filtered or unexported fields
}

func (SocketInfo) BindToSocket ¶ 

func (s SocketInfo) BindToSocket() (ret net.Listener, err error)

func (SocketInfo) DialSocket ¶ 

func (s SocketInfo) DialSocket() (ret net.Conn, err error)

func (SocketInfo) GetFile ¶ 

func (s SocketInfo) GetFile() string

type SocketWrapper ¶ 

type SocketWrapper struct {
	// contains filtered or unexported fields
}

type SpecialKeyRing ¶ 

type SpecialKeyRing struct {
	Contextified
	// contains filtered or unexported fields
}

SpecialKeyRing holds blessed keys, like the one Keybase uses to sign its Merkle Root.

func NewSpecialKeyRing ¶ 

func NewSpecialKeyRing(v []keybase1.KID, g *GlobalContext) *SpecialKeyRing

NewSpecialKeyRing allocates a new SpecialKeyRing with the given vector of KIDs. For NaCl keys, it will actually import those keys into the Keyring.

func (*SpecialKeyRing) IsValidKID ¶ 

func (sk *SpecialKeyRing) IsValidKID(kid keybase1.KID) bool

IsValidKID returns if this KID is valid (blessed) according to this Keyring

func (*SpecialKeyRing) Load ¶ 

func (sk *SpecialKeyRing) Load(kid keybase1.KID) (GenericKey, error)

Load takes a blessed KID and returns, if possible, the GenericKey associated with that KID, for signature verification. If the key isn't found in memory or on disk (in the case of PGP), then it will attempt to fetch the key from the keybase server.

type StreamExistsError ¶ 

type StreamExistsError struct{}

func (StreamExistsError) Error ¶ 

func (s StreamExistsError) Error() string

func (StreamExistsError) ToStatus ¶ 

func (e StreamExistsError) ToStatus(s keybase1.Status)

type StreamNotFoundError ¶ 

type StreamNotFoundError struct{}

func (StreamNotFoundError) Error ¶ 

func (s StreamNotFoundError) Error() string

func (StreamNotFoundError) ToStatus ¶ 

func (e StreamNotFoundError) ToStatus(s keybase1.Status)

type StreamWrongKindError ¶ 

type StreamWrongKindError struct{}

func (StreamWrongKindError) Error ¶ 

func (s StreamWrongKindError) Error() string

func (StreamWrongKindError) ToStatus ¶ 

func (e StreamWrongKindError) ToStatus(s keybase1.Status)

type StringWarning ¶ 

type StringWarning string

func (StringWarning) Warn ¶ 

func (s StringWarning) Warn()

func (StringWarning) Warning ¶ 

func (s StringWarning) Warning() string

type StubAPIEngine ¶ 

type StubAPIEngine struct {
	*ExternalAPIEngine
}

func NewStubAPIEngine ¶ 

func NewStubAPIEngine() *StubAPIEngine

func (*StubAPIEngine) Get ¶ 

func (e *StubAPIEngine) Get(arg APIArg) (res *ExternalAPIRes, err error)

func (*StubAPIEngine) GetHTML ¶ 

func (e *StubAPIEngine) GetHTML(arg APIArg) (res *ExternalHTMLRes, err error)

func (*StubAPIEngine) GetText ¶ 

func (e *StubAPIEngine) GetText(arg APIArg) (*ExternalTextRes, error)
type SubkeyChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseSubkeyChainLink(b GenericChainLink) (ret *SubkeyChainLink, err error)

func (*SubkeyChainLink) GetDelegatedKid ¶ 

func (s *SubkeyChainLink) GetDelegatedKid() keybase1.KID

func (*SubkeyChainLink) GetParentKid ¶ 

func (s *SubkeyChainLink) GetParentKid() keybase1.KID

func (*SubkeyChainLink) GetRole ¶ 

func (s *SubkeyChainLink) GetRole() KeyRole

func (*SubkeyChainLink) ToDisplayString ¶ 

func (s *SubkeyChainLink) ToDisplayString() string

func (*SubkeyChainLink) Type ¶ 

func (s *SubkeyChainLink) Type() string

type Syncer ¶ 

type Syncer interface {
	Contexitifier
	sync.Locker
	// contains filtered or unexported methods
}

type TerminalUI ¶ 

type TerminalUI interface {
	OutputWriter() io.Writer
	Output(string) error
	Printf(fmt string, args ...interface{}) (int, error)
	PromptYesNo(PromptDescriptor, string, PromptDefault) (bool, error)
	Prompt(PromptDescriptor, string) (string, error)
	PromptPassword(PromptDescriptor, string) (string, error)
	PromptForConfirmation(prompt string) error
}

type TestConfig ¶ 

type TestConfig struct {
	// contains filtered or unexported fields
}

TestConfig tracks libkb config during a test

func (*TestConfig) CleanTest ¶ 

func (c *TestConfig) CleanTest()

func (*TestConfig) GetConfigFileName ¶ 

func (c *TestConfig) GetConfigFileName() string

func (*TestConfig) InitTest ¶ 

func (c *TestConfig) InitTest(t *testing.T, initConfig string)

type TestContext ¶ 

type TestContext struct {
	G          *GlobalContext
	PrevGlobal *GlobalContext
	Tp         TestParameters
	// TODO: Rename this to TB.
	T testing.TB
}

func SetupTest ¶ 

func SetupTest(tb testing.TB, nm string) (tc TestContext)

func (*TestContext) Cleanup ¶ 

func (tc *TestContext) Cleanup()

func (TestContext) ClearAllStoredSecrets ¶ 

func (tc TestContext) ClearAllStoredSecrets() error

func (TestContext) Clone ¶ 

func (tc TestContext) Clone() (ret TestContext)

func (*TestContext) GenerateGPGKeyring ¶ 

func (tc *TestContext) GenerateGPGKeyring(ids ...string) error

func (*TestContext) MakePGPKey ¶ 

func (tc *TestContext) MakePGPKey(id string) (*PGPKeyBundle, error)

func (TestContext) MoveGpgKeyringTo ¶ 

func (tc TestContext) MoveGpgKeyringTo(dst TestContext) error

func (*TestContext) ResetLoginState ¶ 

func (tc *TestContext) ResetLoginState()

ResetLoginStateForTest simulates a shutdown and restart (for client state). Used by tests that need to clear out cached login state without logging out.

func (*TestContext) SetRuntimeDir ¶ 

func (tc *TestContext) SetRuntimeDir(s string)

type TestLoginUI ¶ 

type TestLoginUI struct {
	Username                 string
	RevokeBackup             bool
	CalledGetEmailOrUsername int
}

func (*TestLoginUI) DisplayPaperKeyPhrase ¶ 

func (t *TestLoginUI) DisplayPaperKeyPhrase(_ context.Context, arg keybase1.DisplayPaperKeyPhraseArg) error

func (*TestLoginUI) DisplayPrimaryPaperKey ¶ 

func (t *TestLoginUI) DisplayPrimaryPaperKey(_ context.Context, arg keybase1.DisplayPrimaryPaperKeyArg) error

func (*TestLoginUI) GetEmailOrUsername ¶ 

func (t *TestLoginUI) GetEmailOrUsername(_ context.Context, _ int) (string, error)

func (*TestLoginUI) PromptRevokePaperKeys ¶ 

func (t *TestLoginUI) PromptRevokePaperKeys(_ context.Context, arg keybase1.PromptRevokePaperKeysArg) (bool, error)

type TestOutput ¶ 

type TestOutput struct {
	// contains filtered or unexported fields
}

TestOutput is a mock interface for capturing and testing output

func NewTestOutput ¶ 

func NewTestOutput(e string, t *testing.T, c *bool) TestOutput

func (TestOutput) Write ¶ 

func (to TestOutput) Write(p []byte) (n int, err error)

type TestParameters ¶ 

type TestParameters struct {
	ConfigFilename string
	Home           string
	GPGHome        string
	GPGOptions     []string
	Debug          bool
	Devel          bool // Whether we are in Devel Mode
	RuntimeDir     string
}

func (TestParameters) GetDebug ¶ 

func (tp TestParameters) GetDebug() (bool, bool)

type TestSecretUI ¶ 

type TestSecretUI struct {
	Passphrase             string
	BackupPassphrase       string
	StoreSecret            bool
	CalledGetSecret        bool
	CalledGetKBPassphrase  bool
	CalledGetBUPassphrase  bool
	CalledGetNewPassphrase bool
	CalledGetPassphrase    bool
}

func (*TestSecretUI) GetKeybasePassphrase ¶ 

func (t *TestSecretUI) GetKeybasePassphrase(keybase1.GetKeybasePassphraseArg) (keybase1.GetPassphraseRes, error)

func (*TestSecretUI) GetNewPassphrase ¶ 

func (t *TestSecretUI) GetNewPassphrase(keybase1.GetNewPassphraseArg) (keybase1.GetPassphraseRes, error)

func (*TestSecretUI) GetPaperKeyPassphrase ¶ 

func (t *TestSecretUI) GetPaperKeyPassphrase(keybase1.GetPaperKeyPassphraseArg) (string, error)

func (*TestSecretUI) GetPassphrase ¶ 

func (t *TestSecretUI) GetPassphrase(p keybase1.GUIEntryArg, terminal *keybase1.SecretEntryArg) (keybase1.GetPassphraseRes, error)

func (*TestSecretUI) GetSecret ¶ 

func (t *TestSecretUI) GetSecret(p keybase1.SecretEntryArg, terminal *keybase1.SecretEntryArg) (*keybase1.SecretEntryRes, error)

type TimeoutError ¶ 

type TimeoutError struct{}

func (TimeoutError) Error ¶ 

func (e TimeoutError) Error() string

func (TimeoutError) ToStatus ¶ 

func (e TimeoutError) ToStatus() keybase1.Status

type TimerSelector ¶ 

type TimerSelector int

TimerSelector allows us to select which timers we want on. 

const (
	// TimerNone means Timers Disabled
	TimerNone TimerSelector = 0
	// TimerAPI enables API timers
	TimerAPI TimerSelector = 1 << iota
	// TimerXAPI enables External API timers
	TimerXAPI
	// TimerRPC enables RPC timers
	TimerRPC
)

type TimerSet ¶ 

type TimerSet struct {
	Contextified
	// contains filtered or unexported fields
}

TimerSet is the set of currently active timers

func NewTimerSet ¶ 

func NewTimerSet(g *GlobalContext) *TimerSet

NewTimerSet looks into the given context for configuration information about how to set up timers. It then returns the corresponding TimerSet.

func (TimerSet) Start ¶ 

func (s TimerSet) Start(sel TimerSelector) ReportingTimer

Start alloates and starts a new timer if the passed TimerSelector is currently enabled. Otherwise, it just returns a Dummy timer.

type Token ¶ 

type Token struct {
	Typ int
	// contains filtered or unexported fields
}

func NewToken ¶ 

func NewToken(typ int) *Token

func (Token) Eq ¶ 

func (t Token) Eq(t2 Token) bool

type TooManyKeysError ¶ 

type TooManyKeysError struct {
	// contains filtered or unexported fields
}

func (TooManyKeysError) Error ¶ 

func (e TooManyKeysError) Error() string

type TorMode ¶ 

type TorMode int
const (
	TorNone TorMode = iota
	TorStrict
	TorLeaky
)

func StringToTorMode ¶ 

func StringToTorMode(s string) (ret TorMode, err error)

func (TorMode) Enabled ¶ 

func (m TorMode) Enabled() bool

func (TorMode) UseCSRF ¶ 

func (m TorMode) UseCSRF() bool

func (TorMode) UseCookies ¶ 

func (m TorMode) UseCookies() bool

func (TorMode) UseHeaders ¶ 

func (m TorMode) UseHeaders() bool

func (TorMode) UseSession ¶ 

func (m TorMode) UseSession() bool

type TorSessionRequiredError ¶ 

type TorSessionRequiredError struct{}

func (TorSessionRequiredError) Error ¶ 

func (t TorSessionRequiredError) Error() string
type TrackChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}

========================================================================= TrackChainLink

func LocalTrackChainLinkFor ¶ 

func LocalTrackChainLinkFor(tracker, trackee keybase1.UID, g *GlobalContext) (ret *TrackChainLink, err error)
func ParseTrackChainLink(b GenericChainLink) (ret *TrackChainLink, err error)

func (*TrackChainLink) GetTrackedKeys ¶ 

func (l *TrackChainLink) GetTrackedKeys() ([]TrackedKey, error)

func (*TrackChainLink) GetTrackedUID ¶ 

func (l *TrackChainLink) GetTrackedUID() (keybase1.UID, error)

func (*TrackChainLink) GetTrackedUsername ¶ 

func (l *TrackChainLink) GetTrackedUsername() (string, error)

func (TrackChainLink) IsRemote ¶ 

func (l TrackChainLink) IsRemote() bool

func (*TrackChainLink) IsRevoked ¶ 

func (l *TrackChainLink) IsRevoked() bool

func (*TrackChainLink) RemoteKeyProofs ¶ 

func (l *TrackChainLink) RemoteKeyProofs() *jsonw.Wrapper

func (*TrackChainLink) ToDisplayString ¶ 

func (l *TrackChainLink) ToDisplayString() string

func (*TrackChainLink) ToServiceBlocks ¶ 

func (l *TrackChainLink) ToServiceBlocks() (ret []*ServiceBlock)

func (*TrackChainLink) Type ¶ 

func (l *TrackChainLink) Type() string

type TrackDiff ¶ 

type TrackDiff interface {
	BreaksTracking() bool
	ToDisplayString() string
	ToDisplayMarkup() *Markup
	IsSameAsTracked() bool
	GetTrackDiffType() keybase1.TrackDiffType
}

func ComputeRemoteDiff ¶ 

func ComputeRemoteDiff(tracked, observed keybase1.ProofState) TrackDiff

type TrackDiffClash ¶ 

type TrackDiffClash struct {
	// contains filtered or unexported fields
}

func (TrackDiffClash) BreaksTracking ¶ 

func (t TrackDiffClash) BreaksTracking() bool

func (TrackDiffClash) GetTrackDiffType ¶ 

func (t TrackDiffClash) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffClash) IsSameAsTracked ¶ 

func (t TrackDiffClash) IsSameAsTracked() bool

func (TrackDiffClash) ToDisplayMarkup ¶ 

func (t TrackDiffClash) ToDisplayMarkup() *Markup

func (TrackDiffClash) ToDisplayString ¶ 

func (t TrackDiffClash) ToDisplayString() string

type TrackDiffNew ¶ 

type TrackDiffNew struct{}

func (TrackDiffNew) BreaksTracking ¶ 

func (t TrackDiffNew) BreaksTracking() bool

func (TrackDiffNew) GetTrackDiffType ¶ 

func (t TrackDiffNew) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffNew) IsSameAsTracked ¶ 

func (t TrackDiffNew) IsSameAsTracked() bool

func (TrackDiffNew) ToDisplayMarkup ¶ 

func (t TrackDiffNew) ToDisplayMarkup() *Markup

func (TrackDiffNew) ToDisplayString ¶ 

func (t TrackDiffNew) ToDisplayString() string

type TrackDiffNone ¶ 

type TrackDiffNone struct{}

func (TrackDiffNone) BreaksTracking ¶ 

func (t TrackDiffNone) BreaksTracking() bool

func (TrackDiffNone) GetTrackDiffType ¶ 

func (t TrackDiffNone) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffNone) IsSameAsTracked ¶ 

func (t TrackDiffNone) IsSameAsTracked() bool

func (TrackDiffNone) ToDisplayMarkup ¶ 

func (t TrackDiffNone) ToDisplayMarkup() *Markup

func (TrackDiffNone) ToDisplayString ¶ 

func (t TrackDiffNone) ToDisplayString() string

type TrackDiffRemoteChanged ¶ 

type TrackDiffRemoteChanged struct {
	// contains filtered or unexported fields
}

func (TrackDiffRemoteChanged) BreaksTracking ¶ 

func (t TrackDiffRemoteChanged) BreaksTracking() bool

func (TrackDiffRemoteChanged) GetTrackDiffType ¶ 

func (t TrackDiffRemoteChanged) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffRemoteChanged) IsSameAsTracked ¶ 

func (t TrackDiffRemoteChanged) IsSameAsTracked() bool

func (TrackDiffRemoteChanged) ToDisplayMarkup ¶ 

func (t TrackDiffRemoteChanged) ToDisplayMarkup() *Markup

func (TrackDiffRemoteChanged) ToDisplayString ¶ 

func (t TrackDiffRemoteChanged) ToDisplayString() string

type TrackDiffRemoteFail ¶ 

type TrackDiffRemoteFail struct {
	// contains filtered or unexported fields
}

func (TrackDiffRemoteFail) BreaksTracking ¶ 

func (t TrackDiffRemoteFail) BreaksTracking() bool

func (TrackDiffRemoteFail) GetTrackDiffType ¶ 

func (t TrackDiffRemoteFail) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffRemoteFail) IsSameAsTracked ¶ 

func (t TrackDiffRemoteFail) IsSameAsTracked() bool

func (TrackDiffRemoteFail) ToDisplayMarkup ¶ 

func (t TrackDiffRemoteFail) ToDisplayMarkup() *Markup

func (TrackDiffRemoteFail) ToDisplayString ¶ 

func (t TrackDiffRemoteFail) ToDisplayString() string

type TrackDiffRemoteWorking ¶ 

type TrackDiffRemoteWorking struct {
	// contains filtered or unexported fields
}

func (TrackDiffRemoteWorking) BreaksTracking ¶ 

func (t TrackDiffRemoteWorking) BreaksTracking() bool

func (TrackDiffRemoteWorking) GetTrackDiffType ¶ 

func (t TrackDiffRemoteWorking) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffRemoteWorking) IsSameAsTracked ¶ 

func (t TrackDiffRemoteWorking) IsSameAsTracked() bool

func (TrackDiffRemoteWorking) ToDisplayMarkup ¶ 

func (t TrackDiffRemoteWorking) ToDisplayMarkup() *Markup

func (TrackDiffRemoteWorking) ToDisplayString ¶ 

func (t TrackDiffRemoteWorking) ToDisplayString() string

type TrackDiffRevoked ¶ 

type TrackDiffRevoked struct {
	// contains filtered or unexported fields
}

func (TrackDiffRevoked) BreaksTracking ¶ 

func (t TrackDiffRevoked) BreaksTracking() bool

func (TrackDiffRevoked) GetTrackDiffType ¶ 

func (t TrackDiffRevoked) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffRevoked) IsSameAsTracked ¶ 

func (t TrackDiffRevoked) IsSameAsTracked() bool

func (TrackDiffRevoked) ToDisplayMarkup ¶ 

func (t TrackDiffRevoked) ToDisplayMarkup() *Markup

func (TrackDiffRevoked) ToDisplayString ¶ 

func (t TrackDiffRevoked) ToDisplayString() string

type TrackDiffUpgraded ¶ 

type TrackDiffUpgraded struct {
	// contains filtered or unexported fields
}

func (TrackDiffUpgraded) BreaksTracking ¶ 

func (t TrackDiffUpgraded) BreaksTracking() bool

func (TrackDiffUpgraded) GetCurr ¶ 

func (t TrackDiffUpgraded) GetCurr() string

func (TrackDiffUpgraded) GetPrev ¶ 

func (t TrackDiffUpgraded) GetPrev() string

func (TrackDiffUpgraded) GetTrackDiffType ¶ 

func (t TrackDiffUpgraded) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffUpgraded) IsSameAsTracked ¶ 

func (t TrackDiffUpgraded) IsSameAsTracked() bool

func (TrackDiffUpgraded) ToDisplayMarkup ¶ 

func (t TrackDiffUpgraded) ToDisplayMarkup() *Markup

func (TrackDiffUpgraded) ToDisplayString ¶ 

func (t TrackDiffUpgraded) ToDisplayString() string

type TrackIDComponent ¶ 

type TrackIDComponent interface {
	ToIDString() string
	ToKeyValuePair() (string, string)
	GetProofState() keybase1.ProofState
	LastWriterWins() bool
}

Can be a ProofLinkWithState, one of the identities listed in a tracking statement, or a PGP Fingerprint!

type TrackInstructions ¶ 

type TrackInstructions struct {
	Local  bool
	Remote bool
}

type TrackLookup ¶ 

type TrackLookup struct {
	// contains filtered or unexported fields
}

func NewTrackLookup ¶ 

func NewTrackLookup(link *TrackChainLink) *TrackLookup

func (*TrackLookup) GetCTime ¶ 

func (l *TrackLookup) GetCTime() time.Time

func (TrackLookup) GetProofState ¶ 

func (l TrackLookup) GetProofState(id string) keybase1.ProofState

func (TrackLookup) GetTrackedKeys ¶ 

func (l TrackLookup) GetTrackedKeys() []TrackedKey

func (TrackLookup) IsRemote ¶ 

func (l TrackLookup) IsRemote() bool

func (TrackLookup) ToSummary ¶ 

func (l TrackLookup) ToSummary() TrackSummary

type TrackSet ¶ 

type TrackSet struct {
	// contains filtered or unexported fields
}

func NewTrackSet ¶ 

func NewTrackSet() *TrackSet

func (TrackSet) Add ¶ 

func (ts TrackSet) Add(t TrackIDComponent)

func (TrackSet) GetProofState ¶ 

func (ts TrackSet) GetProofState(id string) keybase1.ProofState

func (TrackSet) HasMember ¶ 

func (ts TrackSet) HasMember(t TrackIDComponent) bool

func (TrackSet) LenEq ¶ 

func (ts TrackSet) LenEq(b TrackSet) bool

func (TrackSet) Subtract ¶ 

func (ts TrackSet) Subtract(b TrackSet) (out []TrackIDComponent)

type TrackSummary ¶ 

type TrackSummary struct {
	// contains filtered or unexported fields
}

func ImportTrackSummary ¶ 

func ImportTrackSummary(s *keybase1.TrackSummary) *TrackSummary

func (TrackSummary) Export ¶ 

func (s TrackSummary) Export(username string) (ret keybase1.TrackSummary)

func (TrackSummary) GetCTime ¶ 

func (s TrackSummary) GetCTime() time.Time

func (TrackSummary) IsRemote ¶ 

func (s TrackSummary) IsRemote() bool

func (TrackSummary) Username ¶ 

func (s TrackSummary) Username() string

type TrackedKey ¶ 

type TrackedKey struct {
	KID         keybase1.KID
	Fingerprint PGPFingerprint
}

type Tracker ¶ 

type Tracker keybase1.Tracker

func (Tracker) Eq ¶ 

func (t Tracker) Eq(t2 Tracker) bool

func (Tracker) Export ¶ 

func (t Tracker) Export() keybase1.Tracker

func (Tracker) GetUID ¶ 

func (t Tracker) GetUID() keybase1.UID

type TrackerSyncer ¶ 

type TrackerSyncer struct {
	// Locks the whole object
	sync.RWMutex
	Contextified
	// contains filtered or unexported fields
}

func NewTrackerSyncer ¶ 

func NewTrackerSyncer(uid keybase1.UID, g *GlobalContext) *TrackerSyncer

func (*TrackerSyncer) Trackers ¶ 

func (t *TrackerSyncer) Trackers() *Trackers

type Trackers ¶ 

type Trackers struct {
	Version  int       `json:"version"`
	Trackers []Tracker `json:"trackers"`
}

type TwitterChecker ¶ 

type TwitterChecker struct {
	// contains filtered or unexported fields
}

func (*TwitterChecker) CheckHint ¶ 

func (rc *TwitterChecker) CheckHint(h SigHint) ProofError

func (*TwitterChecker) CheckStatus ¶ 

func (rc *TwitterChecker) CheckStatus(h SigHint) ProofError

func (*TwitterChecker) GetTorError ¶ 

func (rc *TwitterChecker) GetTorError() ProofError

func (*TwitterChecker) ScreenNameCompare ¶ 

func (rc *TwitterChecker) ScreenNameCompare(s1, s2 string) bool

type TwitterServiceType ¶ 

type TwitterServiceType struct{ BaseServiceType }

func (TwitterServiceType) AllStringKeys ¶ 

func (t TwitterServiceType) AllStringKeys() []string

func (TwitterServiceType) CheckProofText ¶ 

func (t TwitterServiceType) CheckProofText(text string, id keybase1.SigID, sig string) (err error)

func (TwitterServiceType) CheckUsername ¶ 

func (t TwitterServiceType) CheckUsername(s string) (err error)

func (TwitterServiceType) DisplayName ¶ 

func (t TwitterServiceType) DisplayName(un string) string

func (TwitterServiceType) GetPrompt ¶ 

func (t TwitterServiceType) GetPrompt() string

func (TwitterServiceType) GetProofType ¶ 

func (t TwitterServiceType) GetProofType() string

func (TwitterServiceType) GetTypeName ¶ 

func (t TwitterServiceType) GetTypeName() string

func (TwitterServiceType) NormalizeUsername ¶ 

func (t TwitterServiceType) NormalizeUsername(s string) (string, error)

func (TwitterServiceType) PostInstructions ¶ 

func (t TwitterServiceType) PostInstructions(un string) *Markup

func (TwitterServiceType) PrimaryStringKeys ¶ 

func (t TwitterServiceType) PrimaryStringKeys() []string

func (TwitterServiceType) RecheckProofPosting ¶ 

func (t TwitterServiceType) RecheckProofPosting(tryNumber int, status keybase1.ProofStatus, _ string) (warning *Markup, err error)

func (TwitterServiceType) ToChecker ¶ 

func (t TwitterServiceType) ToChecker() Checker

func (TwitterServiceType) ToServiceJSON ¶ 

func (t TwitterServiceType) ToServiceJSON(un string) *jsonw.Wrapper
type TypedChainLink interface {
	GetRevocations() []keybase1.SigID
	GetRevokeKids() []keybase1.KID

	GetSigID() keybase1.SigID
	GetArmoredSig() string

	ToDebugString() string
	Type() string
	ToDisplayString() string
	IsRevocationIsh() bool
	IsRevoked() bool
	GetRole() KeyRole
	GetSeqno() Seqno
	GetCTime() time.Time
	GetETime() time.Time
	GetPGPFingerprint() *PGPFingerprint
	GetPGPFullHash() string
	GetKID() keybase1.KID
	IsInCurrentFamily(u *User) bool
	GetUsername() string
	GetUID() keybase1.UID
	GetDelegatedKid() keybase1.KID
	GetParentKid() keybase1.KID
	VerifyReverseSig(ckf ComputedKeyFamily) error
	GetMerkleSeqno() int
	GetDevice() *Device
	// contains filtered or unexported methods
}

type U ¶ 

type U struct {
	Val uint64
}

func (U) String ¶ 

func (u U) String() string

type UHex ¶ 

type UHex struct {
	Val uint64
}

func (UHex) String ¶ 

func (h UHex) String() string

type UI ¶ 

type UI interface {
	GetIdentifyUI() IdentifyUI
	GetIdentifyTrackUI(strict bool) IdentifyUI
	GetLoginUI() LoginUI
	GetSecretUI() SecretUI
	GetTerminalUI() TerminalUI
	GetDumbOutputUI() DumbOutputUI
	GetProveUI() ProveUI
	GetLogUI() LogUI
	GetGPGUI() GPGUI
	GetProvisionUI(role KexRole) ProvisionUI
	Configure() error
	Shutdown() error
}

type UIConsumer ¶ 

type UIConsumer interface {
	Name() string
	RequiredUIs() []UIKind
	SubConsumers() []UIConsumer
}

type UIDMismatchError ¶ 

type UIDMismatchError struct {
	Msg string
}

func (UIDMismatchError) Error ¶ 

func (u UIDMismatchError) Error() string

type UIDelegationUnavailableError ¶ 

type UIDelegationUnavailableError struct{}

func (UIDelegationUnavailableError) Error ¶ 

func (e UIDelegationUnavailableError) Error() string

func (UIDelegationUnavailableError) ToStatus ¶ 

func (e UIDelegationUnavailableError) ToStatus() keybase1.Status

type UIKind ¶ 

type UIKind int
const (
	GPGUIKind UIKind = iota
	IdentifyUIKind
	LogUIKind
	LoginUIKind
	ProveUIKind
	SecretUIKind
	ProvisionUIKind
)

func (UIKind) String ¶ 

func (u UIKind) String() string

type UIRouter ¶ 

type UIRouter interface {
	SetUI(ConnectionID, UIKind)
	GetIdentifyUI() (IdentifyUI, error)
	GetSecretUI() (SecretUI, error)
	Shutdown()
}

type UnexpectedKeyError ¶ 

type UnexpectedKeyError struct {
}

func (UnexpectedKeyError) Error ¶ 

func (e UnexpectedKeyError) Error() string

type UnknownKeyTypeError ¶ 

type UnknownKeyTypeError struct {
	// contains filtered or unexported fields
}

func (UnknownKeyTypeError) Error ¶ 

func (e UnknownKeyTypeError) Error() string

type UnknownSpecialKIDError ¶ 

type UnknownSpecialKIDError struct {
	// contains filtered or unexported fields
}

func (UnknownSpecialKIDError) Error ¶ 

func (u UnknownSpecialKIDError) Error() string

type UnmarshalError ¶ 

type UnmarshalError struct {
	T string
}

func (UnmarshalError) Error ¶ 

func (u UnmarshalError) Error() string
type UntrackChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseUntrackChainLink(b GenericChainLink) (ret *UntrackChainLink, err error)

func (*UntrackChainLink) IsRevocationIsh ¶ 

func (u *UntrackChainLink) IsRevocationIsh() bool

func (*UntrackChainLink) ToDisplayString ¶ 

func (u *UntrackChainLink) ToDisplayString() string

func (*UntrackChainLink) Type ¶ 

func (u *UntrackChainLink) Type() string

type UntrackError ¶ 

type UntrackError struct {
	// contains filtered or unexported fields
}

func NewUntrackError ¶ 

func NewUntrackError(d string, a ...interface{}) UntrackError

func (UntrackError) Error ¶ 

func (e UntrackError) Error() string

type Usage ¶ 

type Usage struct {
	Config     bool
	GpgKeyring bool
	KbKeyring  bool
	API        bool
	Socket     bool
}

func (Usage) UseKeyring ¶ 

func (u Usage) UseKeyring() bool

type User ¶ 

type User struct {
	Contextified
	// contains filtered or unexported fields
}

func LoadMe ¶ 

func LoadMe(arg LoadUserArg) (*User, error)

func LoadUser ¶ 

func LoadUser(arg LoadUserArg) (ret *User, err error)

func NewUser ¶ 

func NewUser(g *GlobalContext, o *jsonw.Wrapper) (*User, error)

func NewUserFromLocalStorage ¶ 

func NewUserFromLocalStorage(g *GlobalContext, o *jsonw.Wrapper) (*User, error)

func NewUserFromServer ¶ 

func NewUserFromServer(g *GlobalContext, o *jsonw.Wrapper) (*User, error)

func NewUserThin ¶ 

func NewUserThin(name string, uid keybase1.UID) *User

func (*User) AllSyncedSecretKeys ¶ 

func (u *User) AllSyncedSecretKeys(lctx LoginContext) (keys []*SKB, err error)

AllSyncedSecretKeys returns all the PGP key blocks that were synced to API server. LoginContext can be nil if this isn't used while logging in, signing up.

func (*User) AuthenticationProof ¶ 

func (u *User) AuthenticationProof(key GenericKey, session string, ei int) (ret *jsonw.Wrapper, err error)

AuthenticationProof makes a JSON proof statement for the user that he can sign to prove a log-in to the system. If successful, the server will return with a session token.

func (*User) BaseProofSet ¶ 

func (u *User) BaseProofSet() *ProofSet

BaseProofSet creates a basic proof set for a user with their keybase and uid proofs and any pgp fingerpring proofs.

func (*User) CheckBasicsFreshness ¶ 

func (u *User) CheckBasicsFreshness(server int64) (current bool, err error)

func (*User) CryptocurrencySig ¶ 

func (u *User) CryptocurrencySig(key GenericKey, address string, sigToRevoke keybase1.SigID) (*jsonw.Wrapper, error)

func (*User) DeviceNames ¶ 

func (u *User) DeviceNames() ([]string, error)

func (*User) Equal ¶ 

func (u *User) Equal(other *User) bool

func (*User) Export ¶ 

func (u *User) Export() *keybase1.User

func (*User) FilterActivePGPKeys ¶ 

func (u *User) FilterActivePGPKeys(sibkey bool, query string) []*PGPKeyBundle

FilterActivePGPKeys returns the active pgp keys that match query.

func (*User) GetActivePGPFingerprints ¶ 

func (u *User) GetActivePGPFingerprints(sibkey bool) (ret []PGPFingerprint)

GetActivePGPFingerprints looks into the user's ComputedKeyFamily and returns only the fingerprint of the active PGP keys. If you want only sibkeys, then // specify sibkey=true.

func (*User) GetActivePGPKIDs ¶ 

func (u *User) GetActivePGPKIDs(sibkey bool) (ret []keybase1.KID)

func (*User) GetActivePGPKeys ¶ 

func (u *User) GetActivePGPKeys(sibkey bool) (ret []*PGPKeyBundle)

GetActivePGPKeys looks into the user's ComputedKeyFamily and returns only the active PGP keys. If you want only sibkeys, then specify sibkey=true.

func (*User) GetComputedKeyFamily ¶ 

func (u *User) GetComputedKeyFamily() (ret *ComputedKeyFamily)

func (*User) GetComputedKeyInfos ¶ 

func (u *User) GetComputedKeyInfos() *ComputedKeyInfos

func (*User) GetDevice ¶ 

func (u *User) GetDevice(id keybase1.DeviceID) (*Device, error)

func (*User) GetDeviceSibkey ¶ 

func (u *User) GetDeviceSibkey() (GenericKey, error)

func (*User) GetDeviceSubkey ¶ 

func (u *User) GetDeviceSubkey() (subkey GenericKey, err error)

func (*User) GetEldestKID ¶ 

func (u *User) GetEldestKID() (ret keybase1.KID)

May return an empty KID

func (*User) GetIDVersion ¶ 

func (u *User) GetIDVersion() (int64, error)

func (*User) GetKeyFamily ¶ 

func (u *User) GetKeyFamily() *KeyFamily

func (*User) GetName ¶ 

func (u *User) GetName() string

func (*User) GetNormalizedName ¶ 

func (u *User) GetNormalizedName() NormalizedUsername

func (*User) GetServerSeqno ¶ 

func (u *User) GetServerSeqno() (i int, err error)

func (*User) GetSigChainLastKnownSeqno ¶ 

func (u *User) GetSigChainLastKnownSeqno() Seqno

func (*User) GetSigIDFromSeqno ¶ 

func (u *User) GetSigIDFromSeqno(seqno int) keybase1.SigID

func (*User) GetSyncedSecretKey ¶ 

func (u *User) GetSyncedSecretKey() (ret *SKB, err error)

func (*User) GetUID ¶ 

func (u *User) GetUID() keybase1.UID

func (*User) HasActiveKey ¶ 

func (u *User) HasActiveKey() bool

func (*User) HasDeviceInCurrentInstall ¶ 

func (u *User) HasDeviceInCurrentInstall() bool

Returns whether or not the current install has an active device sibkey.

func (*User) IDTable ¶ 

func (u *User) IDTable() *IdentityTable

func (*User) IsSigIDActive ¶ 

func (u *User) IsSigIDActive(sigID keybase1.SigID) (bool, error)

func (*User) LinkFromSigID ¶ 

func (u *User) LinkFromSigID(sigID keybase1.SigID) *ChainLink

func (*User) LoadSigChains ¶ 

func (u *User) LoadSigChains(allKeys bool, f *MerkleUserLeaf, self bool) (err error)

func (*User) MakeIDTable ¶ 

func (u *User) MakeIDTable() error

func (*User) RevokeKeysProof ¶ 

func (u *User) RevokeKeysProof(key GenericKey, kidsToRevoke []keybase1.KID, deviceToDisable keybase1.DeviceID) (*jsonw.Wrapper, error)

func (*User) RevokeSigsProof ¶ 

func (u *User) RevokeSigsProof(key GenericKey, sigIDsToRevoke []keybase1.SigID) (*jsonw.Wrapper, error)

func (*User) ServiceProof ¶ 

func (u *User) ServiceProof(signingKey GenericKey, typ ServiceType, remotename string) (ret *jsonw.Wrapper, err error)

func (*User) SigChainBump ¶ 

func (u *User) SigChainBump(linkID LinkID, sigID keybase1.SigID)

func (*User) SigChainBumpMT ¶ 

func (u *User) SigChainBumpMT(mt MerkleTriple)

func (*User) SigChainDump ¶ 

func (u *User) SigChainDump(w io.Writer)

func (*User) SigningKeyPub ¶ 

func (u *User) SigningKeyPub() (GenericKey, error)

func (*User) Store ¶ 

func (u *User) Store() error

func (*User) StoreSigChain ¶ 

func (u *User) StoreSigChain() error

func (*User) StoreTopLevel ¶ 

func (u *User) StoreTopLevel() error

func (*User) SyncSecrets ¶ 

func (u *User) SyncSecrets() error

func (*User) SyncedSecretKey ¶ 

func (u *User) SyncedSecretKey(lctx LoginContext) (ret *SKB, err error)

func (*User) ToTrackingStatement ¶ 

func (u *User) ToTrackingStatement(w *jsonw.Wrapper, outcome *IdentifyOutcome) (err error)

func (*User) ToTrackingStatementBasics ¶ 

func (u *User) ToTrackingStatementBasics(errp *error) *jsonw.Wrapper

func (*User) ToTrackingStatementKey ¶ 

func (u *User) ToTrackingStatementKey(errp *error) *jsonw.Wrapper

func (*User) ToTrackingStatementPGPKeys ¶ 

func (u *User) ToTrackingStatementPGPKeys(errp *error) *jsonw.Wrapper

func (*User) ToTrackingStatementSeqTail ¶ 

func (u *User) ToTrackingStatementSeqTail() *jsonw.Wrapper

func (*User) ToUntrackingStatement ¶ 

func (u *User) ToUntrackingStatement(w *jsonw.Wrapper) (err error)

func (*User) ToUntrackingStatementBasics ¶ 

func (u *User) ToUntrackingStatementBasics() *jsonw.Wrapper

func (*User) TrackChainLinkFor ¶ 

func (u *User) TrackChainLinkFor(username string, uid keybase1.UID) (*TrackChainLink, error)

func (*User) TrackStatementJSON ¶ 

func (u *User) TrackStatementJSON(them *User, outcome *IdentifyOutcome) (string, error)

func (*User) TrackingProofFor ¶ 

func (u *User) TrackingProofFor(signingKey GenericKey, u2 *User, outcome *IdentifyOutcome) (ret *jsonw.Wrapper, err error)

func (*User) UntrackingProofFor ¶ 

func (u *User) UntrackingProofFor(signingKey GenericKey, u2 *User) (ret *jsonw.Wrapper, err error)

func (*User) UpdatePassphraseProof ¶ 

func (u *User) UpdatePassphraseProof(key GenericKey, pwh string, ppGen PassphraseGeneration) (*jsonw.Wrapper, error)

func (*User) VerifySelfSig ¶ 

func (u *User) VerifySelfSig() error

func (*User) VerifySelfSigByKey ¶ 

func (u *User) VerifySelfSigByKey() (ret bool)

type UserBasic ¶ 

type UserBasic interface {
	GetUID() keybase1.UID
	GetName() string
}

type UserCache ¶ 

type UserCache struct {
	// contains filtered or unexported fields
}

UserCache stores User objects in memory for a fixed amount of time.

func NewUserCache ¶ 

func NewUserCache(maxAge time.Duration) *UserCache

NewUserCache creates a UserCache and sets the object max age to maxAge. Once a user is inserted, after maxAge duration passes, the user will be removed from the cache.

func (*UserCache) Get ¶ 

func (c *UserCache) Get(uid keybase1.UID) (*keybase1.UserPlusKeys, error)

Get returns a user object. If none exists for uid, it will return NotFoundError.

func (*UserCache) Insert ¶ 

func (c *UserCache) Insert(up *keybase1.UserPlusKeys) error

Insert adds a user to the cache, keyed on UID.

func (*UserCache) Shutdown ¶ 

func (c *UserCache) Shutdown()

Shutdown stops any goroutines in the cache.

type UserConfig ¶ 

type UserConfig struct {
	ID     string             `json:"id"`
	Name   NormalizedUsername `json:"name"`
	Salt   string             `json:"salt"`
	Device *string            `json:"device"`
	// contains filtered or unexported fields
}

func ImportUserConfigFromJSONWrapper ¶ 

func ImportUserConfigFromJSONWrapper(jw *jsonw.Wrapper) (ret *UserConfig, err error)

func NewUserConfig ¶ 

func NewUserConfig(id keybase1.UID, name NormalizedUsername, salt []byte, dev keybase1.DeviceID) *UserConfig

func (UserConfig) GetDeviceID ¶ 

func (u UserConfig) GetDeviceID() keybase1.DeviceID

func (UserConfig) GetSalt ¶ 

func (u UserConfig) GetSalt() []byte

func (UserConfig) GetUID ¶ 

func (u UserConfig) GetUID() keybase1.UID

func (UserConfig) GetUsername ¶ 

func (u UserConfig) GetUsername() NormalizedUsername

func (*UserConfig) Import ¶ 

func (u *UserConfig) Import() (err error)

func (*UserConfig) SetDevice ¶ 

func (u *UserConfig) SetDevice(d keybase1.DeviceID)

type UserConfigWrapper ¶ 

type UserConfigWrapper struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type UserInfo ¶ 

type UserInfo struct {
	UID      keybase1.UID
	Username string
}

type UserNotFoundError ¶ 

type UserNotFoundError struct {
	// contains filtered or unexported fields
}

func (UserNotFoundError) Error ¶ 

func (u UserNotFoundError) Error() string

type VerificationError ¶ 

type VerificationError struct{}

func (VerificationError) Error ¶ 

func (v VerificationError) Error() string

type VerificationPath ¶ 

type VerificationPath struct {
	Contextified
	// contains filtered or unexported fields
}

func (*VerificationPath) VerifyUser ¶ 

func (vp *VerificationPath) VerifyUser() (user *MerkleUserLeaf, err error)

func (*VerificationPath) VerifyUsername ¶ 

func (vp *VerificationPath) VerifyUsername() (username string, err error)

type WaitForItError ¶ 

type WaitForItError struct{}

func (WaitForItError) Error ¶ 

func (e WaitForItError) Error() string

type Warning ¶ 

type Warning interface {
	Warning() string
	Warn()
}

func ErrorToWarning ¶ 

func ErrorToWarning(e error) Warning

func Warningf ¶ 

func Warningf(format string, a ...interface{}) Warning

type Warnings ¶ 

type Warnings struct {
	// contains filtered or unexported fields
}

func ImportWarnings ¶ 

func ImportWarnings(v []string) Warnings

func (Warnings) IsEmpty ¶ 

func (w Warnings) IsEmpty() bool

func (*Warnings) Push ¶ 

func (w *Warnings) Push(e Warning)

func (Warnings) Warn ¶ 

func (w Warnings) Warn()

func (Warnings) Warnings ¶ 

func (w Warnings) Warnings() []Warning

type WebChecker ¶ 

type WebChecker struct {
	// contains filtered or unexported fields
}

func (*WebChecker) CheckHint ¶ 

func (rc *WebChecker) CheckHint(h SigHint) ProofError

func (*WebChecker) CheckStatus ¶ 

func (rc *WebChecker) CheckStatus(h SigHint) ProofError

func (*WebChecker) GetTorError ¶ 

func (rc *WebChecker) GetTorError() ProofError
type WebProofChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func NewWebProofChainLink(b GenericChainLink, p, h, proofText string) *WebProofChainLink

func (*WebProofChainLink) CheckDataJSON ¶ 

func (w *WebProofChainLink) CheckDataJSON() *jsonw.Wrapper

func (*WebProofChainLink) ComputeTrackDiff ¶ 

func (w *WebProofChainLink) ComputeTrackDiff(tl *TrackLookup) (res TrackDiff)

func (*WebProofChainLink) DisplayCheck ¶ 

func (w *WebProofChainLink) DisplayCheck(ui IdentifyUI, lcr LinkCheckResult)

func (*WebProofChainLink) GetHostname ¶ 

func (w *WebProofChainLink) GetHostname() string

func (*WebProofChainLink) GetProofType ¶ 

func (w *WebProofChainLink) GetProofType() keybase1.ProofType

func (*WebProofChainLink) GetProtocol ¶ 

func (w *WebProofChainLink) GetProtocol() string

func (*WebProofChainLink) GetRemoteUsername ¶ 

func (w *WebProofChainLink) GetRemoteUsername() string

func (*WebProofChainLink) LastWriterWins ¶ 

func (w *WebProofChainLink) LastWriterWins() bool

func (*WebProofChainLink) ProofText ¶ 

func (w *WebProofChainLink) ProofText() string

func (*WebProofChainLink) TableKey ¶ 

func (w *WebProofChainLink) TableKey() string

func (*WebProofChainLink) ToDisplayString ¶ 

func (w *WebProofChainLink) ToDisplayString() string

func (*WebProofChainLink) ToIDString ¶ 

func (w *WebProofChainLink) ToIDString() string

func (*WebProofChainLink) ToKeyValuePair ¶ 

func (w *WebProofChainLink) ToKeyValuePair() (string, string)

func (*WebProofChainLink) ToTrackingStatement ¶ 

func (w *WebProofChainLink) ToTrackingStatement(state keybase1.ProofState) (*jsonw.Wrapper, error)

func (*WebProofChainLink) Type ¶ 

func (w *WebProofChainLink) Type() string

type WebServiceType ¶ 

type WebServiceType struct{ BaseServiceType }

func (WebServiceType) AllStringKeys ¶ 

func (t WebServiceType) AllStringKeys() []string

func (WebServiceType) CheckProofText ¶ 

func (t WebServiceType) CheckProofText(text string, id keybase1.SigID, sig string) (err error)

func (WebServiceType) CheckUsername ¶ 

func (t WebServiceType) CheckUsername(s string) error

func (WebServiceType) DisplayName ¶ 

func (t WebServiceType) DisplayName(un string) string

func (WebServiceType) GetAPIArgKey ¶ 

func (t WebServiceType) GetAPIArgKey() string

func (WebServiceType) GetPrompt ¶ 

func (t WebServiceType) GetPrompt() string

func (WebServiceType) GetProofType ¶ 

func (t WebServiceType) GetProofType() string

func (WebServiceType) GetTypeName ¶ 

func (t WebServiceType) GetTypeName() string

func (WebServiceType) LastWriterWins ¶ 

func (t WebServiceType) LastWriterWins() bool

func (WebServiceType) MarkupFilenames ¶ 

func (t WebServiceType) MarkupFilenames(un string, mkp *Markup)

func (WebServiceType) NormalizeUsername ¶ 

func (t WebServiceType) NormalizeUsername(s string) (ret string, err error)

func (WebServiceType) PostInstructions ¶ 

func (t WebServiceType) PostInstructions(un string) *Markup

func (WebServiceType) PreProofWarning ¶ 

func (t WebServiceType) PreProofWarning(un string) *Markup

func (WebServiceType) PrimaryStringKeys ¶ 

func (t WebServiceType) PrimaryStringKeys() []string

func (WebServiceType) RecheckProofPosting ¶ 

func (t WebServiceType) RecheckProofPosting(tryNumber int, status keybase1.ProofStatus, _ string) (warning *Markup, err error)

func (WebServiceType) ToChecker ¶ 

func (t WebServiceType) ToChecker() Checker

func (WebServiceType) ToServiceJSON ¶ 

func (t WebServiceType) ToServiceJSON(un string) *jsonw.Wrapper

type WebUnreachableError ¶ 

type WebUnreachableError struct {
	// contains filtered or unexported fields
}

func (WebUnreachableError) Error ¶ 

func (h WebUnreachableError) Error() string

type Win32 ¶ 

type Win32 struct {
	Base
}

func (Win32) CacheDir ¶ 

func (w Win32) CacheDir() string

func (Win32) ConfigDir ¶ 

func (w Win32) ConfigDir() string

func (Win32) DataDir ¶ 

func (w Win32) DataDir() string

func (Win32) Home ¶ 

func (w Win32) Home(emptyOk bool) string

func (Win32) LogDir ¶ 

func (w Win32) LogDir() string

func (Win32) Normalize ¶ 

func (w Win32) Normalize(s string) string

func (Win32) RuntimeDir ¶ 

func (w Win32) RuntimeDir() string

func (Win32) ServiceSpawnDir ¶ 

func (w Win32) ServiceSpawnDir() (string, error)

func (Win32) Split ¶ 

func (w Win32) Split(s string) []string

type WrongKeyError ¶ 

type WrongKeyError struct {
	// contains filtered or unexported fields
}

func (WrongKeyError) Error ¶ 

func (e WrongKeyError) Error() string

type WrongKidError ¶ 

type WrongKidError struct {
	// contains filtered or unexported fields
}

func (WrongKidError) Error ¶ 

func (w WrongKidError) Error() string

type WrongSigError ¶ 

type WrongSigError struct {
	// contains filtered or unexported fields
}

func (WrongSigError) Error ¶ 

func (e WrongSigError) Error() string

type XdgPosix ¶ 

type XdgPosix struct {
	Base
}

func (XdgPosix) CacheDir ¶ 

func (x XdgPosix) CacheDir() string

func (XdgPosix) ConfigDir ¶ 

func (x XdgPosix) ConfigDir() string

func (XdgPosix) DataDir ¶ 

func (x XdgPosix) DataDir() string

func (XdgPosix) Home ¶ 

func (x XdgPosix) Home(emptyOk bool) string

func (XdgPosix) LogDir ¶ 

func (x XdgPosix) LogDir() string

func (XdgPosix) Normalize ¶ 

func (x XdgPosix) Normalize(s string) string

func (XdgPosix) RuntimeDir ¶ 

func (x XdgPosix) RuntimeDir() string

func (XdgPosix) ServiceSpawnDir ¶ 

func (x XdgPosix) ServiceSpawnDir() (ret string, err error)

Source Files ¶

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.