libkb

package

Go to main page

Versions in this module

v1

v1.0.17

Aug 9, 2016

Changes in this version

+ const DBTrackers2

+ const DBTrackers2Reverse

+ const HTTPDefaultScraperTimeout

+ const HTTPRetryCount

+ const HTTPRetryInitialTimeout

+ const HTTPRetryMutliplier

+ const PaperKeyWordCountMin

+ const RemoteIdentifyUITimeout

+ const SCDecryptionError

+ const SCGenericAPIError

+ const SCKeyRevoked

+ func PlatformSpecificUpgradeInstructions(g *GlobalContext, upgradeURI string)

+ func SaferDLLLoading() error

type APIArg

+ InitialTimeout time.Duration

+ RetryCount int

+ RetryMultiplier float64

+ func NewAPIArg(g *GlobalContext, endpoint string) APIArg

+ func NewRetryAPIArg(g *GlobalContext, endpoint string) APIArg

type APIError

+ func (a *APIError) ToStatus() (s keybase1.Status)

type AppConfig

+ LogFile string

+ func (c AppConfig) GetLogFile() string

type AppStartMode

+ const AppStartModeDefault

+ const AppStartModeError

+ func ParseAppStartMode(s string) (AppStartMode, error)

type AssertionAnd

+ func (a AssertionAnd) NeedsParens() bool

type AssertionDNS

+ func (a AssertionDNS) CheckAndNormalize() (AssertionURL, error)

+ func (a AssertionDNS) IsRemote() bool

type AssertionExpression

+ NeedsParens func() bool

type AssertionFingerprint

+ func (a AssertionFingerprint) CheckAndNormalize() (AssertionURL, error)

type AssertionHTTP

+ func (a AssertionHTTP) CheckAndNormalize() (AssertionURL, error)

type AssertionHTTPS

+ func (a AssertionHTTPS) CheckAndNormalize() (AssertionURL, error)

type AssertionKeybase

+ func (a AssertionKeybase) CheckAndNormalize() (AssertionURL, error)

+ func (a AssertionKeybase) String() string

type AssertionOr

+ func (a AssertionOr) NeedsParens() bool

type AssertionSocial

+ func (a AssertionSocial) CheckAndNormalize() (AssertionURL, error)

+ func (a AssertionSocial) GetValue() string

type AssertionUID

+ func (a AssertionUID) CheckAndNormalize() (AssertionURL, error)

type AssertionURL

+ CheckAndNormalize func() (AssertionURL, error)

+ GetKey func() string

type AssertionURLBase

+ func (b AssertionURLBase) GetKey() string

+ func (b AssertionURLBase) NeedsParens() bool

type AssertionWeb

+ func (a AssertionWeb) CheckAndNormalize() (AssertionURL, error)

type CommandLine

+ GetAppStartMode func() string

+ GetGregorDisabled func() (bool, bool)

+ GetGregorPingInterval func() (time.Duration, bool)

+ GetGregorSaveInterval func() (time.Duration, bool)

+ GetGregorURI func() string

+ GetMountDir func() string

type ComputedKeyInfo

+ RevokedBy keybase1.KID

type ConfigReader

+ GetGregorDisabled func() (bool, bool)

+ GetGregorPingInterval func() (time.Duration, bool)

+ GetMountDir func() string

type ConnectionManager

+ func (c *ConnectionManager) LookupByClientType(clientType keybase1.ClientType) *rpc.Transporter

type DecryptionError

+ func (e DecryptionError) ToStatus() keybase1.Status

type DeviceKey

+ LastUsedTime int64

type Env

+ func (e *Env) GetGregorDisabled() bool

+ func (e *Env) GetGregorPingInterval() time.Duration

+ func (e *Env) GetKBFSInfoPath() string

type GlobalContext

+ GregorListener GregorListener

+ NewTriplesec func(pw []byte, salt []byte) (Triplesec, error)

+ OutOfDateInfo keybase1.OutOfDateInfo

+ func (g *GlobalContext) GetAppStartMode() (AppStartMode, error)

+ func (g *GlobalContext) GetConfigDir() string

+ func (g *GlobalContext) GetKBFSInfoPath() string

+ func (g *GlobalContext) GetLogDir() string

+ func (g *GlobalContext) GetLogf() logger.Loggerf

+ func (g *GlobalContext) GetMountDir() (string, error)

+ func (g *GlobalContext) GetServiceInfoPath() string

+ func (g *GlobalContext) LogoutIfRevoked() error

+ func (g *GlobalContext) NewRPCLogFactory() *RPCLogFactory

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

+ func (g *GlobalContext) SetClock(c clockwork.Clock)

type GpgCLI

+ func (g *GpgCLI) SemanticVersion() (*semver.Version, error)

+ func (g *GpgCLI) VersionAtLeast(s string) (bool, error)

+ type GregorFirehoseHandler interface

+ IsAlive func() bool

+ PushOutOfBandMessages func([]gregor1.OutOfBandMessage)

+ PushState func(gregor1.State, keybase1.PushReason)

+ type GregorInBandMessageHandler interface

+ Create func(ctx context.Context, cli gregor1.IncomingInterface, category string, ...) (bool, error)

+ Dismiss func(ctx context.Context, cli gregor1.IncomingInterface, category string, ...) (bool, error)

+ IsAlive func() bool

+ Name func() string

+ type GregorListener interface

+ PushFirehoseHandler func(handler GregorFirehoseHandler)

+ PushHandler func(handler GregorInBandMessageHandler)

type JSONConfigFile

+ func (f JSONConfigFile) GetGregorDisabled() (bool, bool)

+ func (f JSONConfigFile) GetGregorPingInterval() (time.Duration, bool)

+ func (f JSONConfigFile) GetMountDir() string

type KeyFamily

+ func (kf KeyFamily) Export() []keybase1.PublicKey

type KeyRevokedError

+ func (e KeyRevokedError) ToStatus() keybase1.Status

type KeybasePacket

+ func NewKeybasePacket(body interface{}, tag int, version int) (*KeybasePacket, error)

type LKSec

+ func (s *LKSec) LoadServerHalf(lctx LoginContext) (err error)

+ type LogSendContext struct

+ Logs Logs

+ func (l *LogSendContext) LogSend(statusJSON string, numLines int) (string, error)

type LoginState

+ func (s *LoginState) GetPassphraseStreamExport(ui SecretUI) (pps keybase1.PassphraseStream, err error)

+ type Logs struct

+ Desktop string

+ Install string

+ Kbfs string

+ Service string

+ Start string

+ Updater string

type NoSigChainError

+ func (e NoSigChainError) ToStatus() keybase1.Status

type NotifyListener

+ KeyfamilyChanged func(uid keybase1.UID)

+ PaperKeyCached func(uid keybase1.UID, encKID keybase1.KID, sigKID keybase1.KID)

type NotifyRouter

+ func (n *NotifyRouter) HandleAppExit()

+ func (n *NotifyRouter) HandleKeyfamilyChanged(uid keybase1.UID)

+ func (n *NotifyRouter) HandlePaperKeyCached(uid keybase1.UID, encKID keybase1.KID, sigKID keybase1.KID)

+ func (n *NotifyRouter) HandleServiceShutdown()

type NullConfiguration

+ func (n NullConfiguration) GetGregorDisabled() (bool, bool)

+ func (n NullConfiguration) GetGregorPingInterval() (time.Duration, bool)

+ func (n NullConfiguration) GetMountDir() string

type PaperKeyPhrase

+ func (p PaperKeyPhrase) NumWords() int

type PassphraseStream

+ func NewPassphraseStreamLKSecOnly(s []byte) (*PassphraseStream, error)

type PassphraseStreamCache

+ func (s *PassphraseStreamCache) ValidPassphraseStream() bool

+ func (s *PassphraseStreamCache) ValidTsec() bool

type PromptArg

+ ShowTyping bool

type ResolveResult

+ func (res *ResolveResult) WasKBAssertion() bool

type RevokedKey

+ RevokedBy keybase1.KID

+ type TrackDiffSnoozedRevoked struct

+ func (t TrackDiffSnoozedRevoked) BreaksTracking() bool

+ func (t TrackDiffSnoozedRevoked) GetTrackDiffType() keybase1.TrackDiffType

+ func (t TrackDiffSnoozedRevoked) IsSameAsTracked() bool

+ func (t TrackDiffSnoozedRevoked) ToDisplayMarkup() *Markup

+ func (t TrackDiffSnoozedRevoked) ToDisplayString() string

+ type Tracker2Syncer struct

+ func NewTracker2Syncer(g *GlobalContext) *Tracker2Syncer

+ func (t *Tracker2Syncer) Result() keybase1.UserSummary2Set

+ type Triplesec interface

+ Decrypt func([]byte) ([]byte, error)

+ DeriveKey func(l int) ([]byte, []byte, error)

+ Encrypt func([]byte) ([]byte, error)

+ Scrub func()

+ func NewSecureTriplesec(passphrase []byte, salt []byte) (Triplesec, error)

type UIKind

+ const RekeyUIKind

type UIRouter

+ GetRekeyUI func() (keybase1.RekeyUIInterface, int, error)

+ GetRekeyUINoSessionID func() (keybase1.RekeyUIInterface, error)

+ type UnforwardedLoggerWithLegacyInterface interface

+ Debug func(s string, args ...interface{})

+ Error func(s string, args ...interface{})

+ Errorf func(s string, args ...interface{})

+ Info func(s string, args ...interface{})

+ Profile func(s string, args ...interface{})

+ Warning func(s string, args ...interface{})

type User

+ func LoadUserFromServer(g *GlobalContext, uid keybase1.UID, body *jsonw.Wrapper) (u *User, err error)

+ type UserPlusKeysMemo struct

+ func NewUserPlusKeysMemo(g *GlobalContext) *UserPlusKeysMemo

+ func (u *UserPlusKeysMemo) Clear()

+ func (u *UserPlusKeysMemo) Get(uid keybase1.UID) (keybase1.UserPlusKeys, bool)

+ func (u *UserPlusKeysMemo) Set(upk keybase1.UserPlusKeys)

v1.0.16

May 23, 2016

Changes in this version

+ const DBGregor

+ const DevelGregorServerURI

+ const ProductionGregorServerURI

+ const SCGPGUnavailable

+ const SCThrottleControl

+ const StagingGregorServerURI

+ const UpdaterConfigFile

+ const UpdaterLogFileName

+ const WhichPassphraseKeybase

+ var ErrSecretForUserNotFound = NotFoundError

+ var GregorServerLookup = map[RunMode]string

+ func GetPassphraseUntilCheckWithChecker(g *GlobalContext, arg keybase1.GUIEntryArg, prompter PassphrasePrompter, ...) (keybase1.GetPassphraseRes, error)

+ func IsExecError(err error) bool

+ type CheckerWrapper struct

+ func (w *CheckerWrapper) Check(_ *GlobalContext, s string) error

type CoinbaseServiceType

+ func (t CoinbaseServiceType) NormalizeRemoteName(s string) (ret string, err error)

+ func (t CoinbaseServiceType) PreProofCheck(normalizedUsername string) (*Markup, error)

type CommandLine

+ GetUpdaterConfigFilename func() string

type ConfigReader

+ GetGregorSaveInterval func() (time.Duration, bool)

+ GetGregorURI func() string

+ GetUpdateDisabled func() (bool, bool)

+ GetUpdaterConfigFilename func() string

type DNSServiceType

+ func (t DNSServiceType) NormalizeRemoteName(s string) (string, error)

+ type DirExecError struct

+ Path string

+ func (e DirExecError) Error() string

type Env

+ func (e *Env) GetGregorSaveInterval() time.Duration

+ func (e *Env) GetGregorURI() string

+ func (e *Env) GetInstallID() (ret InstallID)

+ func (e *Env) GetUpdateDisabled() (bool, bool)

+ func (e *Env) GetUpdaterConfig() UpdaterConfigReader

+ func (e *Env) GetUpdaterConfigFilename() string

+ func (e *Env) SetUpdaterConfig(r UpdaterConfigReader)

+ type FakeGregorDismisser struct

+ func (f *FakeGregorDismisser) DismissItem(id gregor.MsgID) error

+ type FileExecError struct

+ Path string

+ func (e FileExecError) Error() string

+ type GPGUnavailableError struct

+ func (e GPGUnavailableError) ToStatus() keybase1.Status

+ func (g GPGUnavailableError) Error() string

type GithubServiceType

+ func (t GithubServiceType) NormalizeRemoteName(s string) (ret string, err error)

+ func (t GithubServiceType) NormalizeUsername(s string) (string, error)

type GlobalContext

+ GregorDismisser GregorDismisser

+ func (g *GlobalContext) AddLoginHook(hook LoginHook)

+ func (g *GlobalContext) AddLogoutHook(hook LogoutHook)

+ func (g *GlobalContext) CallLoginHooks()

+ func (g *GlobalContext) CallLogoutHooks()

+ func (g *GlobalContext) ConfigureUpdaterConfig() error

+ func (g *GlobalContext) GetLog() logger.Logger

+ type GregorDismisser interface

+ DismissItem func(id gregor.MsgID) error

type HackerNewsServiceType

+ func (t HackerNewsServiceType) NormalizeRemoteName(s string) (string, error)

type IdentifyOutcome

+ ResponsibleGregorItem gregor.Item

type IdentifyState

+ func NewIdentifyStateWithGregorItem(item gregor.Item, u *User) IdentifyState

type IdentifyUI

+ Dismiss func(string, keybase1.DismissReason)

+ DisplayTLFCreateWithInvite func(keybase1.DisplayTLFCreateWithInviteArg) error

+ type InstallID string

+ func (i InstallID) Exists() bool

+ func (i InstallID) String() string

+ type Invitation struct

+ ID string

+ ShortCode string

+ Throttled bool

+ func GenerateInvitationCode(g *GlobalContext, arg InviteArg) (*Invitation, error)

+ func GenerateInvitationCodeForAssertion(g *GlobalContext, assertion keybase1.SocialAssertion, arg InviteArg) (*Invitation, error)

+ func SendInvitation(g *GlobalContext, email string, arg InviteArg) (*Invitation, error)

+ func (i Invitation) Link() string

+ type InviteArg struct

+ Message string

+ NoteToSelf string

+ func (i InviteArg) ToHTTPArgs() HTTPArgs

type JSONConfigFile

+ func (f JSONConfigFile) GetGregorSaveInterval() (time.Duration, bool)

+ func (f JSONConfigFile) GetGregorURI() string

+ func (f JSONConfigFile) GetUpdateDisabled() (bool, bool)

+ func (f JSONConfigFile) GetUpdaterConfigFilename() string

type JSONLocalDb

+ func (j *JSONLocalDb) GetRaw(id DbKey) ([]byte, bool, error)

+ func (j *JSONLocalDb) PutRaw(id DbKey, b []byte) error

+ type JSONUpdaterConfigFile struct

+ func NewJSONUpdaterConfigFile(g *GlobalContext) *JSONUpdaterConfigFile

+ func (j JSONUpdaterConfigFile) GetInstallID() (ret InstallID)

type KeychainSecretStore — darwin/amd64

+ func (k KeychainSecretStore) GetApprovalPrompt() string

+ func (k KeychainSecretStore) GetTerminalPrompt() string

+ type LoginHook interface

+ OnLogin func() error

+ type LogoutHook interface

+ OnLogout func() error

type NotFoundError

+ func (e NotFoundError) ToStatus() keybase1.Status

+ type NotifyListener interface

+ ClientOutOfDate func(to, uri, msg string)

+ FSActivity func(activity keybase1.FSNotification)

+ FavoritesChanged func(uid keybase1.UID)

+ Login func(username string)

+ Logout func()

+ TrackingChanged func(uid keybase1.UID, username string)

+ UserChanged func(uid keybase1.UID)

type NotifyRouter

+ func (n *NotifyRouter) HandleFavoritesChanged(uid keybase1.UID)

+ func (n *NotifyRouter) SetListener(listener NotifyListener)

type NullConfiguration

+ func (n NullConfiguration) GetGregorSaveInterval() (time.Duration, bool)

+ func (n NullConfiguration) GetGregorURI() string

+ func (n NullConfiguration) GetUpdateDisabled() (bool, bool)

+ func (n NullConfiguration) GetUpdaterConfigFilename() string

+ type PaperChecker struct

+ func (p *PaperChecker) Check(g *GlobalContext, s string) error

type PaperKeyPhrase

+ func (p PaperKeyPhrase) InvalidWords() (words []string)

+ type PassphraseChecker interface

+ Check func(*GlobalContext, string) error

type RedditServiceType

+ func (t RedditServiceType) NormalizeRemoteName(s string) (ret string, err error)

+ func (t RedditServiceType) NormalizeUsername(s string) (string, error)

type RooterServiceType

+ func (t RooterServiceType) NormalizeRemoteName(s string) (string, error)

+ type SaltpackVerifyContext interface

+ GetLog func() logger.Logger

type SecretStoreAll

+ GetApprovalPrompt func() string

+ GetTerminalPrompt func() string

+ type SecretStoreFile struct

+ func NewSecretStoreFile(dir string) *SecretStoreFile

+ func (s *SecretStoreFile) ClearSecret(username NormalizedUsername) error

+ func (s *SecretStoreFile) GetApprovalPrompt() string

+ func (s *SecretStoreFile) GetTerminalPrompt() string

+ func (s *SecretStoreFile) GetUsersWithStoredSecrets() ([]string, error)

+ func (s *SecretStoreFile) RetrieveSecret(username NormalizedUsername) ([]byte, error)

+ func (s *SecretStoreFile) StoreSecret(username NormalizedUsername, secret []byte) error

type ServiceType

+ NormalizeRemoteName func(string) (string, error)

type TestParameters

+ UseProductionRunMode bool

type TestSecretStoreAll — js/wasm, linux/amd64, windows/amd64

+ func (t TestSecretStoreAll) GetApprovalPrompt() string

+ func (t TestSecretStoreAll) GetTerminalPrompt() string

type TwitterServiceType

+ func (t TwitterServiceType) NormalizeRemoteName(s string) (string, error)

+ type UpdaterConfigReader interface

+ GetInstallID func() InstallID

type WebServiceType

+ func (t WebServiceType) NormalizeRemoteName(s string) (ret string, err error)

v1.0.15

Mar 31, 2016

Changes in this version

+ const AND

+ const APIURIPathPrefix

+ const APIVersion

+ const AuthExpireIn

+ const AuthenticationType

+ const CanonicalHost

+ const ConfigFile

+ const CryptocurrencyType

+ const DBFile

+ const DBLink

+ const DBLocalTrack

+ const DBLookupMerkleRoot

+ const DBLookupUsername

+ const DBMerkleRoot

+ const DBPGPKey

+ const DBProofCheck

+ const DBSig

+ const DBSigChainTailEncrypted

+ const DBSigChainTailPublic

+ const DBSigChainTailSemiprivate

+ const DBSigHints

+ const DBTrackers

+ const DBUser

+ const DBUserSecretKeys

+ const DaemonPort

+ const DefaultRunMode

+ const DesktopLogFileName

+ const DevelRunMode

+ const DevelServerURI

+ const DeviceIDLen

+ const DeviceIDSuffix

+ const DeviceStatusActive

+ const DeviceStatusDefunct

+ const DeviceStatusNone

+ const DeviceTypeDesktop

+ const DeviceTypeMobile

+ const DeviceTypePaper

+ const DownloadURL

+ const EOF

+ const ERROR

+ const EldestType

+ const GoClientID

+ const HTTPDefaultTimeout

+ const HTTPPollMaximum

+ const HashPGPMd5

+ const HashPGPRipemd160

+ const HashPGPSha1

+ const HashPGPSha224

+ const HashPGPSha256

+ const HashPGPSha384

+ const HashPGPSha512

+ const IDSuffixKID

+ const Identify2CacheLongTimeout

+ const Identify2CacheShortTimeout

+ const IdentifySourceKBFS

+ const IsBrewBuild

+ const KBFSLogFileName

+ const KIDNaclDH

+ const KIDNaclEddsa

+ const KIDPGPBase

+ const KIDPGPDsa

+ const KIDPGPEcdh

+ const KIDPGPEcdsa

+ const KIDPGPElgamal

+ const KIDPGPRsa

+ const Kex2PhraseEntropy

+ const Kex2ScryptCost

+ const Kex2ScryptKeylen

+ const Kex2ScryptP

+ const Kex2ScryptR

+ const KexScryptCost

+ const KexScryptKeylen

+ const KexScryptP

+ const KexScryptR

+ const KexSessionIDEntropy

+ const KeyExpireIn

+ const KeyTypeKbNaclDH

+ const KeyTypeKbNaclDHServerHalf

+ const KeyTypeKbNaclEddsa

+ const KeyTypeKbNaclEddsaServerHalf

+ const KeyTypeNone

+ const KeyTypeOpenPGPPublic

+ const KeyTypeP3skbPrivate

+ const KeybaseKIDV1

+ const KeybasePacketV1

+ const KeybaseSaltpackBrand

+ const KeybaseSignatureV1

+ const LKSecVersion

+ const LPAREN

+ const LinkCacheCleanDur

+ const LinkCacheSize

+ const LinkIDLen

+ const LocalTrackMaxAge

+ const LoginSessionMemoryTimeout

+ const MerkleTreeLeaf

+ const MerkleTreeNode

+ const MinPassphraseLength

+ const NONE

+ const NaclDHExpireIn

+ const NaclDHKeySecretSize

+ const NaclDHKeysize

+ const NaclDHNonceSize

+ const NaclEdDSAExpireIn

+ const NaclSigningKeySecretSize

+ const NoRunMode

+ const NodeHashLenLong

+ const NodeHashLenShort

+ const OR

+ const OneYearInSeconds

+ const PGPAssertionKey

+ const PGPFingerprintHexLen

+ const PGPFingerprintLen

+ const PGPUpdateType

+ const PIDFile

+ const PaperKeyIDBits

+ const PaperKeyMemoryTimeout

+ const PaperKeyScryptCost

+ const PaperKeyScryptKeylen

+ const PaperKeyScryptP

+ const PaperKeyScryptR

+ const PaperKeySecretEntropy

+ const PaperKeyVersion

+ const PaperKeyVersionBits

+ const PermDir

+ const PermFile

+ const ProductionRunMode

+ const ProductionServerURI

+ const ProofCacheLongDur

+ const ProofCacheMediumDur

+ const ProofCacheShortDur

+ const ProofCacheSize

+ const RPAREN

+ const RedditPrefix

+ const RedditSub

+ const RevDated

+ const RevFull

+ const RevSimpleDelete

+ const RevokeType

+ const RunModeError

+ const SCAPINetworkError

+ const SCAlreadyLoggedIn

+ const SCBadInvitationCode

+ const SCBadKexPhrase

+ const SCBadLoginPassword

+ const SCBadLoginUserNotFound

+ const SCBadSession

+ const SCBadSignupUsernameTaken

+ const SCBadTrackSession

+ const SCCanceled

+ const SCDecryptionKeyNotFound

+ const SCDeviceMismatch

+ const SCDeviceNoProvision

+ const SCDeviceNotFound

+ const SCDevicePrevProvisioned

+ const SCDeviceRequired

+ const SCGeneric

+ const SCIdentificationExpired

+ const SCIdentifyFailed

+ const SCInputCanceled

+ const SCKeyBadEldest

+ const SCKeyBadGen

+ const SCKeyBadSig

+ const SCKeyBadUIDs

+ const SCKeyDuplicateUpdate

+ const SCKeyInUse

+ const SCKeyNoActive

+ const SCKeyNoEldest

+ const SCKeyNoMatchingGPG

+ const SCKeyNoNaClEncryption

+ const SCKeyNoPGPEncryption

+ const SCKeyNoSecret

+ const SCKeyNoSig

+ const SCKeyNotFound

+ const SCKeySyncedPGPNotFound

+ const SCLoginRequired

+ const SCMissingResult

+ const SCNoUI

+ const SCNoUIDelegation

+ const SCNotFound

+ const SCOk

+ const SCProfileNotPublic

+ const SCProofError

+ const SCReloginRequired

+ const SCResolutionFailed

+ const SCSelfNotFound

+ const SCSibkeyAlreadyExists

+ const SCStreamEOF

+ const SCStreamExists

+ const SCStreamNotFound

+ const SCStreamWrongKind

+ const SCTimeout

+ const SCTrackingBroke

+ const SCWrongCryptoFormat

+ const SHA256Code

+ const SecretKeyringTemplate

+ const SecretPromptCancelDuration

+ const ServerUpdateLag

+ const ServiceLogFileName

+ const SessionFile

+ const SibkeyType

+ const SigExpireIn

+ const SigKbEddsa

+ const SigShortIDBytes

+ const SigTypeAnnouncement

+ const SigTypeCryptocurrency

+ const SigTypeNone

+ const SigTypeRemoteProof

+ const SigTypeRevoke

+ const SigTypeSelfSig

+ const SigTypeTrack

+ const SigTypeUntrack

+ const SocketFile

+ const StagingRunMode

+ const StagingServerURI

+ const StartLogFileName

+ const SubkeyExpireIn

+ const SubkeyType

+ const TagEncryption

+ const TagP3skb

+ const TagSignature

+ const TestInvitationCode

+ const TorServerURI

+ const TrackStatusNone

+ const TrackStatusTracking

+ const TrackType

+ const TrackingRateLimitSeconds

+ const URL

+ const UmaskablePermFile

+ const UntrackType

+ const UpdatePassphraseType

+ const UserCacheMaxAge

+ const UserSummaryLimit

+ const Version

+ const WebServiceBindingType

+ const XAPIResHTML

+ const XAPIResJSON

+ const XAPIResText

+ var AllDeviceTypes = DeviceTypeSet

+ var BundledCAs = map[string]string

+ var CheckDeviceName = Checker

+ var CheckEmail = Checker

+ var CheckEmailOrUsername = Checker

+ var CheckInviteCode = Checker

+ var CheckKex2SecretPhrase = Checker

+ var CheckNotEmpty = Checker

+ var CheckPassphraseNew = Checker

+ var CheckPassphraseSimple = Checker

+ var CheckUsername = Checker

+ var CheckYesNo = Checker

+ var CodeSigningProdKIDs = []string

+ var CodeSigningStagingKIDs = []string

+ var CodeSigningTestKIDs = []string

+ var DefaultDeviceTypes = DeviceTypeSet

+ var ErrCannotPeek = errors.New("Cannot peek after read")

+ var ErrLoginSessionCleared = errors.New("LoginSession already cleared")

+ var ErrLoginSessionNotLoaded = errors.New("LoginSession not loaded")

+ var ErrNilUser = errors.New("User is nil")

+ var ErrTrackingExpired = errors.New("Local track expired")

+ var FOLDERID_RoamingAppData = GUID — windows/amd64

+ var MerkleProdKIDs = []string

+ var MerkleStagingKIDs = []string

+ var MerkleTestKIDs = []string

+ var PGPArmorHeaders = map[string]string

+ var PGPVersion = "Keybase Go " + Version + " (" + runtime.GOOS + ")"

+ var PrereleaseBuild string

+ var ProofErrorDNSOverTor = &ProofErrorImpl

+ var ProofErrorHTTPOverTor = &ProofErrorImpl

+ var PublicChain = &ChainType

+ var RemoteServiceOrder = []keybase1.ProofType

+ var RemoteServiceTypes = map[string]keybase1.ProofType

+ var RunModes = []RunMode

+ var ServerLookup = map[RunMode]string

+ var TorProxy = "localhost:9050"

+ var UserAgent = runtime.GOOS + ":" + "Keybase CLI (" + runtime.Version() + "):" + Version

+ func APIBase(un string) string

+ func AddToProofSetNoChecks(r RemoteProofChainLink, ps *ProofSet)

+ func AppDataDir() (string, error) — darwin/amd64, linux/amd64, windows/amd64

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

+ func BoxPublicKeyToKeybaseKID(k saltpack.BoxPublicKey) (ret keybase1.KID)

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

+ func CanEncrypt(key GenericKey) bool

+ func CanonicalProofName(t TypedChainLink) string

+ func CheckInvitationCode(code string) error

+ func CheckKarma(un string) (int, error)

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

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

+ func CheckTracking(g *GlobalContext) error

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

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

+ func Cicmp(s1, s2 string) bool

+ func ClearStoredSecret(g *GlobalContext, username NormalizedUsername) error

+ func CollectAssertions(e AssertionExpression) (remotes AssertionAnd, locals AssertionAnd)

+ func CombineErrors(errs ...error) error

+ func ComputeSigIDFromSigBody(body []byte) keybase1.SigID

+ func Contains(s string, list []string) bool

+ func DebugDumpKey(g *GlobalContext, name string, b []byte)

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

+ func DefaultPassphraseArg(allowSecretStore bool) keybase1.GUIEntryArg

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

+ func DeletePrimary() (err error)

+ func DeviceStatusToString(i *int) string

+ func Digest(r io.Reader) (string, error)

+ func DigestForFileAtPath(path string) (string, error)

+ func DiscardAndCloseBody(resp *http.Response) error

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

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

+ func Encode58(inp []byte) string

+ func ErrToOk(err error) string

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

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

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

+ func ExportRemoteProof(p RemoteProofChainLink) keybase1.RemoteProof

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

+ func ExportTrackIDComponentToRevokedProof(tidc TrackIDComponent) keybase1.RevokedProof

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

+ func FastByteArrayEq(a, b []byte) bool

+ func FileExists(path string) (bool, error)

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

+ func FindBase64Blocks(s string) []string

+ func FindBase64Snippets(s string) []string

+ func FindBestIdentifyComponent(e AssertionExpression) string

+ func FindFirstBase64Block(s string) string

+ func FormatTime(tm time.Time) string

+ func GenericKeyEqual(k1, k2 GenericKey) bool

+ func GetConfiguredAccounts(c SecretStoreContext, s SecretStoreAll) ([]keybase1.ConfiguredAccount, error)

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

+ func GetKeybasePassphrase(ui SecretUI, username, retryMsg string, allowSecretStore bool) (keybase1.GetPassphraseRes, error)

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

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

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

+ func GetPaperKeyForCryptoPassphrase(ui SecretUI, reason string, devices []*Device) (string, error)

+ func GetPaperKeyPassphrase(ui SecretUI, username string) (string, error)

+ func GetPassphraseUntilCheck(arg keybase1.GUIEntryArg, prompter PassphrasePrompter, checker *Checker) (keybase1.GetPassphraseRes, error)

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

+ func GetSecret(ui SecretUI, title, prompt, retryMsg string, allowSecretStore bool) (keybase1.GetPassphraseRes, error)

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

+ func GetTerminalPrompt() string

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

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

+ func GiveMeAnS(i int) string

+ func HasSecretStore() bool — darwin/amd64

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

+ func ImportStatusAsError(s *keybase1.Status) error

+ func IsArmored(buf []byte) bool

+ func IsDirEmpty(dir string) (bool, error)

+ func IsEmpty(s string) bool

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

+ func IsNo(s string) bool

+ func IsPGP(key GenericKey) bool

+ func IsPGPAlgo(algo AlgoType) bool

+ func IsSocialAssertion(s string) bool

+ func IsSocketClosedError(e error) bool

+ func IsSystemAdminUser() (isAdminUser bool, match string, err error)

+ func IsValidHostname(s string) bool

+ func IsYes(s string) bool

+ func JoinPredicate(arr []string, delimeter string, f func(s string) bool) string

+ func KIDIsDeviceEncrypt(kid keybase1.KID) bool

+ func KIDIsDeviceVerify(kid keybase1.KID) bool

+ func KarmaURL(un string) string

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

+ func KeyLookupByBoxPublicKey(g *GlobalContext, k saltpack.BoxPublicKey) (username string, uid keybase1.UID, err error)

+ func KeyLookupKID(g *GlobalContext, k keybase1.KID) (username string, uid keybase1.UID, err error)

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

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

+ func KeybaseEmailAddress(s string) string

+ func ListProofCheckers() (proofCheckers []string)

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

+ func MakeParentDirs(filename string) error

+ func MakeURI(prot string, host string) string

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

+ func NameCmp(n1, n2 string) bool

+ func NameTrim(s string) string

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

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

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

+ func NewDeviceID() (keybase1.DeviceID, error)

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

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

+ func NewLoopbackConnPair() (*LoopbackConn, *LoopbackConn)

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

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

+ func NewTransportFromSocket(g *GlobalContext, s net.Conn) rpc.Transporter

+ func NewTwitterChecker(p RemoteProofChainLink) (*TwitterChecker, ProofError)

+ func NewTypedChainLink(cl *ChainLink) (ret TypedChainLink, w Warning)

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

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

+ func OpenTempFile(prefix string, suffix string, mode os.FileMode) (string, *os.File, error)

+ func PGPEncrypt(source io.Reader, sink io.WriteCloser, signer *PGPKeyBundle, ...) error

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

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

+ func PGPLookup(g *GlobalContext, id uint64) (username string, uid keybase1.UID, err error)

+ func PGPLookupFingerprint(g *GlobalContext, fp *PGPFingerprint) (username string, uid keybase1.UID, err error)

+ func PGPLookupHex(g *GlobalContext, hexID string) (username string, uid keybase1.UID, err error)

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

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

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

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

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

+ func PickFirstError(errors ...error) error

+ func PlatformSpecificUpgradeInstructionsString() (string, error)

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

+ func PosixLineEndings(arg string) string — darwin/amd64, linux/amd64, windows/amd64

+ func PostDeviceLKS(sr SessionReader, deviceID keybase1.DeviceID, deviceType string, ...) error

+ func PostInviteRequest(arg InviteRequestArg) (err error)

+ func ProofErrorIsSoft(pe ProofError) bool

+ func ProofErrorToState(pe ProofError) keybase1.ProofState

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

+ func RandInt() (int, error)

+ func RandInt64() (int64, error)

+ func RandIntn(n int) int

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

+ func RegisterMakeProofCheckerFunc(s string, h MakeProofCheckerFunc)

+ func RegisterServiceType(st ServiceType)

+ func RegisterSocialNetwork(s string)

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

+ func RemoveNilErrors(errs []error) []error

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

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

+ func SaltpackDecrypt(g *GlobalContext, source io.Reader, sink io.WriteCloser, ...) (*saltpack.MessageKeyInfo, error)

+ func SaltpackEncrypt(g *GlobalContext, arg *SaltpackEncryptArg) error

+ func SaltpackSign(g *GlobalContext, source io.ReadCloser, sink io.WriteCloser, ...) error

+ func SaltpackSignDetached(g *GlobalContext, source io.ReadCloser, sink io.WriteCloser, ...) error

+ func SaltpackVerify(g *GlobalContext, source io.Reader, sink io.WriteCloser, ...) error

+ func SaltpackVerifyDetached(g *GlobalContext, message io.Reader, signature []byte, ...) error

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

+ func SecureByteArrayEq(a, b []byte) bool

+ func ShortCA(raw string) string

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

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

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

+ func SigningPublicKeyToKeybaseKID(k saltpack.SigningPublicKey) (ret keybase1.KID)

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

+ func SplitByRunes(s string, separators []rune) []string

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

+ func SplitPath(s string) []string

+ func StoreLocalTrack(tracker keybase1.UID, trackee keybase1.UID, expiringLocal bool, ...) error

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

+ func TempFile(prefix string) (string, error)

+ func TempFileName(prefix string) (tmp string, err error)

+ func TimeLog(name string, start time.Time, out func(string, ...interface{}))

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

+ func Trace(log logger.Logger, msg string, f func() error) func()

+ func TrimCicmp(s1, s2 string) bool

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

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

+ func Uniquify(inp []string) []string

+ func UnixToTimeMappingZero(unixTime int64) time.Time

+ func Unquote(data []byte) string

+ func UsernameToUID(s string) keybase1.UID

+ func UsernameToUIDPreserveCase(s string) keybase1.UID

+ func ValidSocialNetwork(s string) bool

+ func VersionMessage(linefn func(string))

+ func VersionString() string

+ func WhitespaceNormalize(s string) string

+ func WrapError(e error) interface

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

+ type API interface

+ Get func(APIArg) (*APIRes, error)

+ GetDecode func(APIArg, APIResponseWrapper) error

+ GetResp func(APIArg) (*http.Response, error)

+ Post func(APIArg) (*APIRes, error)

+ PostDecode func(APIArg, APIResponseWrapper) error

+ PostJSON func(APIArg) (*APIRes, error)

+ PostRaw func(APIArg, string, io.Reader) (*APIRes, error)

+ PostResp func(APIArg) (*http.Response, error)

+ type APIArg struct

+ AppStatusCodes []int

+ Args HTTPArgs

+ Endpoint string

+ HTTPStatus []int

+ JSONPayload JSONPayload

+ NeedSession bool

+ SessionR SessionReader

+ type APIError struct

+ Code int

+ Msg string

+ func NewAPIErrorFromHTTPResponse(r *http.Response) *APIError

+ func (a *APIError) Error() string

+ type APINetError struct

+ func (e APINetError) Error() string

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

+ type APIRes struct

+ AppStatus *AppStatus

+ Body *jsonw.Wrapper

+ HTTPStatus int

+ Status *jsonw.Wrapper

+ type APIResponseWrapper interface

+ GetAppStatus func() *AppStatus

+ type APIStatus struct

+ Code int

+ Name string

+ type Account struct

+ func NewAccount(g *GlobalContext) *Account

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

+ func (a *Account) ClearCachedSecretKeys()

+ func (a *Account) ClearKeyring()

+ func (a *Account) ClearLoginSession()

+ func (a *Account) ClearStreamCache()

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

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

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

+ func (a *Account) Dump()

+ func (a *Account) EnsureUsername(username NormalizedUsername)

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

+ func (a *Account) GetUID() (ret keybase1.UID)

+ func (a *Account) GetUnlockedPaperEncKey() GenericKey

+ func (a *Account) GetUnlockedPaperSigKey() GenericKey

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

+ func (a *Account) LKSec() *LKSec

+ func (a *Account) LKSecUnlock(locked []byte) ([]byte, PassphraseGeneration, error)

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

+ func (a *Account) LocalSession() *Session

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

+ func (a *Account) LoggedIn() bool

+ func (a *Account) LoggedInAndProvisioined() bool

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

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

+ func (a *Account) LoginSession() *LoginSession

+ func (a *Account) Logout() error

+ func (a *Account) PassphraseStream() *PassphraseStream

+ func (a *Account) PassphraseStreamCache() *PassphraseStreamCache

+ func (a *Account) PassphraseStreamRef() *PassphraseStream

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

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

+ func (a *Account) SecretPromptCanceled()

+ func (a *Account) SecretSyncer() *SecretSyncer

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

+ func (a *Account) SetLKSec(lks *LKSec)

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

+ func (a *Account) SetTestPostCleanHook(f func())

+ func (a *Account) SetUnlockedPaperKey(sig GenericKey, enc GenericKey) error

+ func (a *Account) Shutdown() error

+ func (a *Account) SkipSecretPrompt() bool

+ func (a *Account) UnloadLocalSession()

+ func (a *Account) UserInfo() (uid keybase1.UID, username NormalizedUsername, token string, ...)

+ type AlgoType int

+ type AlreadyRegisteredError struct

+ UID keybase1.UID

+ func (u AlreadyRegisteredError) Error() string

+ type AppConfig struct

+ Debug bool

+ HomeDir string

+ LocalRPCDebug string

+ RunMode RunMode

+ SecurityAccessGroupOverride bool

+ ServerURI string

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

+ func (c AppConfig) GetHome() string

+ func (c AppConfig) GetLocalRPCDebug() string

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

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

+ func (c AppConfig) GetServerURI() string

+ type AppStartMode string

+ const AppStartModeDisabled

+ const AppStartModeService

+ type AppStatus struct

+ Code int

+ Desc string

+ Fields map[string]string

+ Name string

+ type AppStatusError struct

+ Code int

+ Desc string

+ Fields map[string]string

+ Name string

+ func NewAppStatusError(ast *AppStatus) AppStatusError

+ func (a AppStatusError) Error() string

+ func (a AppStatusError) IsBadField(s string) bool

+ func (a AppStatusError) ToStatus() keybase1.Status

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

+ type AssertionAnd struct

+ func NewAssertionAnd(left, right AssertionExpression) AssertionAnd

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

+ func (a AssertionAnd) HasFactor(pf Proof) bool

+ func (a AssertionAnd) HasOr() bool

+ func (a AssertionAnd) Len() int

+ func (a AssertionAnd) MatchSet(ps ProofSet) bool

+ func (a AssertionAnd) String() string

+ type AssertionDNS struct

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

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

+ func (a AssertionDNS) MatchSet(ps ProofSet) bool

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

+ type AssertionExpression interface

+ CollectUrls func([]AssertionURL) []AssertionURL

+ HasOr func() bool

+ MatchSet func(ps ProofSet) bool

+ String func() string

+ func AssertionParse(s string) (AssertionExpression, error)

+ func AssertionParseAndOnly(s string) (AssertionExpression, error)

+ type AssertionFingerprint struct

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

+ func (a AssertionFingerprint) IsFingerprint() bool

+ func (a AssertionFingerprint) MatchProof(proof Proof) bool

+ func (a AssertionFingerprint) MatchSet(ps ProofSet) bool

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

+ type AssertionHTTP struct

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

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

+ func (a AssertionHTTP) IsRemote() bool

+ func (a AssertionHTTP) Keys() []string

+ func (a AssertionHTTP) MatchSet(ps ProofSet) bool

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

+ type AssertionHTTPS struct

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

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

+ func (a AssertionHTTPS) IsRemote() bool

+ func (a AssertionHTTPS) MatchSet(ps ProofSet) bool

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

+ type AssertionKeybase struct

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

+ func (a AssertionKeybase) IsKeybase() bool

+ func (a AssertionKeybase) MatchSet(ps ProofSet) bool

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

+ type AssertionOr struct

+ func NewAssertionOr(left, right AssertionExpression) AssertionOr

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

+ func (a AssertionOr) HasOr() bool

+ func (a AssertionOr) MatchSet(ps ProofSet) bool

+ func (a AssertionOr) String() string

+ type AssertionParseError struct

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

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

+ func (e AssertionParseError) Error() string

+ type AssertionSocial struct

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

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

+ func (a AssertionSocial) IsRemote() bool

+ func (a AssertionSocial) IsSocial() bool

+ func (a AssertionSocial) MatchSet(ps ProofSet) bool

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

+ type AssertionUID struct

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

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

+ func (a AssertionUID) IsUID() bool

+ func (a AssertionUID) MatchSet(ps ProofSet) bool

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

+ func (a AssertionUID) ToUID() keybase1.UID

+ type AssertionURL interface

+ CacheKey func() string

+ Check func() error

+ GetValue func() string

+ IsFingerprint func() bool

+ IsKeybase func() bool

+ IsRemote func() bool

+ IsSocial func() bool

+ IsUID func() bool

+ Keys func() []string

+ MatchProof func(p Proof) bool

+ ToKeyValuePair func() (string, string)

+ ToLookup func() (string, string, error)

+ ToUID func() keybase1.UID

+ func FindBestIdentifyComponentURL(e AssertionExpression) AssertionURL

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

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

+ type AssertionURLBase struct

+ Key string

+ Value string

+ func (b AssertionURLBase) CacheKey() string

+ func (b AssertionURLBase) Check() error

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

+ func (b AssertionURLBase) GetValue() string

+ func (b AssertionURLBase) HasOr() bool

+ func (b AssertionURLBase) IsFingerprint() bool

+ func (b AssertionURLBase) IsKeybase() bool

+ func (b AssertionURLBase) IsRemote() bool

+ func (b AssertionURLBase) IsSocial() bool

+ func (b AssertionURLBase) IsUID() bool

+ func (b AssertionURLBase) Keys() []string

+ func (b AssertionURLBase) MatchProof(proof Proof) bool

+ func (b AssertionURLBase) String() string

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

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

+ type AssertionWeb struct

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

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

+ func (a AssertionWeb) IsRemote() bool

+ func (a AssertionWeb) Keys() []string

+ func (a AssertionWeb) MatchSet(ps ProofSet) bool

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

+ type B struct

+ Val bool

+ func (b B) String() string

+ type BadFingerprintError struct

+ func (b BadFingerprintError) Error() string

+ type BadInvitationCodeError struct

+ func (e BadInvitationCodeError) Error() string

+ func (e BadInvitationCodeError) ToStatus(s keybase1.Status)

+ type BadKeyError struct

+ Msg string

+ func (p BadKeyError) Error() string

+ type BadNameError string

+ func (e BadNameError) Error() string

+ type BadRevocationError struct

+ func (e BadRevocationError) Error() string

+ type BadServiceError struct

+ Service string

+ func (e BadServiceError) Error() string

+ type BadSigError struct

+ E string

+ func (e BadSigError) Error() string

+ type BadUsernameError struct

+ N string

+ func (e BadUsernameError) Error() string

+ type Base struct

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

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

+ type Base64Finder struct

+ func NewBase64Finder(i string) *Base64Finder

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

+ type BaseAPIEngine struct

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

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

+ type BaseServiceType struct

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

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

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

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

+ func (t BaseServiceType) BaseGetProofType(st ServiceType) string

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

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

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

+ func (t BaseServiceType) CaseSensitiveUsername() bool

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

+ func (t BaseServiceType) GetAPIArgKey() string

+ func (t BaseServiceType) LastWriterWins() bool

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

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

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

+ type BtcOpts struct

+ type BucketDict struct

+ func NewBuckDict() *BucketDict

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

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

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

+ type BufferCloser struct

+ func NewBufferCloser() *BufferCloser

+ func (b *BufferCloser) Close() error

+ type CanceledError struct

+ M string

+ func NewCanceledError(m string) CanceledError

+ func (c CanceledError) Error() string

+ func (c CanceledError) ToStatus() (s keybase1.Status)

+ type ChainLink struct

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

+ func ImportLinkFromStorage(id LinkID, selfUID keybase1.UID, g *GlobalContext) (*ChainLink, error)

+ func NewChainLink(g *GlobalContext, parent *SigChain, id LinkID, jw *jsonw.Wrapper) *ChainLink

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

+ func (c *ChainLink) Copy() ChainLink

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

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

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

+ func (c *ChainLink) GetMerkleSeqno() int

+ func (c *ChainLink) GetPGPFingerprint() *PGPFingerprint

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

+ func (c *ChainLink) GetPrev() LinkID

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

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

+ func (c *ChainLink) GetSeqno() Seqno

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

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

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

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

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

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

+ func (c *ChainLink) Pack() error

+ func (c *ChainLink) Parent() *SigChain

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

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

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

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

+ func (c *ChainLink) Typed() TypedChainLink

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

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

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

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

+ func (c *ChainLink) VerifyHash() error

+ func (c *ChainLink) VerifyLink() error

+ func (c *ChainLink) VerifyPayload() error

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

+ func (c ChainLink) ToMerkleTriple() *MerkleTriple

+ type ChainLinkError struct

+ func (c ChainLinkError) Error() string

+ type ChainLinkFingerprintMismatchError struct

+ Msg string

+ func (e ChainLinkFingerprintMismatchError) Error() string

+ type ChainLinkKIDMismatchError struct

+ Msg string

+ func (e ChainLinkKIDMismatchError) Error() string

+ type ChainLinkPrevHashMismatchError struct

+ Msg string

+ func (e ChainLinkPrevHashMismatchError) Error() string

+ type ChainLinkUnpacked struct

+ type ChainLinkWrongSeqnoError struct

+ Msg string

+ func (e ChainLinkWrongSeqnoError) Error() string

+ type ChainType struct

+ DbType ObjType

+ Encrypted bool

+ GetMerkleTriple func(u *MerkleUserLeaf) *MerkleTriple

+ Private bool

+ type CheckCompletedListener interface

+ CCLCheckCompleted func(lcr *LinkCheckResult)

+ type CheckMember struct

+ Set []string

+ func (c CheckMember) Checker() Checker

+ type CheckResult struct

+ Status ProofError

+ Time time.Time

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

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

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

+ func (cr CheckResult) Freshness() keybase1.CheckResultFreshness

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

+ type Checker struct

+ F func(string) bool

+ Hint string

+ PreserveSpace bool

+ type Client struct

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

+ type ClientConfig struct

+ Host string

+ Port int

+ Prefix string

+ RootCAs *x509.CertPool

+ Timeout time.Duration

+ URL *url.URL

+ UseCookies bool

+ UseTLS bool

+ type Clock interface

+ Now func() time.Time

+ type CoinbaseChecker struct

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

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

+ func (rc *CoinbaseChecker) GetTorError() ProofError

+ func (rc *CoinbaseChecker) ProfileURL() string

+ type CoinbaseServiceType struct

+ func (t CoinbaseServiceType) AllStringKeys() []string

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

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

+ func (t CoinbaseServiceType) DisplayName(un string) string

+ func (t CoinbaseServiceType) GetPrompt() string

+ func (t CoinbaseServiceType) GetProofType() string

+ func (t CoinbaseServiceType) GetTypeName() string

+ func (t CoinbaseServiceType) NormalizeUsername(s string) (ret string, err error)

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

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

+ func (t CoinbaseServiceType) ToChecker() Checker

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

+ type Command interface

+ GetUsage func() Usage

+ type CommandLine interface

+ GetAPIDump func() (bool, bool)

+ GetAPITimeout func() (time.Duration, bool)

+ GetAutoFork func() (bool, bool)

+ GetBool func(string, bool) (bool, bool)

+ GetCodeSigningKIDs func() []string

+ GetConfigFilename func() string

+ GetDbFilename func() string

+ GetDebug func() (bool, bool)

+ GetGString func(string) string

+ GetGpg func() string

+ GetGpgHome func() string

+ GetGpgOptions func() []string

+ GetHome func() string

+ GetLinkCacheSize func() (int, bool)

+ GetLocalRPCDebug func() string

+ GetLocalTrackMaxAge func() (time.Duration, bool)

+ GetLogFile func() string

+ GetLogFormat func() string

+ GetMerkleKIDs func() []string

+ GetNoAutoFork func() (bool, bool)

+ GetPGPFingerprint func() *PGPFingerprint

+ GetPidFile func() string

+ GetPinentry func() string

+ GetProofCacheSize func() (int, bool)

+ GetProxy func() string

+ GetRunMode func() (RunMode, error)

+ GetScraperTimeout func() (time.Duration, bool)

+ GetSecretKeyringTemplate func() string

+ GetServerURI func() string

+ GetSessionFilename func() string

+ GetSocketFile func() string

+ GetStandalone func() (bool, bool)

+ GetString func(string) string

+ GetTimers func() string

+ GetTorHiddenAddress func() string

+ GetTorMode func() (TorMode, error)

+ GetTorProxy func() string

+ GetUserCacheMaxAge func() (time.Duration, bool)

+ GetVDebugSetting func() string

+ type ComputedKeyFamily struct

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

+ func (ckf *ComputedKeyFamily) GetAllActiveDevices() []*Device

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

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

+ func (ckf *ComputedKeyFamily) GetDeviceForKID(kid keybase1.KID) (*Device, error)

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

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

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

+ func (ckf *ComputedKeyFamily) HasActiveDevice() bool

+ func (ckf *ComputedKeyFamily) HasActiveEncryptionSubkey() bool

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

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

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

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

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

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

+ func (ckf ComputedKeyFamily) ExportDeviceKeys() (exportedKeys []keybase1.PublicKey, pgpKeyCount int)

+ func (ckf ComputedKeyFamily) ExportRevokedDeviceKeys() []keybase1.RevokedKey

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

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

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

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

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

+ func (ckf ComputedKeyFamily) FindKeybaseName(s string) bool

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

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

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

+ func (ckf ComputedKeyFamily) GetAllActiveSibkeys() []GenericKey

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

+ func (ckf ComputedKeyFamily) GetAllActiveSubkeys() []GenericKey

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

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

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

+ func (ckf ComputedKeyFamily) GetRevokedKeys() []RevokedKey

+ func (ckf ComputedKeyFamily) HasActiveKey() bool

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

+ type ComputedKeyInfo struct

+ ActivePGPHash string

+ CTime int64

+ DelegatedAt *KeybaseTime

+ Delegations map[keybase1.SigID]keybase1.KID

+ ETime int64

+ Eldest bool

+ Parent keybase1.KID

+ RevokedAt *KeybaseTime

+ Sibkey bool

+ Status KeyStatus

+ Subkey keybase1.KID

+ func NewComputedKeyInfo(eldest, sibkey bool, status KeyStatus, ctime, etime int64, ...) ComputedKeyInfo

+ func (cki ComputedKeyInfo) GetCTime() time.Time

+ func (cki ComputedKeyInfo) GetETime() time.Time

+ type ComputedKeyInfos struct

+ Devices map[keybase1.DeviceID]*Device

+ Infos map[keybase1.KID]*ComputedKeyInfo

+ KIDToDeviceID map[keybase1.KID]keybase1.DeviceID

+ Sigs map[keybase1.SigID]*ComputedKeyInfo

+ func NewComputedKeyInfos(g *GlobalContext) *ComputedKeyInfos

+ func (cki *ComputedKeyInfos) Delegate(kid keybase1.KID, tm *KeybaseTime, sigid keybase1.SigID, ...) (err error)

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

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

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

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

+ func (cki ComputedKeyInfos) ShallowCopy() *ComputedKeyInfos

+ type ConfigError struct

+ func (c ConfigError) Error() string

+ type ConfigGetter func() string

+ type ConfigReader interface

+ GetAPITimeout func() (time.Duration, bool)

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

+ GetAppStartMode func() AppStartMode

+ GetAutoFork func() (bool, bool)

+ GetBoolAtPath func(string) (bool, bool)

+ GetBundledCA func(host string) string

+ GetCodeSigningKIDs func() []string

+ GetConfigFilename func() string

+ GetDbFilename func() string

+ GetDebug func() (bool, bool)

+ GetDeviceID func() keybase1.DeviceID

+ GetGpg func() string

+ GetGpgHome func() string

+ GetGpgOptions func() []string

+ GetHome func() string

+ GetIntAtPath func(string) (int, bool)

+ GetInterfaceAtPath func(string) (interface{}, error)

+ GetLinkCacheCleanDur func() (time.Duration, bool)

+ GetLinkCacheSize func() (int, bool)

+ GetLocalRPCDebug func() string

+ GetLocalTrackMaxAge func() (time.Duration, bool)

+ GetLogFile func() string

+ GetLogFormat func() string

+ GetMerkleKIDs func() []string

+ GetNoPinentry func() (bool, bool)

+ GetNullAtPath func(string) bool

+ GetPidFile func() string

+ GetPinentry func() string

+ GetProofCacheLongDur func() (time.Duration, bool)

+ GetProofCacheMediumDur func() (time.Duration, bool)

+ GetProofCacheShortDur func() (time.Duration, bool)

+ GetProofCacheSize func() (int, bool)

+ GetProxy func() string

+ GetProxyCACerts func() ([]string, error)

+ GetRunMode func() (RunMode, error)

+ GetSalt func() []byte

+ GetScraperTimeout func() (time.Duration, bool)

+ GetSecretKeyringTemplate func() string

+ GetSecurityAccessGroupOverride func() (bool, bool)

+ GetServerURI func() string

+ GetSessionFilename func() string

+ GetSocketFile func() string

+ GetStandalone func() (bool, bool)

+ GetStringAtPath func(string) (string, bool)

+ GetTimers func() string

+ GetTorHiddenAddress func() string

+ GetTorMode func() (TorMode, error)

+ GetTorProxy func() string

+ GetUID func() keybase1.UID

+ GetUpdateLastChecked func() keybase1.Time

+ GetUpdatePreferenceAuto func() (bool, bool)

+ GetUpdatePreferenceSkip func() string

+ GetUpdatePreferenceSnoozeUntil func() keybase1.Time

+ GetUpdateURL func() string

+ GetUserCacheMaxAge func() (time.Duration, bool)

+ GetUserConfig func() (*UserConfig, error)

+ GetUserConfigForUsername func(s NormalizedUsername) (*UserConfig, error)

+ GetUsername func() NormalizedUsername

+ GetVDebugSetting func() string

+ IsAdmin func() (bool, bool)

+ type ConfigWriter interface

+ BeginTransaction func() (ConfigWriterTransacter, error)

+ DeleteAtPath func(string)

+ NukeUser func(un NormalizedUsername) error

+ Reset func()

+ SetBoolAtPath func(string, bool) error

+ SetDeviceID func(keybase1.DeviceID) error

+ SetIntAtPath func(string, int) error

+ SetNullAtPath func(string) error

+ SetStringAtPath func(string, string) error

+ SetUpdateLastChecked func(keybase1.Time) error

+ SetUpdatePreferenceAuto func(bool) error

+ SetUpdatePreferenceSkip func(string) error

+ SetUpdatePreferenceSnoozeUntil func(keybase1.Time) error

+ SetUserConfig func(cfg *UserConfig, overwrite bool) error

+ SetWrapperAtPath func(string, *jsonw.Wrapper) error

+ SwitchUser func(un NormalizedUsername) error

+ type ConfigWriterTransacter interface

+ Abort func() error

+ Commit func() error

+ type ConnectionID int

+ type ConnectionManager struct

+ func NewConnectionManager() *ConnectionManager

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

+ func (c *ConnectionManager) ApplyAll(f ApplyFn)

+ func (c *ConnectionManager) Label(id ConnectionID, d keybase1.ClientDetails) error

+ func (c *ConnectionManager) ListAllLabeledConnections() []keybase1.ClientDetails

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

+ func (c *ConnectionManager) Shutdown()

+ type Contexitifier interface

+ G func() *GlobalContext

+ type Contextified struct

+ func NewContextified(gc *GlobalContext) Contextified

+ func (c *Contextified) SetGlobalContext(g *GlobalContext)

+ func (c Contextified) G() *GlobalContext

+ func (c Contextified) GStrict() *GlobalContext

+ type CryptoMessageFormat string

+ const CryptoMessageFormatKeybaseV0

+ const CryptoMessageFormatPGP

+ const CryptoMessageFormatSaltpack

+ type CryptoMessageType int

+ const CryptoMessageTypeAmbiguous

+ const CryptoMessageTypeAttachedSignature

+ const CryptoMessageTypeClearSignature

+ const CryptoMessageTypeDetachedSignature

+ const CryptoMessageTypeEncryption

+ const CryptoMessageTypeSignature

+ type CryptocurrencyChainLink struct

+ func ParseCryptocurrencyChainLink(b GenericChainLink) (cl *CryptocurrencyChainLink, err error)

+ func (c *CryptocurrencyChainLink) ToDisplayString() string

+ func (c *CryptocurrencyChainLink) Type() string

+ func (c CryptocurrencyChainLink) Display(ui IdentifyUI)

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

+ func (c CryptocurrencyChainLink) GetAddress() string

+ type CtimeMismatchError struct

+ Msg string

+ func (e CtimeMismatchError) Error() string

+ type CurrentStatus struct

+ Configured bool

+ LoggedIn bool

+ Registered bool

+ SessionIsValid bool

+ User *User

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

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

+ type DNSChecker struct

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

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

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

+ func (rc *DNSChecker) GetTorError() ProofError

+ type DNSServiceType struct

+ func (t DNSServiceType) AllStringKeys() []string

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

+ func (t DNSServiceType) CheckUsername(s string) error

+ func (t DNSServiceType) DisplayName(un string) string

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

+ func (t DNSServiceType) GetAPIArgKey() string

+ func (t DNSServiceType) GetPrompt() string

+ func (t DNSServiceType) GetProofType() string

+ func (t DNSServiceType) GetTypeName() string

+ func (t DNSServiceType) LastWriterWins() bool

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

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

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

+ func (t DNSServiceType) ToChecker() Checker

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

+ type Darwin struct

+ func (d Darwin) CacheDir() string

+ func (d Darwin) ConfigDir() string

+ func (d Darwin) DataDir() string

+ func (d Darwin) Home(emptyOk bool) string

+ func (d Darwin) LogDir() string

+ func (d Darwin) Normalize(s string) string

+ func (d Darwin) RuntimeDir() string

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

+ type DbKey struct

+ Key string

+ Typ ObjType

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

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

+ func LocalTrackDBKey(tracker, trackee keybase1.UID, expireLocal bool) DbKey

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

+ func (k DbKey) ToString(table string) string

+ type DecryptBadNonceError struct

+ func (d DecryptBadNonceError) Error() string

+ type DecryptBadPacketTypeError struct

+ func (d DecryptBadPacketTypeError) Error() string

+ type DecryptBadSenderError struct

+ func (d DecryptBadSenderError) Error() string

+ type DecryptOpenError struct

+ func (d DecryptOpenError) Error() string

+ type DecryptWrongReceiverError struct

+ func (d DecryptWrongReceiverError) Error() string

+ type DecryptionError struct

+ func (e DecryptionError) Error() string

+ type DelegationType LinkType

+ type Delegator struct

+ Aggregated bool

+ Ctime int64

+ DelegationType DelegationType

+ Device *Device

+ EldestKID keybase1.KID

+ EncodedPrivateKey string

+ ExistingKey GenericKey

+ Expire int

+ LastSeqno Seqno

+ Me *User

+ NewKey GenericKey

+ PrevLinkID LinkID

+ RevSig string

+ ServerHalf []byte

+ SigningUser UserBasic

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

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

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

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

+ func (d Delegator) GetMerkleTriple() MerkleTriple

+ func (d Delegator) GetSigningKey() GenericKey

+ func (d Delegator) IsEldest() bool

+ func (d Delegator) IsSibkeyOrEldest() bool

+ type Device struct

+ CTime keybase1.Time

+ Description *string

+ ID keybase1.DeviceID

+ Kid keybase1.KID

+ MTime keybase1.Time

+ Status *int

+ Type string

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

+ func ParseDevice(jw *jsonw.Wrapper, t time.Time) (ret *Device, err error)

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

+ func (d *Device) IsActive() bool

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

+ func (d *Device) ProtExport() *keybase1.Device

+ func (d *Device) StatusString() string

+ type DeviceAlreadyProvisionedError struct

+ func (e DeviceAlreadyProvisionedError) Error() string

+ func (e DeviceAlreadyProvisionedError) ToStatus() keybase1.Status

+ type DeviceChainLink struct

+ func ParseDeviceChainLink(b GenericChainLink) (ret *DeviceChainLink, err error)

+ func (s *DeviceChainLink) GetDevice() *Device

+ type DeviceKey struct

+ CTime int64

+ Description string

+ LksServerHalf string

+ MTime int64

+ PPGen PassphraseGeneration

+ Status int

+ Type string

+ func (d DeviceKey) Display() string

+ type DeviceKeyMap map[keybase1.DeviceID]DeviceKey

+ type DeviceRequiredError struct

+ func (e DeviceRequiredError) Error() string

+ func (e DeviceRequiredError) ToStatus() keybase1.Status

+ type DeviceStatus struct

+ KeyAvailable bool

+ Keyed bool

+ Provisioned bool

+ type DeviceTypeSet map[string]bool

+ type DumbOutputUI interface

+ Printf func(fmt string, args ...interface{}) (int, error)

+ PrintfStderr func(fmt string, args ...interface{}) (int, error)

+ type EmptyKeyRing struct

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

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

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

+ type Env struct

+ Test TestParameters

+ func NewEnv(cmd CommandLine, config ConfigReader) *Env

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

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

+ func (e *Env) GetAPIDump() bool

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

+ func (e *Env) GetAppStartMode() AppStartMode

+ func (e *Env) GetAutoFork() bool

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

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

+ func (e *Env) GetCacheDir() string

+ func (e *Env) GetCodeSigningKIDs() []keybase1.KID

+ func (e *Env) GetCommandLine() CommandLine

+ func (e *Env) GetConfig() ConfigReader

+ func (e *Env) GetConfigDir() string

+ func (e *Env) GetConfigFilename() string

+ func (e *Env) GetConfigWriter() ConfigWriter

+ func (e *Env) GetDataDir() string

+ func (e *Env) GetDbFilename() string

+ func (e *Env) GetDebug() bool

+ func (e *Env) GetDefaultLogFile() string

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

+ func (e *Env) GetDoLogForward() bool

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

+ func (e *Env) GetEmail() string

+ func (e *Env) GetEmailOrUsername() string

+ func (e *Env) GetGpg() string

+ func (e *Env) GetGpgHome() string

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

+ func (e *Env) GetHome() string

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

+ func (e *Env) GetLabel() string

+ func (e *Env) GetLinkCacheCleanDur() time.Duration

+ func (e *Env) GetLinkCacheSize() int

+ func (e *Env) GetLocalRPCDebug() string

+ func (e *Env) GetLocalTrackMaxAge() time.Duration

+ func (e *Env) GetLogDir() string

+ func (e *Env) GetLogFile() string

+ func (e *Env) GetLogFormat() string

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

+ func (e *Env) GetMountDir() string

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

+ func (e *Env) GetNoPinentry() bool

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

+ func (e *Env) GetPinentry() string

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

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

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

+ func (e *Env) GetProofCacheSize() int

+ func (e *Env) GetProxy() string

+ func (e *Env) GetRunMode() RunMode

+ func (e *Env) GetRunModeAsString() string

+ func (e *Env) GetRuntimeDir() string

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

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

+ func (e *Env) GetSecretKeyringTemplate() string

+ func (e *Env) GetServerURI() string

+ func (e *Env) GetServiceInfoPath() string

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

+ func (e *Env) GetServiceType() string

+ func (e *Env) GetSessionFilename() string

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

+ func (e *Env) GetStandalone() bool

+ func (e *Env) GetStoredSecretAccessGroup() string

+ func (e *Env) GetStoredSecretServiceName() string

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

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

+ func (e *Env) GetTimers() string

+ func (e *Env) GetTorHiddenAddress() string

+ func (e *Env) GetTorMode() TorMode

+ func (e *Env) GetTorProxy() string

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

+ func (e *Env) GetUpdateDefaultInstructions() (string, error)

+ func (e *Env) GetUpdateLastChecked() keybase1.Time

+ func (e *Env) GetUpdatePreferenceAuto() (bool, bool)

+ func (e *Env) GetUpdatePreferenceSkip() string

+ func (e *Env) GetUpdatePreferenceSnoozeUntil() keybase1.Time

+ func (e *Env) GetUpdateURL() string

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

+ func (e *Env) GetUsername() NormalizedUsername

+ func (e *Env) GetVDebugSetting() string

+ func (e *Env) IsAdmin() bool

+ func (e *Env) SetCommandLine(cmd CommandLine)

+ func (e *Env) SetConfig(r ConfigReader, w ConfigWriter)

+ func (e *Env) SetUpdateLastChecked(t keybase1.Time) error

+ func (e *Env) SetUpdatePreferenceAuto(b bool) error

+ func (e *Env) SetUpdatePreferenceSkip(v string) error

+ func (e *Env) SetUpdatePreferenceSnoozeUntil(t keybase1.Time) error

+ type ErrorUnwrapper struct

+ func (eu ErrorUnwrapper) MakeArg() interface{}

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

+ type ExportableError interface

+ ToStatus func() keybase1.Status

+ type ExportedStream struct

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

+ type ExportedStreams struct

+ func NewExportedStreams() *ExportedStreams

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

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

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

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

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

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

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

+ type ExternalAPI interface

+ Get func(APIArg) (*ExternalAPIRes, error)

+ GetHTML func(APIArg) (*ExternalHTMLRes, error)

+ GetText func(APIArg) (*ExternalTextRes, error)

+ Post func(APIArg) (*ExternalAPIRes, error)

+ PostHTML func(APIArg) (*ExternalHTMLRes, error)

+ type ExternalAPIEngine struct

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

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

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

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

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

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

+ type ExternalAPIRes struct

+ Body *jsonw.Wrapper

+ HTTPStatus int

+ type ExternalHTMLRes struct

+ GoQuery *goquery.Document

+ HTTPStatus int

+ type ExternalTextRes struct

+ Body string

+ HTTPStatus int

+ type FailedAssertionError struct

+ func (u FailedAssertionError) Error() string

+ type File struct

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

+ func (f File) GetFilename() string

+ func (f File) Save() error

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

+ type FirstErrorPicker struct

+ func (p *FirstErrorPicker) Error() error

+ func (p *FirstErrorPicker) Push(e error)

+ type FishyMsgpackError struct

+ func (e FishyMsgpackError) Error() string

+ type GPGKey struct

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

+ func (g *GPGKey) CanDecrypt() bool

+ func (g *GPGKey) CanEncrypt() bool

+ func (g *GPGKey) CanSign() bool

+ func (g *GPGKey) CheckSecretKey() error

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

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

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

+ func (g *GPGKey) GetAlgoType() AlgoType

+ func (g *GPGKey) GetFingerprintP() *PGPFingerprint

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

+ func (g *GPGKey) HasSecretKey() bool

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

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

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

+ func (g *GPGKey) VerboseDescription() string

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

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

+ type GPGUI interface

+ type GUID struct — windows/amd64

+ Data1 uint32

+ Data2 uint16

+ Data3 uint16

+ Data4 [8]byte

+ type GenericChainLink struct

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

+ func (g *GenericChainLink) DoOwnNewLinkFromServerNotifications(glob *GlobalContext)

+ func (g *GenericChainLink) GetArmoredSig() string

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

+ func (g *GenericChainLink) GetDevice() *Device

+ func (g *GenericChainLink) GetPGPFingerprint() *PGPFingerprint

+ func (g *GenericChainLink) GetPGPFullHash() string

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

+ func (g *GenericChainLink) GetRole() KeyRole

+ func (g *GenericChainLink) GetSeqno() Seqno

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

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

+ func (g *GenericChainLink) GetUsername() string

+ func (g *GenericChainLink) IsRevocationIsh() bool

+ func (g *GenericChainLink) IsRevoked() bool

+ func (g *GenericChainLink) ToDebugString() string

+ func (g *GenericChainLink) ToDisplayString() string

+ func (g *GenericChainLink) Type() string

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

+ type GenericKey interface

+ CanDecrypt func() bool

+ CanEncrypt func() bool

+ CanSign func() bool

+ CheckSecretKey func() error

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

+ Encode func() (string, error)

+ EncryptToString func(plaintext []byte, sender GenericKey) (ciphertext string, err error)

+ GetAlgoType func() AlgoType

+ GetFingerprintP func() *PGPFingerprint

+ GetKID func() keybase1.KID

+ HasSecretKey func() bool

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

+ ToLksSKB func(lks *LKSec) (*SKB, error)

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

+ VerboseDescription func() string

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

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

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

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

+ func ParseGenericKey(bundle string) (GenericKey, error)

+ type GetCheckTimeFunc func(keybase1.UserPlusKeys) keybase1.Time

+ type GithubChecker struct

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

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

+ func (rc *GithubChecker) GetTorError() ProofError

+ type GithubServiceType struct

+ func (t GithubServiceType) AllStringKeys() []string

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

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

+ func (t GithubServiceType) DisplayName(un string) string

+ func (t GithubServiceType) GetPrompt() string

+ func (t GithubServiceType) GetProofType() string

+ func (t GithubServiceType) GetTypeName() string

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

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

+ func (t GithubServiceType) ToChecker() Checker

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

+ type GlobalContext struct

+ API API

+ Clock clockwork.Clock

+ ConnectionManager *ConnectionManager

+ Env *Env

+ ExitCode keybase1.ExitCode

+ GpgClient *GpgCLI

+ Identify2Cache Identify2Cacher

+ Keyrings *Keyrings

+ LinkCache *LinkCache

+ LocalDb *JSONLocalDb

+ Log logger.Logger

+ LoopbackListener *LoopbackListener

+ MerkleClient *MerkleClient

+ NotifyRouter *NotifyRouter

+ Output io.Writer

+ ProofCache *ProofCache

+ ProofCheckerFactory ProofCheckerFactory

+ RateLimits *RateLimits

+ Resolver *Resolver

+ SecretStoreAll SecretStoreAll

+ Service bool

+ ShutdownHooks []ShutdownHook

+ SocketInfo Socket

+ SocketWrapper *SocketWrapper

+ Timers *TimerSet

+ TrackCache *TrackCache

+ UI UI

+ UIRouter UIRouter

+ VDL *VDebugLog

+ XAPI ExternalAPI

+ XStreams *ExportedStreams

+ var G *GlobalContext

+ func NewGlobalContext() *GlobalContext

+ func NewGlobalContextInit() *GlobalContext

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

+ func (g *GlobalContext) ConfigReload() error

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

+ func (g *GlobalContext) ConfigureAPI() error

+ func (g *GlobalContext) ConfigureCaches() error

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

+ func (g *GlobalContext) ConfigureConfig() error

+ func (g *GlobalContext) ConfigureExportedStreams() error

+ func (g *GlobalContext) ConfigureKeyring() error

+ func (g *GlobalContext) ConfigureLogging() error

+ func (g *GlobalContext) ConfigureMerkleClient() error

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

+ func (g *GlobalContext) ConfigureTimers() error

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

+ func (g *GlobalContext) GetAllUserNames() (NormalizedUsername, []NormalizedUsername, error)

+ func (g *GlobalContext) GetCacheDir() string

+ func (g *GlobalContext) GetClock() clockwork.Clock

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

+ func (g *GlobalContext) GetGpgClient() *GpgCLI

+ func (g *GlobalContext) GetMyClientDetails() keybase1.ClientDetails

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

+ func (g *GlobalContext) GetRunMode() RunMode

+ func (g *GlobalContext) GetRuntimeDir() string

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

+ func (g *GlobalContext) GetStoredSecretAccessGroup() string

+ func (g *GlobalContext) GetStoredSecretServiceName() string

+ func (g *GlobalContext) GetUnforwardedLogger() *logger.UnforwardedLogger

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

+ func (g *GlobalContext) Init() *GlobalContext

+ func (g *GlobalContext) LoginState() *LoginState

+ func (g *GlobalContext) Logout() error

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

+ func (g *GlobalContext) NewProofChecker(l RemoteProofChainLink) (ProofChecker, ProofError)

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

+ func (g *GlobalContext) OutputString(s string)

+ func (g *GlobalContext) PushShutdownHook(sh ShutdownHook)

+ func (g *GlobalContext) ResetLoginState()

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

+ func (g *GlobalContext) SetCommandLine(cmd CommandLine)

+ func (g *GlobalContext) SetService()

+ func (g *GlobalContext) SetUI(u UI)

+ func (g *GlobalContext) SetUIRouter(u UIRouter)

+ func (g *GlobalContext) Shutdown() error

+ func (g *GlobalContext) StartupMessage()

+ func (g *GlobalContext) Trace(msg string, f func() error) func()

+ type GpgBaseKey struct

+ Algo int

+ Bits int

+ Created int64

+ Expires int64

+ ID64 string

+ Trust string

+ Type string

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

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

+ func (k GpgBaseKey) AlgoString() string

+ func (k GpgBaseKey) CreatedString() string

+ func (k GpgBaseKey) ExpirationString() string

+ type GpgCLI struct

+ func NewGpgCLI(g *GlobalContext, logUI LogUI) *GpgCLI

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

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

+ func (g *GpgCLI) ExportKey(k PGPKeyBundle, private bool) (err error)

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

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

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

+ func (g *GpgCLI) Path() string

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

+ func (g *GpgCLI) SetTTY(t string)

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

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

+ type GpgError struct

+ M string

+ func ErrorToGpgError(e error) GpgError

+ func (e GpgError) Error() string

+ type GpgFingerprinter interface

+ SetFingerprint func(pgp *PGPFingerprint)

+ type GpgIndexElement interface

+ ToKey func() *GpgPrimaryKey

+ type GpgIndexError struct

+ func ErrorToGpgIndexError(l int, e error) GpgIndexError

+ func (e GpgIndexError) Error() string

+ type GpgIndexLine struct

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

+ func (g GpgIndexLine) At(i int) string

+ func (g GpgIndexLine) IsNewKey() bool

+ func (g GpgIndexLine) Len() int

+ type GpgIndexParser struct

+ func NewGpgIndexParser() *GpgIndexParser

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

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

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

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

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

+ func (p *GpgIndexParser) Warn(w Warning)

+ type GpgKeyIndex struct

+ Emails *BucketDict

+ Fingerprints *BucketDict

+ ID64s *BucketDict

+ Keys []*GpgPrimaryKey

+ func NewGpgKeyIndex() *GpgKeyIndex

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

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

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

+ func (ki *GpgKeyIndex) Len() int

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

+ func (ki *GpgKeyIndex) PushElement(e GpgIndexElement)

+ func (ki *GpgKeyIndex) Sort()

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

+ type GpgPrimaryKey struct

+ func NewGpgPrimaryKey() *GpgPrimaryKey

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

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

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

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

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

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

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

+ func (k *GpgPrimaryKey) GetFingerprint() *PGPFingerprint

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

+ func (k *GpgPrimaryKey) IsValid() bool

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

+ func (k *GpgPrimaryKey) ToKey() *GpgPrimaryKey

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

+ type GpgSubKey struct

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

+ type HTTPArgs map[string]HTTPValue

+ func HTTPArgsFromKeyValuePair(key string, val HTTPValue) HTTPArgs

+ func NewHTTPArgs() HTTPArgs

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

+ func (a HTTPArgs) EncodeToString() string

+ func (a HTTPArgs) ToValues() url.Values

+ type HTTPRequest interface

+ SetEnvironment func(env Env)

+ type HTTPValue interface

+ String func() string

+ func UIDArg(uid keybase1.UID) HTTPValue

+ type HackerNewsChecker struct

+ func (h *HackerNewsChecker) APIBase() string

+ func (h *HackerNewsChecker) APIURL() string

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

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

+ func (h *HackerNewsChecker) GetTorError() ProofError

+ func (h *HackerNewsChecker) HumanURL() string

+ func (h *HackerNewsChecker) KarmaURL() string

+ type HackerNewsServiceType struct

+ func (t HackerNewsServiceType) AllStringKeys() []string

+ func (t HackerNewsServiceType) CaseSensitiveUsername() bool

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

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

+ func (t HackerNewsServiceType) DisplayName(un string) string

+ func (t HackerNewsServiceType) GetPrompt() string

+ func (t HackerNewsServiceType) GetProofType() string

+ func (t HackerNewsServiceType) GetTypeName() string

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

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

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

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

+ func (t HackerNewsServiceType) ToChecker() Checker

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

+ type HashSummer func() []byte

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

+ type HashingWriteCloser struct

+ func (h HashingWriteCloser) Close() error

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

+ type HomeFinder interface

+ CacheDir func() string

+ ConfigDir func() string

+ DataDir func() string

+ Home func(emptyOk bool) string

+ LogDir func() string

+ Normalize func(s string) string

+ RuntimeDir func() string

+ ServiceSpawnDir func() (string, error)

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

+ type I struct

+ Val int

+ func (i I) String() string

+ type Identify2Cache struct

+ func NewIdentify2Cache(maxAge time.Duration) *Identify2Cache

+ func (c *Identify2Cache) Get(uid keybase1.UID, gctf GetCheckTimeFunc, timeout time.Duration) (*keybase1.UserPlusKeys, error)

+ func (c *Identify2Cache) Insert(up *keybase1.UserPlusKeys) error

+ func (c *Identify2Cache) Shutdown()

+ type Identify2Cacher interface

+ Get func(keybase1.UID, GetCheckTimeFunc, time.Duration) (*keybase1.UserPlusKeys, error)

+ Insert func(up *keybase1.UserPlusKeys) error

+ Shutdown func()

+ type IdentifyDidNotCompleteError struct

+ func (e IdentifyDidNotCompleteError) Error() string

+ func (e IdentifyDidNotCompleteError) ToStatus() keybase1.Status

+ type IdentifyFailedError struct

+ Assertion string

+ Reason string

+ func (e IdentifyFailedError) Error() string

+ func (e IdentifyFailedError) ToStatus() keybase1.Status

+ type IdentifyOutcome struct

+ Error error

+ KeyDiffs []TrackDiff

+ ProofChecks []*LinkCheckResult

+ Reason keybase1.IdentifyReason

+ Revoked []TrackDiffRevoked

+ RevokedDetails []keybase1.RevokedProof

+ TrackEqual bool

+ TrackOptions keybase1.TrackOptions

+ TrackUsed *TrackLookup

+ Username string

+ Warnings []Warning

+ func NewIdentifyOutcome() *IdentifyOutcome

+ func NewIdentifyOutcomeWithUsername(u string) *IdentifyOutcome

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

+ func (i *IdentifyOutcome) AddProofsToSet(existing *ProofSet, okStates []keybase1.ProofState)

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

+ func (i *IdentifyOutcome) TrackSet() *TrackSet

+ func (i IdentifyOutcome) GetError() error

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

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

+ func (i IdentifyOutcome) IsOK() bool

+ func (i IdentifyOutcome) NumProofFailures() int

+ func (i IdentifyOutcome) NumProofSuccesses() int

+ func (i IdentifyOutcome) NumRevoked() int

+ func (i IdentifyOutcome) NumTrackChanges() int

+ func (i IdentifyOutcome) NumTrackFailures() int

+ func (i IdentifyOutcome) TrackStatus() keybase1.TrackStatus

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

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

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

+ type IdentifyState struct

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

+ func (is IdentifyState) ExportToUncheckedIdentity() *keybase1.Identity

+ func (s *IdentifyState) HasPreviousTrack() bool

+ func (s *IdentifyState) Precompute(dhook func(keybase1.IdentifyKey))

+ func (s *IdentifyState) Result() *IdentifyOutcome

+ func (s *IdentifyState) SetTmpTrackLookup(t *TrackChainLink)

+ func (s *IdentifyState) SetTrackLookup(t *TrackChainLink)

+ func (s *IdentifyState) TrackLookup() *TrackLookup

+ type IdentifyTimeoutError struct

+ func (e IdentifyTimeoutError) Error() string

+ func (e IdentifyTimeoutError) ToStatus() keybase1.Status

+ type IdentifyUI interface

+ Confirm func(*keybase1.IdentifyOutcome) (keybase1.ConfirmResult, error)

+ DisplayCryptocurrency func(keybase1.Cryptocurrency)

+ DisplayKey func(keybase1.IdentifyKey)

+ DisplayTrackStatement func(string) error

+ DisplayUserCard func(keybase1.UserCard)

+ Finish func()

+ FinishSocialProofCheck func(keybase1.RemoteProof, keybase1.LinkCheckResult)

+ FinishWebProofCheck func(keybase1.RemoteProof, keybase1.LinkCheckResult)

+ LaunchNetworkChecks func(*keybase1.Identity, *keybase1.User)

+ ReportLastTrack func(*keybase1.TrackSummary)

+ ReportTrackToken func(keybase1.TrackToken) error

+ Start func(string, keybase1.IdentifyReason)

+ type Identities []Identity

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

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

+ type Identity struct

+ Comment string

+ Email string

+ Username string

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

+ func KeybaseIdentity(un NormalizedUsername) Identity

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

+ func (i Identity) Format() string

+ func (i Identity) String() string

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

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

+ type IdentityTable struct

+ Order []TypedChainLink

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

+ func (idt *IdentityTable) ActiveCryptocurrency() *CryptocurrencyChainLink

+ func (idt *IdentityTable) ComputeRemoteDiff(tracked, trackedTmp, observed keybase1.ProofState) (ret TrackDiff)

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

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

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

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

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

+ func (idt *IdentityTable) Len() int

+ func (idt *IdentityTable) MarkCheckResult(err ProofError)

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

+ func (idt *IdentityTable) VerifySelfSig(nun NormalizedUsername, uid keybase1.UID) bool

+ type InactiveKeyError struct

+ func (i InactiveKeyError) Error() string

+ type InputCanceledError struct

+ func (e InputCanceledError) Error() string

+ func (e InputCanceledError) ToStatus() (s keybase1.Status)

+ type InsufficientKarmaError struct

+ func (e InsufficientKarmaError) Error() string

+ type InternalAPIEngine struct

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

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

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

+ func (a *InternalAPIEngine) GetDecode(arg APIArg, v APIResponseWrapper) error

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

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

+ func (a *InternalAPIEngine) PostDecode(arg APIArg, v APIResponseWrapper) error

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

+ func (a *InternalAPIEngine) PostRaw(arg APIArg, ctype string, r io.Reader) (*APIRes, error)

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

+ type InternalError struct

+ Msg string

+ func (e InternalError) Error() string

+ type InvalidArgumentError struct

+ Msg string

+ func (e InvalidArgumentError) Error() string

+ type InvalidHostnameError struct

+ func (e InvalidHostnameError) Error() string

+ type InvalidKexPhraseError struct

+ func (e InvalidKexPhraseError) Error() string

+ func (e InvalidKexPhraseError) ToStatus() keybase1.Status

+ type InviteRequestArg struct

+ Email string

+ Fullname string

+ Notes string

+ type JSONConfigFile struct

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

+ func (f *JSONConfigFile) DeleteAtPath(p string)

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

+ func (f *JSONConfigFile) Reset()

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

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

+ func (f *JSONConfigFile) SetInt64AtPath(p string, v int64) error

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

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

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

+ func (f *JSONConfigFile) SetTimeAtPath(path string, t keybase1.Time) error

+ func (f *JSONConfigFile) SetUpdateLastChecked(t keybase1.Time) error

+ func (f *JSONConfigFile) SetUpdatePreferenceAuto(b bool) error

+ func (f *JSONConfigFile) SetUpdatePreferenceSkip(v string) error

+ func (f *JSONConfigFile) SetUpdatePreferenceSnoozeUntil(t keybase1.Time) error

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

+ func (f *JSONConfigFile) SetWrapperAtPath(p string, w *jsonw.Wrapper) error

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

+ func (f JSONConfigFile) Check() error

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

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

+ func (f JSONConfigFile) GetAppStartMode() AppStartMode

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

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

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

+ func (f JSONConfigFile) GetCodeSigningKIDs() []string

+ func (f JSONConfigFile) GetConfigFilename() string

+ func (f JSONConfigFile) GetDbFilename() string

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

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

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

+ func (f JSONConfigFile) GetFilename() string

+ func (f JSONConfigFile) GetGpg() string

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

+ func (f JSONConfigFile) GetGpgOptions() []string

+ func (f JSONConfigFile) GetHome() string

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

+ func (f JSONConfigFile) GetInterfaceAtPath(p string) (i interface{}, err error)

+ func (f JSONConfigFile) GetLinkCacheCleanDur() (time.Duration, bool)

+ func (f JSONConfigFile) GetLinkCacheSize() (int, bool)

+ func (f JSONConfigFile) GetLocalRPCDebug() string

+ func (f JSONConfigFile) GetLocalTrackMaxAge() (time.Duration, bool)

+ func (f JSONConfigFile) GetLogFile() string

+ func (f JSONConfigFile) GetLogFormat() string

+ func (f JSONConfigFile) GetMerkleKIDs() []string

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

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

+ func (f JSONConfigFile) GetPidFile() string

+ func (f JSONConfigFile) GetPinentry() string

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

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

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

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

+ func (f JSONConfigFile) GetProxy() string

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

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

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

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

+ func (f JSONConfigFile) GetSecretKeyringTemplate() string

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

+ func (f JSONConfigFile) GetServerURI() string

+ func (f JSONConfigFile) GetSessionFilename() string

+ func (f JSONConfigFile) GetSocketFile() string

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

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

+ func (f JSONConfigFile) GetTimeAtPath(path string) keybase1.Time

+ func (f JSONConfigFile) GetTimers() string

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

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

+ func (f JSONConfigFile) GetTorHiddenAddress() string

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

+ func (f JSONConfigFile) GetTorProxy() string

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

+ func (f JSONConfigFile) GetUpdateLastChecked() keybase1.Time

+ func (f JSONConfigFile) GetUpdatePreferenceAuto() (bool, bool)

+ func (f JSONConfigFile) GetUpdatePreferenceSkip() string

+ func (f JSONConfigFile) GetUpdatePreferenceSnoozeUntil() keybase1.Time

+ func (f JSONConfigFile) GetUpdateURL() string

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

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

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

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

+ func (f JSONConfigFile) GetVDebugSetting() string

+ func (f JSONConfigFile) IsAdmin() (bool, bool)

+ type JSONFile struct

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

+ func (f *JSONFile) BeginTransaction() (ConfigWriterTransacter, error)

+ func (f *JSONFile) Exists() bool

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

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

+ func (f *JSONFile) Nuke() error

+ func (f *JSONFile) Save() error

+ type JSONLocalDb struct

+ func NewJSONLocalDb(e LocalDb) *JSONLocalDb

+ func (j *JSONLocalDb) Close() error

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

+ func (j *JSONLocalDb) ForceOpen() error

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

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

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

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

+ func (j *JSONLocalDb) Open() error

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

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

+ type JSONPayload map[string]interface

+ type Kex2Secret struct

+ func NewKex2Secret() (*Kex2Secret, error)

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

+ func (s *Kex2Secret) Phrase() string

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

+ type KexRole int

+ const KexRoleProvisionee

+ const KexRoleProvisioner

+ type KexRouter struct

+ func NewKexRouter(g *GlobalContext) *KexRouter

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

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

+ type KeyCannotDecryptError struct

+ func (k KeyCannotDecryptError) Error() string

+ type KeyCannotEncryptError struct

+ func (k KeyCannotEncryptError) Error() string

+ type KeyCannotSignError struct

+ func (s KeyCannotSignError) Error() string

+ type KeyCannotVerifyError struct

+ func (k KeyCannotVerifyError) Error() string

+ type KeyExistsError struct

+ Key *PGPFingerprint

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

+ func (k KeyExistsError) Error() string

+ type KeyExpiredError struct

+ func (r KeyExpiredError) Error() string

+ type KeyFamily struct

+ AllKIDs map[keybase1.KID]bool

+ BundlesForTesting []string

+ PGPKeySets map[keybase1.KID]*PGPKeySet

+ SingleKeys map[keybase1.KID]GenericKey

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

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

+ type KeyFamilyError struct

+ Msg string

+ func (e KeyFamilyError) Error() string

+ type KeyGenError struct

+ Msg string

+ func (e KeyGenError) Error() string

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

+ type KeyRevokedError struct

+ func (r KeyRevokedError) Error() string

+ type KeyRole int

+ const DLGNone

+ const DLGSibkey

+ const DLGSubkey

+ type KeySection struct

+ EldestKID keybase1.KID

+ HasRevSig bool

+ IncludePGPHash bool

+ Key GenericKey

+ ParentKID keybase1.KID

+ RevSig string

+ SigningUser UserBasic

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

+ type KeyStatus int

+ const KeyDeleted

+ const KeyRevoked

+ const KeySuperseded

+ const KeyUncancelled

+ type KeyType int

+ type KeyUnimplementedError struct

+ func (k KeyUnimplementedError) Error() string

+ type KeyUnlocker struct

+ KeyDesc string

+ Reason string

+ Tries int

+ UI SecretUI

+ Unlocker func(pw string, storeSecret bool) (ret GenericKey, err error)

+ UseSecretStore bool

+ Which string

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

+ type KeyVersionError struct

+ func (k KeyVersionError) Error() string

+ type KeybasePacket struct

+ Body interface{}

+ Hash *KeybasePacketHash

+ Tag int

+ Version int

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

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

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

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

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

+ func (p *KeybasePacket) HashMe() error

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

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

+ type KeybasePacketHash struct

+ Type int

+ Value []byte

+ type KeybasePackets []*KeybasePacket

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

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

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

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

+ type KeybaseSaltpackError struct

+ func (e KeybaseSaltpackError) Error() string

+ type KeybaseTime struct

+ Chain int

+ Unix int64

+ func NowAsKeybaseTime(seqno int) *KeybaseTime

+ func TclToKeybaseTime(tcl TypedChainLink) *KeybaseTime

+ type KeychainSecretStore struct — darwin/amd64

+ func (k KeychainSecretStore) ClearSecret(accountName NormalizedUsername) error

+ func (k KeychainSecretStore) GetUsersWithStoredSecrets() ([]string, error)

+ func (k KeychainSecretStore) RetrieveSecret(accountName NormalizedUsername) ([]byte, error)

+ func (k KeychainSecretStore) StoreSecret(accountName NormalizedUsername, secret []byte) (err error)

+ type KeyringFile struct

+ Entities openpgp.EntityList

+ func (k *KeyringFile) Index() error

+ func (k *KeyringFile) Load() error

+ func (k *KeyringFile) LoadAndIndex() error

+ func (k KeyringFile) GetFilename() string

+ func (k KeyringFile) Save() error

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

+ type Keyrings struct

+ func NewKeyrings(g *GlobalContext) *Keyrings

+ func (k *Keyrings) GetSecretKeyAndSKBWithPrompt(arg SecretKeyPromptArg) (key GenericKey, skb *SKB, err error)

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

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

+ func (k *Keyrings) GetSecretKeyWithPrompt(arg SecretKeyPromptArg) (key GenericKey, err error)

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

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

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

+ type LKSec struct

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

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

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

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

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

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

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

+ func (s *LKSec) GenerateServerHalf() error

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

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

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

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

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

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

+ func (s LKSec) Generation() PassphraseGeneration

+ type LevelDb struct

+ func NewLevelDb(g *GlobalContext) *LevelDb

+ func (l *LevelDb) Close() error

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

+ func (l *LevelDb) ForceOpen() error

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

+ func (l *LevelDb) GetFilename() string

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

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

+ func (l *LevelDb) Open() error

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

+ type Lexer struct

+ func NewLexer(s string) *Lexer

+ func (lx *Lexer) Get() *Token

+ func (lx *Lexer) Putback()

+ type LinkCache struct

+ func NewLinkCache(maxSize int, cleanDur time.Duration) *LinkCache

+ func (c *LinkCache) Get(id LinkID) (link ChainLink, ok bool)

+ func (c *LinkCache) Len() int

+ func (c *LinkCache) Mutate(id LinkID, f func(c *ChainLink))

+ func (c *LinkCache) Put(id LinkID, link ChainLink)

+ func (c *LinkCache) Remove(id LinkID)

+ func (c *LinkCache) Shutdown()

+ type LinkCheckResult struct

+ func (l LinkCheckResult) Export() keybase1.LinkCheckResult

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

+ func (l LinkCheckResult) GetCached() *CheckResult

+ func (l LinkCheckResult) GetDiff() TrackDiff

+ func (l LinkCheckResult) GetError() error

+ func (l LinkCheckResult) GetHint() *SigHint

+ func (l LinkCheckResult) GetLink() RemoteProofChainLink

+ func (l LinkCheckResult) GetPosition() int

+ func (l LinkCheckResult) GetTorWarning() bool

+ type LinkID []byte

+ func ComputeLinkID(d []byte) LinkID

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

+ func LinkIDFromHex(s string) (LinkID, error)

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

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

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

+ func (l LinkID) Eq(i2 LinkID) bool

+ func (l LinkID) String() string

+ type LinkType string

+ type LoadUserArg struct

+ AbortIfSigchainUnchanged bool

+ AllKeys bool

+ ForceReload bool

+ LoginContext LoginContext

+ Name string

+ NoCacheResult bool

+ PublicKeyOptional bool

+ ResolveBody *jsonw.Wrapper

+ Self bool

+ UID keybase1.UID

+ func NewLoadUserArg(g *GlobalContext) LoadUserArg

+ func NewLoadUserByNameArg(g *GlobalContext, name string) LoadUserArg

+ func NewLoadUserByUIDArg(g *GlobalContext, uid keybase1.UID) LoadUserArg

+ func NewLoadUserForceArg(g *GlobalContext) LoadUserArg

+ func NewLoadUserPubOptionalArg(g *GlobalContext) LoadUserArg

+ type LocalDb interface

+ Close func() error

+ Delete func(id DbKey) error

+ ForceOpen func() error

+ Get func(id DbKey) ([]byte, bool, error)

+ Lookup func(alias DbKey) ([]byte, bool, error)

+ Nuke func() (string, error)

+ Open func() error

+ Put func(id DbKey, aliases []DbKey, value []byte) error

+ type LockPIDFile struct

+ func NewLockPIDFile(s string) *LockPIDFile

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

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

+ type LockTable struct

+ func (t *LockTable) AcquireOnName(s string) (ret *NamedLock)

+ type LogUI interface

+ Critical func(format string, args ...interface{})

+ Debug func(format string, args ...interface{})

+ Errorf func(format string, args ...interface{})

+ Info func(format string, args ...interface{})

+ Notice func(format string, args ...interface{})

+ Warning func(format string, args ...interface{})

+ type LoggedInError struct

+ func (e LoggedInError) Error() string

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

+ type LoggedInHelper interface

+ GetUID func() keybase1.UID

+ LoggedInLoad func() (bool, error)

+ type LoggedInWrongUserError struct

+ AttemptedName NormalizedUsername

+ ExistingName NormalizedUsername

+ func (e LoggedInWrongUserError) Error() string

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

+ type LoginContext interface

+ CachedSecretKey func(ska SecretKeyArg) (GenericKey, error)

+ ClearLoginSession func()

+ ClearStreamCache func()

+ CreateLoginSessionWithSalt func(emailOrUsername string, salt []byte) error

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

+ CreateStreamCacheViaStretch func(passphrase string) error

+ EnsureUsername func(username NormalizedUsername)

+ GetStreamGeneration func() PassphraseGeneration

+ GetUID func() keybase1.UID

+ Keyring func() (*SKBKeyringFile, error)

+ LoadLoginSession func(emailOrUsername string) error

+ LocalSession func() *Session

+ LockedLocalSecretKey func(ska SecretKeyArg) (*SKB, error)

+ LoggedInLoad func() (bool, error)

+ LoggedInProvisionedLoad func() (bool, error)

+ LoginSession func() *LoginSession

+ Logout func() error

+ PassphraseStreamCache func() *PassphraseStreamCache

+ RunSecretSyncer func(uid keybase1.UID) error

+ SaveState func(sessionID, csrf string, username NormalizedUsername, uid keybase1.UID, ...) error

+ SecretSyncer func() *SecretSyncer

+ SetCachedSecretKey func(ska SecretKeyArg, key GenericKey) error

+ SetLKSec func(lksec *LKSec)

+ SetStreamGeneration func(gen PassphraseGeneration, nilPPStreamOK bool)

+ type LoginRequiredError struct

+ Context string

+ func (e LoginRequiredError) Error() string

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

+ type LoginSession struct

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

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

+ func (s *LoginSession) Clear() error

+ func (s *LoginSession) Dump()

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

+ func (s *LoginSession) Load() error

+ func (s *LoginSession) NotExpired() bool

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

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

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

+ func (s *LoginSession) Status() *keybase1.SessionStatus

+ type LoginSessionNotFound struct

+ SessionID int

+ func (e LoginSessionNotFound) Error() string

+ type LoginState struct

+ func NewLoginState(g *GlobalContext) *LoginState

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

+ func (s *LoginState) AccountDump()

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

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

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

+ func (s *LoginState) GetPassphraseStreamWithPassphrase(passphrase string) (pps *PassphraseStream, err error)

+ func (s *LoginState) GetUID() (ret keybase1.UID)

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

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

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

+ func (s *LoginState) LoggedIn() bool

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

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

+ func (s *LoginState) LoginSession(h func(*LoginSession), name string) error

+ func (s *LoginState) LoginWithKey(lctx LoginContext, user *User, key GenericKey, after afterFn) (err error)

+ func (s *LoginState) LoginWithPassphrase(username, passphrase string, storeSecret bool, after afterFn) (err error)

+ func (s *LoginState) LoginWithPrompt(username string, loginUI LoginUI, secretUI SecretUI, after afterFn) (err error)

+ func (s *LoginState) LoginWithStoredSecret(username string, after afterFn) (err error)

+ func (s *LoginState) Logout() error

+ func (s *LoginState) PassphraseStream() (*PassphraseStream, error)

+ func (s *LoginState) PassphraseStreamCache(h func(*PassphraseStreamCache), name string) error

+ func (s *LoginState) PassphraseStreamGeneration() (PassphraseGeneration, error)

+ func (s *LoginState) RunSecretSyncer(uid keybase1.UID) error

+ func (s *LoginState) SecretSyncer(h func(*SecretSyncer), name string) error

+ func (s *LoginState) Shutdown() error

+ func (s *LoginState) VerifyEmailAddress(email string, secretUI SecretUI, after afterFn) (err error)

+ func (s *LoginState) VerifyPlaintextPassphrase(pp string) (ppStream *PassphraseStream, err error)

+ type LoginUI interface

+ type LogoutError struct

+ func (e LogoutError) Error() string

+ type LoopbackAddr struct

+ func (la LoopbackAddr) Network() (s string)

+ func (la LoopbackAddr) String() (s string)

+ type LoopbackConn struct

+ func (lc *LoopbackConn) Close() (err error)

+ func (lc *LoopbackConn) LocalAddr() (addr net.Addr)

+ func (lc *LoopbackConn) Read(b []byte) (n int, err error)

+ func (lc *LoopbackConn) RemoteAddr() (addr net.Addr)

+ func (lc *LoopbackConn) SetDeadline(t time.Time) (err error)

+ func (lc *LoopbackConn) SetReadDeadline(t time.Time) (err error)

+ func (lc *LoopbackConn) SetWriteDeadline(t time.Time) (err error)

+ func (lc *LoopbackConn) Write(b []byte) (n int, err error)

+ type LoopbackListener struct

+ func NewLoopbackListener() *LoopbackListener

+ func (ll *LoopbackListener) Accept() (ret net.Conn, err error)

+ func (ll *LoopbackListener) Addr() (addr net.Addr)

+ func (ll *LoopbackListener) Close() (err error)

+ func (ll *LoopbackListener) Dial() (net.Conn, error)

+ type MakeProofCheckerFunc func(l RemoteProofChainLink) (ProofChecker, ProofError)

+ type Markup struct

+ func FmtMarkup(f string, args ...interface{}) *Markup

+ func NewMarkup(s string) *Markup

+ func (m *Markup) Append(s string)

+ func (m Markup) Export() (ret keybase1.Text)

+ func (m Markup) GetRaw() string

+ func (m Markup) ToReader() io.Reader

+ type MerkleClashError struct

+ func (m MerkleClashError) Error() string

+ type MerkleClient struct

+ func NewMerkleClient(g *GlobalContext) *MerkleClient

+ func (mc *MerkleClient) Init() error

+ func (mc *MerkleClient) LastRootToSigJSON() (ret *jsonw.Wrapper, err error)

+ func (mc *MerkleClient) LastSeqno() Seqno

+ func (mc *MerkleClient) LoadRoot() error

+ func (mc *MerkleClient) LookupPath(q HTTPArgs) (vp *VerificationPath, err error)

+ func (mc *MerkleClient) LookupUser(q HTTPArgs) (u *MerkleUserLeaf, err error)

+ func (mc *MerkleClient) VerifyRoot(root *MerkleRoot) error

+ type MerkleClientError struct

+ func (m MerkleClientError) Error() string

+ type MerkleNotFoundError struct

+ func (m MerkleNotFoundError) Error() string

+ type MerkleRoot struct

+ func NewMerkleRootFromJSON(jw *jsonw.Wrapper, g *GlobalContext) (ret *MerkleRoot, err error)

+ func (mr *MerkleRoot) Store() error

+ func (mr *MerkleRoot) ToJSON() (jw *jsonw.Wrapper)

+ func (mr *MerkleRoot) ToSigJSON() (ret *jsonw.Wrapper)

+ type MerkleTriple struct

+ LinkID LinkID

+ Seqno Seqno

+ SigID keybase1.SigID

+ func GetMerkleTriple(jw *jsonw.Wrapper) (ret *MerkleTriple, err error)

+ func (mt1 MerkleTriple) Less(mt2 MerkleTriple) bool

+ type MerkleUserLeaf struct

+ func (mul *MerkleUserLeaf) MatchUser(u *User, uid keybase1.UID, nun NormalizedUsername) (err error)

+ type MissingDelegationTypeError struct

+ func (e MissingDelegationTypeError) Error() string

+ type NaclDHKeyPair struct

+ Private *NaclDHKeyPrivate

+ Public NaclDHKeyPublic

+ func GenerateNaclDHKeyPair() (NaclDHKeyPair, error)

+ func ImportNaclDHKeyPairFromBytes(pub []byte, priv []byte) (ret NaclDHKeyPair, err error)

+ func ImportNaclDHKeyPairFromHex(s string) (ret NaclDHKeyPair, err error)

+ func MakeNaclDHKeyPairFromSecret(secret [NaclDHKeySecretSize]byte) (NaclDHKeyPair, error)

+ func (k NaclDHKeyPair) CanDecrypt() bool

+ func (k NaclDHKeyPair) CanEncrypt() bool

+ func (k NaclDHKeyPair) CanSign() bool

+ func (k NaclDHKeyPair) CheckSecretKey() error

+ func (k NaclDHKeyPair) Decrypt(nei *NaclEncryptionInfo) (plaintext []byte, sender keybase1.KID, err error)

+ func (k NaclDHKeyPair) DecryptFromString(ciphertext string) (msg []byte, sender keybase1.KID, err error)

+ func (k NaclDHKeyPair) Encode() (string, error)

+ func (k NaclDHKeyPair) Encrypt(msg []byte, sender *NaclDHKeyPair) (*NaclEncryptionInfo, error)

+ func (k NaclDHKeyPair) EncryptToString(plaintext []byte, sender GenericKey) (string, error)

+ func (k NaclDHKeyPair) GetAlgoType() AlgoType

+ func (k NaclDHKeyPair) GetFingerprintP() *PGPFingerprint

+ func (k NaclDHKeyPair) GetKID() keybase1.KID

+ func (k NaclDHKeyPair) HasSecretKey() bool

+ func (k NaclDHKeyPair) IsNil() bool

+ func (k NaclDHKeyPair) SignToString(msg []byte) (sig string, id keybase1.SigID, err error)

+ func (k NaclDHKeyPair) ToLksSKB(lks *LKSec) (*SKB, error)

+ func (k NaclDHKeyPair) ToServerSKB(gc *GlobalContext, t *triplesec.Cipher, gen PassphraseGeneration) (*SKB, error)

+ func (k NaclDHKeyPair) ToShortIDString() string

+ func (k NaclDHKeyPair) VerboseDescription() string

+ func (k NaclDHKeyPair) VerifyString(sig string, msg []byte) (id keybase1.SigID, err error)

+ func (k NaclDHKeyPair) VerifyStringAndExtract(sig string) (msg []byte, id keybase1.SigID, err error)

+ type NaclDHKeyPrivate [NaclDHKeysize]byte

+ type NaclDHKeyPublic [NaclDHKeysize]byte

+ func (k NaclDHKeyPublic) GetKID() keybase1.KID

+ type NaclEncryptionInfo struct

+ Ciphertext []byte

+ EncryptionType int

+ Nonce []byte

+ Receiver []byte

+ Sender []byte

+ func (k *NaclEncryptionInfo) ToPacket() (ret *KeybasePacket, err error)

+ type NaclGenerator func() (NaclKeyPair, error)

+ type NaclKeyGen struct

+ func NewNaclKeyGen(arg NaclKeyGenArg) *NaclKeyGen

+ func (g *NaclKeyGen) Generate() (err error)

+ func (g *NaclKeyGen) GetKeyPair() NaclKeyPair

+ func (g *NaclKeyGen) Push(lctx LoginContext, aggregated bool) (d Delegator, err error)

+ func (g *NaclKeyGen) SaveLKS(gc *GlobalContext, lks *LKSec, lctx LoginContext) error

+ func (g *NaclKeyGen) UpdateArg(signer GenericKey, eldestKID keybase1.KID, sibkey bool, user *User)

+ type NaclKeyGenArg struct

+ Device *Device

+ EldestKeyID keybase1.KID

+ ExpireIn int

+ ExpiresIn int

+ Generator NaclGenerator

+ Me *User

+ RevSig string

+ Sibkey bool

+ Signer GenericKey

+ type NaclKeyPair interface

+ type NaclSigInfo struct

+ Detached bool

+ HashType int

+ Kid []byte

+ Payload []byte

+ Sig NaclSignature

+ SigType int

+ func (s *NaclSigInfo) ArmoredEncode() (ret string, err error)

+ func (s *NaclSigInfo) ToPacket() (ret *KeybasePacket, err error)

+ func (s NaclSigInfo) Verify() (error, *NaclSigningKeyPublic)

+ type NaclSignature [ed25519.SignatureSize]byte

+ type NaclSigningKeyPair struct

+ Private *NaclSigningKeyPrivate

+ Public NaclSigningKeyPublic

+ func GenerateNaclSigningKeyPair() (NaclSigningKeyPair, error)

+ func ImportNaclSigningKeyPairFromBytes(pub []byte, priv []byte) (ret NaclSigningKeyPair, err error)

+ func ImportNaclSigningKeyPairFromHex(s string) (ret NaclSigningKeyPair, err error)

+ func MakeNaclSigningKeyPairFromSecret(secret [NaclSigningKeySecretSize]byte) (NaclSigningKeyPair, error)

+ func (k NaclSigningKeyPair) CanDecrypt() bool

+ func (k NaclSigningKeyPair) CanEncrypt() bool

+ func (k NaclSigningKeyPair) CanSign() bool

+ func (k NaclSigningKeyPair) CheckSecretKey() error

+ func (k NaclSigningKeyPair) DecryptFromString(ciphertext string) (msg []byte, sender keybase1.KID, err error)

+ func (k NaclSigningKeyPair) Encode() (string, error)

+ func (k NaclSigningKeyPair) EncryptToString(plaintext []byte, sender GenericKey) (ciphertext string, err error)

+ func (k NaclSigningKeyPair) GetAlgoType() AlgoType

+ func (k NaclSigningKeyPair) GetFingerprintP() *PGPFingerprint

+ func (k NaclSigningKeyPair) GetKID() (ret keybase1.KID)

+ func (k NaclSigningKeyPair) HasSecretKey() bool

+ func (k NaclSigningKeyPair) Sign(msg []byte) (ret *NaclSigInfo, err error)

+ func (k NaclSigningKeyPair) SignToString(msg []byte) (sig string, id keybase1.SigID, err error)

+ func (k NaclSigningKeyPair) ToLksSKB(lks *LKSec) (*SKB, error)

+ func (k NaclSigningKeyPair) ToServerSKB(gc *GlobalContext, t *triplesec.Cipher, gen PassphraseGeneration) (*SKB, error)

+ func (k NaclSigningKeyPair) ToShortIDString() string

+ func (k NaclSigningKeyPair) VerboseDescription() string

+ func (k NaclSigningKeyPair) VerifyString(sig string, msg []byte) (id keybase1.SigID, err error)

+ func (k NaclSigningKeyPair) VerifyStringAndExtract(sig string) (msg []byte, id keybase1.SigID, err error)

+ type NaclSigningKeyPrivate [ed25519.PrivateKeySize]byte

+ func (k NaclSigningKeyPrivate) Sign(msg []byte) *NaclSignature

+ type NaclSigningKeyPublic [ed25519.PublicKeySize]byte

+ func KIDToNaclSigningKeyPublic(bk []byte) *NaclSigningKeyPublic

+ func (k NaclSigningKeyPublic) GetKID() keybase1.KID

+ func (k NaclSigningKeyPublic) Verify(msg []byte, sig *NaclSignature) bool

+ type NamedLock struct

+ func (l *NamedLock) Release()

+ type NeedInputError struct

+ func (e NeedInputError) Error() string

+ type NegBoolFunc struct

+ type NoActiveKeyError struct

+ Username string

+ func (c NoActiveKeyError) ToStatus() (s keybase1.Status)

+ func (e NoActiveKeyError) Error() string

+ type NoConfigFile struct

+ func (n NoConfigFile) Error() string

+ type NoConfigWriterError struct

+ func (e NoConfigWriterError) Error() string

+ type NoDecryptionKeyError struct

+ Msg string

+ func (e NoDecryptionKeyError) Error() string

+ func (e NoDecryptionKeyError) ToStatus() (s keybase1.Status)

+ type NoDeviceError struct

+ Reason string

+ func (e NoDeviceError) Error() string

+ func (e NoDeviceError) ToStatus() keybase1.Status

+ type NoEldestKeyError struct

+ func (e NoEldestKeyError) Error() string

+ type NoKeyError struct

+ Msg string

+ func (e NoKeyError) ToStatus() (s keybase1.Status)

+ func (u NoKeyError) Error() string

+ type NoKeyringsError struct

+ func (k NoKeyringsError) Error() string

+ type NoMatchingGPGKeysError struct

+ Fingerprints []string

+ HasActiveDevice bool

+ func (e NoMatchingGPGKeysError) Error() string

+ func (e NoMatchingGPGKeysError) ToStatus() keybase1.Status

+ type NoNaClEncryptionKeyError struct

+ HasPGPKey bool

+ User string

+ func (e NoNaClEncryptionKeyError) Error() string

+ func (e NoNaClEncryptionKeyError) ToStatus() keybase1.Status

+ type NoPGPEncryptionKeyError struct

+ HasDeviceKey bool

+ User string

+ func (e NoPGPEncryptionKeyError) Error() string

+ func (e NoPGPEncryptionKeyError) ToStatus() keybase1.Status

+ type NoPaperKeysError struct

+ func (u NoPaperKeysError) Error() string

+ type NoSecretKeyError struct

+ func (u NoSecretKeyError) Error() string

+ func (u NoSecretKeyError) ToStatus() (s keybase1.Status)

+ type NoSelectedKeyError struct

+ func (n NoSelectedKeyError) Error() string

+ type NoSessionWriterError struct

+ func (e NoSessionWriterError) Error() string

+ type NoSigChainError struct

+ func (e NoSigChainError) Error() string

+ type NoSyncedPGPKeyError struct

+ func (e NoSyncedPGPKeyError) Error() string

+ func (e NoSyncedPGPKeyError) ToStatus() keybase1.Status

+ type NoUIDError struct

+ func (e NoUIDError) Error() string

+ type NoUIError struct

+ Which string

+ func (e NoUIError) Error() string

+ func (e NoUIError) ToStatus() keybase1.Status

+ type NoUserConfigError struct

+ func (n NoUserConfigError) Error() string

+ type NoUsernameError struct

+ func (e NoUsernameError) Error() string

+ type NodeHash interface

+ Check func(s string) bool

+ String func() string

+ func GetNodeHash(w *jsonw.Wrapper) (NodeHash, error)

+ func NodeHashFromHex(s string) (NodeHash, error)

+ type NodeHashLong [NodeHashLenLong]byte

+ func (h1 NodeHashLong) Check(s string) bool

+ func (h1 NodeHashLong) String() string

+ type NodeHashShort [NodeHashLenShort]byte

+ func (h1 NodeHashShort) Check(s string) bool

+ func (h1 NodeHashShort) String() string

+ type NopWriteCloser struct

+ W io.Writer

+ func (c NopWriteCloser) Close() error

+ func (c NopWriteCloser) Write(data []byte) (n int, err error)

+ type NormalizedUsername string

+ func NewNormalizedUsername(s string) NormalizedUsername

+ func (n NormalizedUsername) Eq(n2 NormalizedUsername) bool

+ func (n NormalizedUsername) IsNil() bool

+ func (n NormalizedUsername) String() string

+ type NotConfirmedError struct

+ func (e NotConfirmedError) Error() string

+ type NotFoundError struct

+ Msg string

+ func (e NotFoundError) Error() string

+ type NotLatestSubchainError struct

+ Msg string

+ func (e NotLatestSubchainError) Error() string

+ type NotProvisionedError struct

+ func (e NotProvisionedError) Error() string

+ type NotifyRouter struct

+ func NewNotifyRouter(g *GlobalContext) *NotifyRouter

+ func (n *NotifyRouter) AddConnection(xp rpc.Transporter, ch chan error) ConnectionID

+ func (n *NotifyRouter) HandleClientOutOfDate(upgradeTo string, upgradeURI string)

+ func (n *NotifyRouter) HandleFSActivity(activity keybase1.FSNotification)

+ func (n *NotifyRouter) HandleLogin(u string)

+ func (n *NotifyRouter) HandleLogout()

+ func (n *NotifyRouter) HandleTrackingChanged(uid keybase1.UID, username string)

+ func (n *NotifyRouter) HandleUserChanged(uid keybase1.UID)

+ func (n *NotifyRouter) SetChannels(i ConnectionID, nc keybase1.NotificationChannels)

+ func (n *NotifyRouter) Shutdown()

+ type NullConfiguration struct

+ func (n NullConfiguration) GetAPIDump() (bool, bool)

+ func (n NullConfiguration) GetAPITimeout() (time.Duration, bool)

+ func (n NullConfiguration) GetAllUsernames() (NormalizedUsername, []NormalizedUsername, error)

+ func (n NullConfiguration) GetAppStartMode() AppStartMode

+ func (n NullConfiguration) GetAutoFork() (bool, bool)

+ func (n NullConfiguration) GetBool(string, bool) (bool, bool)

+ func (n NullConfiguration) GetBoolAtPath(string) (bool, bool)

+ func (n NullConfiguration) GetBundledCA(h string) string

+ func (n NullConfiguration) GetCodeSigningKIDs() []string

+ func (n NullConfiguration) GetConfigFilename() string

+ func (n NullConfiguration) GetDbFilename() string

+ func (n NullConfiguration) GetDebug() (bool, bool)

+ func (n NullConfiguration) GetDeviceID() keybase1.DeviceID

+ func (n NullConfiguration) GetEmail() string

+ func (n NullConfiguration) GetGString(string) string

+ func (n NullConfiguration) GetGpg() string

+ func (n NullConfiguration) GetGpgHome() string

+ func (n NullConfiguration) GetGpgOptions() []string

+ func (n NullConfiguration) GetHome() string

+ func (n NullConfiguration) GetIntAtPath(string) (int, bool)

+ func (n NullConfiguration) GetInterfaceAtPath(string) (interface{}, error)

+ func (n NullConfiguration) GetLinkCacheCleanDur() (time.Duration, bool)

+ func (n NullConfiguration) GetLinkCacheSize() (int, bool)

+ func (n NullConfiguration) GetLocalRPCDebug() string

+ func (n NullConfiguration) GetLocalTrackMaxAge() (time.Duration, bool)

+ func (n NullConfiguration) GetLogFile() string

+ func (n NullConfiguration) GetLogFormat() string

+ func (n NullConfiguration) GetMerkleKIDs() []string

+ func (n NullConfiguration) GetNoAutoFork() (bool, bool)

+ func (n NullConfiguration) GetNoPinentry() (bool, bool)

+ func (n NullConfiguration) GetNullAtPath(string) bool

+ func (n NullConfiguration) GetPGPFingerprint() *PGPFingerprint

+ func (n NullConfiguration) GetPidFile() string

+ func (n NullConfiguration) GetPinentry() string

+ func (n NullConfiguration) GetProofCacheLongDur() (time.Duration, bool)

+ func (n NullConfiguration) GetProofCacheMediumDur() (time.Duration, bool)

+ func (n NullConfiguration) GetProofCacheShortDur() (time.Duration, bool)

+ func (n NullConfiguration) GetProofCacheSize() (int, bool)

+ func (n NullConfiguration) GetProxy() string

+ func (n NullConfiguration) GetProxyCACerts() ([]string, error)

+ func (n NullConfiguration) GetRunMode() (RunMode, error)

+ func (n NullConfiguration) GetSalt() []byte

+ func (n NullConfiguration) GetScraperTimeout() (time.Duration, bool)

+ func (n NullConfiguration) GetSecretKeyringTemplate() string

+ func (n NullConfiguration) GetSecurityAccessGroupOverride() (bool, bool)

+ func (n NullConfiguration) GetServerURI() string

+ func (n NullConfiguration) GetSessionFilename() string

+ func (n NullConfiguration) GetSocketFile() string

+ func (n NullConfiguration) GetStandalone() (bool, bool)

+ func (n NullConfiguration) GetString(string) string

+ func (n NullConfiguration) GetStringAtPath(string) (string, bool)

+ func (n NullConfiguration) GetTimers() string

+ func (n NullConfiguration) GetTorHiddenAddress() string

+ func (n NullConfiguration) GetTorMode() (TorMode, error)

+ func (n NullConfiguration) GetTorProxy() string

+ func (n NullConfiguration) GetUID() (ret keybase1.UID)

+ func (n NullConfiguration) GetUpdateLastChecked() keybase1.Time

+ func (n NullConfiguration) GetUpdatePreferenceAuto() (bool, bool)

+ func (n NullConfiguration) GetUpdatePreferenceSkip() string

+ func (n NullConfiguration) GetUpdatePreferenceSnoozeUntil() keybase1.Time

+ func (n NullConfiguration) GetUpdateURL() string

+ func (n NullConfiguration) GetUserCacheMaxAge() (time.Duration, bool)

+ func (n NullConfiguration) GetUserConfig() (*UserConfig, error)

+ func (n NullConfiguration) GetUserConfigForUsername(s NormalizedUsername) (*UserConfig, error)

+ func (n NullConfiguration) GetUsername() NormalizedUsername

+ func (n NullConfiguration) GetVDebugSetting() string

+ func (n NullConfiguration) IsAdmin() (bool, bool)

+ type ObjType byte

+ type OutputDescriptor int

+ type PGPFingerprint [PGPFingerprintLen]byte

+ func GetPGPFingerprint(w *jsonw.Wrapper) (*PGPFingerprint, error)

+ func ImportPGPFingerprintSlice(fp []byte) (ret *PGPFingerprint)

+ func PGPFingerprintFromHex(s string) (*PGPFingerprint, error)

+ func PGPFingerprintFromHexNoError(s string) *PGPFingerprint

+ func PGPFingerprintFromSlice(b []byte) (*PGPFingerprint, error)

+ func (p *PGPFingerprint) Match(q string, exact bool) bool

+ func (p PGPFingerprint) Eq(p2 PGPFingerprint) bool

+ func (p PGPFingerprint) GetProofState() keybase1.ProofState

+ func (p PGPFingerprint) GetProofType() keybase1.ProofType

+ func (p PGPFingerprint) LastWriterWins() bool

+ func (p PGPFingerprint) String() string

+ func (p PGPFingerprint) ToDisplayString(verbose bool) string

+ func (p PGPFingerprint) ToIDString() string

+ func (p PGPFingerprint) ToKeyID() string

+ func (p PGPFingerprint) ToKeyValuePair() (string, string)

+ func (p PGPFingerprint) ToQuads() string

+ type PGPGenArg struct

+ Config *packet.Config

+ Ids Identities

+ PGPUids []string

+ PrimaryBits int

+ PrimaryLifetime int

+ SubkeyBits int

+ SubkeyLifetime int

+ func ImportKeyGenArg(a keybase1.PGPKeyGenArg) (ret PGPGenArg)

+ func (a *PGPGenArg) AddDefaultUID()

+ func (a *PGPGenArg) CreatePGPIDs() error

+ func (a *PGPGenArg) Init() (err error)

+ func (a *PGPGenArg) MakeAllIds() error

+ func (a *PGPGenArg) PGPUserIDs() ([]*packet.UserId, error)

+ func (a *PGPGenArg) PreferredCompression() []uint8

+ func (a *PGPGenArg) PreferredHash() []uint8

+ func (a *PGPGenArg) PreferredSymmetric() []uint8

+ func (a PGPGenArg) ExportTo(ret *keybase1.PGPKeyGenArg)

+ type PGPKeyBundle struct

+ ArmoredPublicKey string

+ GPGFallbackKey GenericKey

+ Generated bool

+ func GeneratePGPKeyBundle(arg PGPGenArg, logUI LogUI) (*PGPKeyBundle, error)

+ func GetOneKey(jw *jsonw.Wrapper) (*PGPKeyBundle, error)

+ func LoadPGPKeyFromLocalDB(k keybase1.KID, g *GlobalContext) (*PGPKeyBundle, error)

+ func NewGeneratedPGPKeyBundle(entity *openpgp.Entity) *PGPKeyBundle

+ func NewPGPKeyBundle(entity *openpgp.Entity) *PGPKeyBundle

+ func ReadOneKeyFromBytes(b []byte) (*PGPKeyBundle, error)

+ func ReadOneKeyFromString(originalArmor string) (*PGPKeyBundle, error)

+ func ReadPrivateKeyFromString(s string) (*PGPKeyBundle, error)

+ func (bundle *PGPKeyBundle) Export() keybase1.PublicKey

+ func (k *PGPKeyBundle) CanDecrypt() bool

+ func (k *PGPKeyBundle) CanEncrypt() bool

+ func (k *PGPKeyBundle) CanSign() bool

+ func (k *PGPKeyBundle) CheckFingerprint(fp *PGPFingerprint) error

+ func (k *PGPKeyBundle) CheckIdentity(kbid Identity) (match bool, ctime int64, etime int64)

+ func (k *PGPKeyBundle) CheckSecretKey() (err error)

+ func (k *PGPKeyBundle) DecryptFromString(ciphertext string) (msg []byte, sender keybase1.KID, err error)

+ func (k *PGPKeyBundle) Encode() (ret string, err error)

+ func (k *PGPKeyBundle) EncodeToStream(wc io.WriteCloser, private bool) error

+ func (k *PGPKeyBundle) EncryptToString(plaintext []byte, sender GenericKey) (ciphertext string, err error)

+ func (k *PGPKeyBundle) FindEmail(em string) bool

+ func (k *PGPKeyBundle) FindKeybaseUsername(un string) bool

+ func (k *PGPKeyBundle) FullHash() (string, error)

+ func (k *PGPKeyBundle) GetKID() keybase1.KID

+ func (k *PGPKeyBundle) GetPGPIdentities() []keybase1.PGPIdentity

+ func (k *PGPKeyBundle) HasSecretKey() bool

+ func (k *PGPKeyBundle) IdentityNames() []string

+ func (k *PGPKeyBundle) InitGPGKey()

+ func (k *PGPKeyBundle) SerializePrivate(w io.Writer) error

+ func (k *PGPKeyBundle) SignToString(msg []byte) (sig string, id keybase1.SigID, err error)

+ func (k *PGPKeyBundle) StoreToLocalDb(g *GlobalContext) error

+ func (k *PGPKeyBundle) StripRevocations() (strippedKey *PGPKeyBundle)

+ func (k *PGPKeyBundle) Unlock(reason string, secretUI SecretUI) error

+ func (k PGPKeyBundle) DecryptionKeys() []openpgp.Key

+ func (k PGPKeyBundle) GetAlgoType() AlgoType

+ func (k PGPKeyBundle) GetFingerprint() PGPFingerprint

+ func (k PGPKeyBundle) GetFingerprintP() *PGPFingerprint

+ func (k PGPKeyBundle) GetPrimaryUID() string

+ func (k PGPKeyBundle) HumanDescription() string

+ func (k PGPKeyBundle) KeyDescription() string

+ func (k PGPKeyBundle) KeyInfo() (algorithm, kid, creation string)

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

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

+ func (k PGPKeyBundle) MatchesKey(key *openpgp.Key) bool

+ func (k PGPKeyBundle) SamePrimaryAs(k2 PGPKeyBundle) bool

+ func (k PGPKeyBundle) UsersDescription() []string

+ func (k PGPKeyBundle) VerboseDescription() string

+ func (k PGPKeyBundle) VerifyString(sig string, msg []byte) (id keybase1.SigID, err error)

+ func (k PGPKeyBundle) VerifyStringAndExtract(sig string) (msg []byte, id keybase1.SigID, err error)

+ func (key *PGPKeyBundle) ToLksSKB(lks *LKSec) (ret *SKB, err error)

+ func (key *PGPKeyBundle) ToServerSKB(gc *GlobalContext, tsec *triplesec.Cipher, gen PassphraseGeneration) (ret *SKB, err error)

+ func (to *PGPKeyBundle) MergeKey(from *PGPKeyBundle)

+ type PGPKeySet struct

+ KeysByHash map[string]*PGPKeyBundle

+ PermissivelyMergedKey *PGPKeyBundle

+ type PGPPullLoggedOutError struct

+ func (e PGPPullLoggedOutError) Error() string

+ type PGPUpdateChainLink struct

+ func ParsePGPUpdateChainLink(b GenericChainLink) (ret *PGPUpdateChainLink, err error)

+ func (l *PGPUpdateChainLink) GetPGPFullHash() string

+ func (l *PGPUpdateChainLink) ToDisplayString() string

+ func (l *PGPUpdateChainLink) Type() string

+ type PIDFileLockError struct

+ Filename string

+ func (e PIDFileLockError) Error() string

+ type Packetable interface

+ ToPacket func() (*KeybasePacket, error)

+ type PaperKeyPhrase string

+ func MakePaperKeyPhrase(version uint8) (PaperKeyPhrase, error)

+ func NewPaperKeyPhrase(phrase string) PaperKeyPhrase

+ func NewPaperKeyPhraseCheckVersion(g *GlobalContext, passphrase string) (ret PaperKeyPhrase, err error)

+ func (p PaperKeyPhrase) Bytes() []byte

+ func (p PaperKeyPhrase) Prefix() string

+ func (p PaperKeyPhrase) String() string

+ func (p PaperKeyPhrase) Version() (uint8, error)

+ type ParsedSig struct

+ Block *armor.Block

+ LiteralData []byte

+ MD *openpgp.MessageDetails

+ SigBody []byte

+ func PGPOpenSig(armored string) (ps *ParsedSig, err error)

+ func (ps *ParsedSig) AssertPayload(expected []byte) error

+ func (ps *ParsedSig) ID() keybase1.SigID

+ func (ps *ParsedSig) Verify(k PGPKeyBundle) (err error)

+ type Parser struct

+ func NewParser(lexer *Lexer) *Parser

+ func (p *Parser) Parse() AssertionExpression

+ type PassphraseError struct

+ Msg string

+ func (p PassphraseError) Error() string

+ func (p PassphraseError) ToStatus() (s keybase1.Status)

+ type PassphraseGeneration int

+ type PassphrasePrompter interface

+ Prompt func(keybase1.GUIEntryArg) (keybase1.GetPassphraseRes, error)

+ type PassphraseProvisionImpossibleError struct

+ func (e PassphraseProvisionImpossibleError) Error() string

+ type PassphraseStream struct

+ func NewPassphraseStream(s []byte) *PassphraseStream

+ func StretchPassphrase(passphrase string, salt []byte) (tsec *triplesec.Cipher, pps *PassphraseStream, err error)

+ func (ps *PassphraseStream) Clone() *PassphraseStream

+ func (ps *PassphraseStream) SetGeneration(gen PassphraseGeneration)

+ func (ps PassphraseStream) DHSeed() []byte

+ func (ps PassphraseStream) EdDSASeed() []byte

+ func (ps PassphraseStream) Export() keybase1.PassphraseStream

+ func (ps PassphraseStream) Generation() PassphraseGeneration

+ func (ps PassphraseStream) LksClientHalf() []byte

+ func (ps PassphraseStream) PWHash() []byte

+ func (ps PassphraseStream) String() string

+ type PassphraseStreamCache struct

+ func NewPassphraseStreamCache(tsec *triplesec.Cipher, ps *PassphraseStream) *PassphraseStreamCache

+ func (s *PassphraseStreamCache) Clear()

+ func (s *PassphraseStreamCache) Dump()

+ func (s *PassphraseStreamCache) PassphraseStream() *PassphraseStream

+ func (s *PassphraseStreamCache) PassphraseStreamRef() *PassphraseStream

+ func (s *PassphraseStreamCache) Triplesec() *triplesec.Cipher

+ func (s *PassphraseStreamCache) Valid() bool

+ type PassphraseStreamCacheReader interface

+ PassphraseStream func() *PassphraseStream

+ Triplesec func() *triplesec.Cipher

+ Valid func() bool

+ type PathStep struct

+ type PathSteps []*PathStep

+ func (path PathSteps) VerifyPath(curr NodeHash, uidS string) (juser *jsonw.Wrapper, err error)

+ type PgpUI interface

+ type PostAuthProofArg struct

+ type PostAuthProofRes struct

+ AuthID string

+ CSRFToken string

+ PPGen int

+ SessionID string

+ UIDHex string

+ Username string

+ func PostAuthProof(arg PostAuthProofArg) (*PostAuthProofRes, error)

+ type PostProofArg struct

+ ID keybase1.SigID

+ ProofType string

+ RemoteKey string

+ RemoteUsername string

+ Sig string

+ SigningKey GenericKey

+ Supersede bool

+ type PostProofRes struct

+ ID string

+ Metadata *jsonw.Wrapper

+ Text string

+ func PostProof(arg PostProofArg) (*PostProofRes, error)

+ type ProfileNotPublicError struct

+ func (e ProfileNotPublicError) ToStatus() keybase1.Status

+ func (p ProfileNotPublicError) Error() string

+ type PromptArg struct

+ Checker *Checker

+ PinentryDesc string

+ PinentryPrompt string

+ RetryMessage string

+ TerminalPrompt string

+ UseSecretStore bool

+ type PromptDefault int

+ const PromptDefaultNeither

+ const PromptDefaultNo

+ const PromptDefaultYes

+ type PromptDescriptor int

+ type Proof struct

+ Key string

+ Value string

+ func RemoteProofChainLinkToProof(r RemoteProofChainLink) Proof

+ type ProofAPIError struct

+ func NewProofAPIError(s keybase1.ProofStatus, u string, d string, a ...interface{}) *ProofAPIError

+ func XapiError(err error, u string) *ProofAPIError

+ type ProofCache struct

+ func NewProofCache(g *GlobalContext, capac int) *ProofCache

+ func (pc *ProofCache) Get(sid keybase1.SigID) *CheckResult

+ func (pc *ProofCache) Put(sid keybase1.SigID, pe ProofError) error

+ type ProofChecker interface

+ CheckHint func(h SigHint) ProofError

+ CheckStatus func(h SigHint) ProofError

+ GetTorError func() ProofError

+ type ProofCheckerFactory interface

+ MakeProofChecker func(l RemoteProofChainLink) (ProofChecker, ProofError)

+ type ProofError interface

+ GetDesc func() string

+ GetProofStatus func() keybase1.ProofStatus

+ func ImportProofError(e keybase1.ProofResult) ProofError

+ type ProofErrorImpl struct

+ Desc string

+ Status keybase1.ProofStatus

+ func NewProofError(s keybase1.ProofStatus, d string, a ...interface{}) *ProofErrorImpl

+ func (e *ProofErrorImpl) Error() string

+ func (e *ProofErrorImpl) GetDesc() string

+ func (e *ProofErrorImpl) GetProofStatus() keybase1.ProofStatus

+ type ProofLinkWithState struct

+ func (p ProofLinkWithState) GetProofState() keybase1.ProofState

+ func (p ProofLinkWithState) GetProofType() keybase1.ProofType

+ func (p ProofLinkWithState) LastWriterWins() bool

+ func (p ProofLinkWithState) ToIDString() string

+ func (p ProofLinkWithState) ToKeyValuePair() (string, string)

+ type ProofMetadata struct

+ CreationTime int64

+ Eldest keybase1.KID

+ ExpireIn int

+ IncludePGPHash bool

+ LastSeqno Seqno

+ LinkType LinkType

+ Me *User

+ PrevLinkID LinkID

+ SigningKey GenericKey

+ SigningUser UserBasic

+ func (arg ProofMetadata) ToJSON(g *GlobalContext) (ret *jsonw.Wrapper, err error)

+ type ProofNotFoundForServiceError struct

+ Service string

+ func (e ProofNotFoundForServiceError) Error() string

+ func (e ProofNotFoundForServiceError) ToStatus() (s keybase1.Status)

+ type ProofNotFoundForUsernameError struct

+ Service string

+ Username string

+ func (e ProofNotFoundForUsernameError) Error() string

+ func (e ProofNotFoundForUsernameError) ToStatus() (s keybase1.Status)

+ type ProofNotYetAvailableError struct

+ func (e ProofNotYetAvailableError) Error() string

+ type ProofSet struct

+ func NewProofSet(proofs []Proof) *ProofSet

+ func (ps *ProofSet) Add(p Proof)

+ func (ps ProofSet) Get(keys []string) (ret []Proof)

+ type ProtocolDowngradeError struct

+ func (h ProtocolDowngradeError) Error() string

+ type ProveUI interface

+ DisplayRecheckWarning func(context.Context, keybase1.DisplayRecheckWarningArg) error

+ OkToCheck func(context.Context, keybase1.OkToCheckArg) (bool, error)

+ OutputInstructions func(context.Context, keybase1.OutputInstructionsArg) error

+ OutputPrechecks func(context.Context, keybase1.OutputPrechecksArg) error

+ PreProofWarning func(context.Context, keybase1.PreProofWarningArg) (bool, error)

+ PromptOverwrite func(context.Context, keybase1.PromptOverwriteArg) (bool, error)

+ PromptUsername func(context.Context, keybase1.PromptUsernameArg) (string, error)

+ type ProvisionUI interface

+ type ProvisionUnavailableError struct

+ func (e ProvisionUnavailableError) Error() string

+ func (e ProvisionUnavailableError) ToStatus() keybase1.Status

+ type PublicKeyList []keybase1.PublicKey

+ func (l PublicKeyList) Len() int

+ func (l PublicKeyList) Less(i, j int) bool

+ func (l PublicKeyList) Swap(i, j int)

+ type RPCLogFactory struct

+ func NewRPCLogFactory(g *GlobalContext) *RPCLogFactory

+ func (r *RPCLogFactory) NewLog(a net.Addr) rpc.LogInterface

+ type RPCLogOptions struct

+ func (r *RPCLogOptions) ClientTrace() bool

+ func (r *RPCLogOptions) Profile() bool

+ func (r *RPCLogOptions) Reload()

+ func (r *RPCLogOptions) ServerTrace() bool

+ func (r *RPCLogOptions) ShowAddress() bool

+ func (r *RPCLogOptions) ShowArg() bool

+ func (r *RPCLogOptions) ShowResult() bool

+ func (r *RPCLogOptions) TransportStart() bool

+ type RateLimitCategory string

+ const CheckTrackingRateLimit

+ const TestEventRateLimit

+ type RateLimits struct

+ func NewRateLimits(g *GlobalContext) *RateLimits

+ func (r *RateLimits) GetPermission(category RateLimitCategory, interval time.Duration) bool

+ type RawKeyFamily struct

+ AllBundles []string

+ type ReadCloser struct

+ type ReceiverDeviceError struct

+ Msg string

+ func NewReceiverDeviceError(expected, received keybase1.DeviceID) ReceiverDeviceError

+ func (e ReceiverDeviceError) Error() string

+ func (e ReceiverDeviceError) ToStatus() keybase1.Status

+ type RedditChecker struct

+ func (rc *RedditChecker) CheckData(h SigHint, dat *jsonw.Wrapper) ProofError

+ func (rc *RedditChecker) CheckHint(h SigHint) ProofError

+ func (rc *RedditChecker) CheckStatus(h SigHint) ProofError

+ func (rc *RedditChecker) GetTorError() ProofError

+ func (rc *RedditChecker) ScreenNameCompare(s1, s2 string) bool

+ func (rc *RedditChecker) UnpackData(inp *jsonw.Wrapper) (*jsonw.Wrapper, ProofError)

+ type RedditServiceType struct

+ func (t RedditServiceType) AllStringKeys() []string

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

+ func (t RedditServiceType) CheckUsername(s string) (err error)

+ func (t RedditServiceType) DisplayName(un string) string

+ func (t RedditServiceType) FormatProofText(ppr *PostProofRes) (res string, err error)

+ func (t RedditServiceType) GetPrompt() string

+ func (t RedditServiceType) GetProofType() string

+ func (t RedditServiceType) GetTypeName() string

+ func (t RedditServiceType) PostInstructions(un string) *Markup

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

+ func (t RedditServiceType) ToChecker() Checker

+ func (t RedditServiceType) ToServiceJSON(un string) *jsonw.Wrapper

+ type ReloginRequiredError struct

+ func (e ReloginRequiredError) Error() string

+ func (e ReloginRequiredError) ToStatus() keybase1.Status

+ type RemoteProofChainLink interface

+ CheckDataJSON func() *jsonw.Wrapper

+ ComputeTrackDiff func(tl *TrackLookup) TrackDiff

+ DisplayCheck func(ui IdentifyUI, lcr LinkCheckResult)

+ GetHostname func() string

+ GetProofType func() keybase1.ProofType

+ GetProtocol func() string

+ GetRemoteUsername func() string

+ LastWriterWins func() bool

+ ProofText func() string

+ TableKey func() string

+ ToIDString func() string

+ ToKeyValuePair func() (string, string)

+ ToTrackingStatement func(keybase1.ProofState) (*jsonw.Wrapper, error)

+ func ParseWebServiceBinding(base GenericChainLink) (ret RemoteProofChainLink, e error)

+ type RemoteProofLinks struct

+ func NewRemoteProofLinks() *RemoteProofLinks

+ func (r *RemoteProofLinks) Active() []RemoteProofChainLink

+ func (r *RemoteProofLinks) AddProofsToSet(existing *ProofSet, okStates []keybase1.ProofState)

+ func (r *RemoteProofLinks) ForService(st ServiceType) []RemoteProofChainLink

+ func (r *RemoteProofLinks) Insert(link RemoteProofChainLink, err ProofError)

+ func (r *RemoteProofLinks) TrackSet() *TrackSet

+ func (r *RemoteProofLinks) TrackingStatement() *jsonw.Wrapper

+ type RemoteStream struct

+ Cli *keybase1.StreamUiClient

+ SessionID int

+ Stream keybase1.Stream

+ func (ewc RemoteStream) Close() (err error)

+ func (ewc RemoteStream) Read(buf []byte) (n int, err error)

+ func (ewc RemoteStream) Write(buf []byte) (n int, err error)

+ type RemoteStreamBuffered struct

+ func NewRemoteStreamBuffered(s keybase1.Stream, c *keybase1.StreamUiClient, sessionID int) *RemoteStreamBuffered

+ func (x *RemoteStreamBuffered) Close() error

+ func (x *RemoteStreamBuffered) Read(p []byte) (int, error)

+ func (x *RemoteStreamBuffered) Write(p []byte) (int, error)

+ type ReportingTimer interface

+ Report func(prefix string)

+ type ReportingTimerDummy struct

+ func (r ReportingTimerDummy) Report(prefix string)

+ type ReportingTimerReal struct

+ func NewReportingTimerReal(ctx Contextified) *ReportingTimerReal

+ func (r *ReportingTimerReal) Report(prefix string)

+ type Requester interface

+ type ResolutionError struct

+ Input string

+ Msg string

+ func (e ResolutionError) Error() string

+ func (e ResolutionError) ToStatus() keybase1.Status

+ type ResolveResult struct

+ func (res *ResolveResult) GetBody() *jsonw.Wrapper

+ func (res *ResolveResult) GetError() error

+ func (res *ResolveResult) GetNormalizedQueriedUsername() NormalizedUsername

+ func (res *ResolveResult) GetNormalizedUsername() NormalizedUsername

+ func (res *ResolveResult) GetUID() keybase1.UID

+ func (res *ResolveResult) GetUsername() string

+ type Resolver struct

+ func NewResolver(g *GlobalContext) *Resolver

+ func (r *Resolver) EnableCaching()

+ func (r *Resolver) Resolve(input string) ResolveResult

+ func (r *Resolver) ResolveFullExpression(input string) (res ResolveResult)

+ func (r *Resolver) ResolveFullExpressionNeedUsername(input string) (res ResolveResult)

+ func (r *Resolver) ResolveFullExpressionWithBody(input string) (res ResolveResult)

+ func (r *Resolver) ResolveWithBody(input string) ResolveResult

+ func (r *Resolver) Shutdown()

+ type RetryExhaustedError struct

+ func (e RetryExhaustedError) Error() string

+ type ReverseSigError struct

+ func (r ReverseSigError) Error() string

+ type RevokeChainLink struct

+ func ParseRevokeChainLink(b GenericChainLink) (ret *RevokeChainLink, err error)

+ func (r *RevokeChainLink) GetDevice() *Device

+ func (r *RevokeChainLink) IsRevocationIsh() bool

+ func (r *RevokeChainLink) ToDisplayString() string

+ func (r *RevokeChainLink) Type() string

+ type RevokedKey struct

+ Key GenericKey

+ RevokedAt *KeybaseTime

+ type RooterChecker struct

+ func (rc *RooterChecker) CheckData(h SigHint, dat string) ProofError

+ func (rc *RooterChecker) CheckHint(h SigHint) (err ProofError)

+ func (rc *RooterChecker) CheckStatus(h SigHint) (perr ProofError)

+ func (rc *RooterChecker) GetTorError() ProofError

+ func (rc *RooterChecker) ScreenNameCompare(s1, s2 string) bool

+ func (rc *RooterChecker) UnpackData(inp *jsonw.Wrapper) (string, ProofError)

+ type RooterServiceType struct

+ func (t RooterServiceType) AllStringKeys() []string

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

+ func (t RooterServiceType) CheckUsername(s string) (err error)

+ func (t RooterServiceType) DisplayName(un string) string

+ func (t RooterServiceType) GetPrompt() string

+ func (t RooterServiceType) GetProofType() string

+ func (t RooterServiceType) GetTypeName() string

+ func (t RooterServiceType) NormalizeUsername(s string) (string, error)

+ func (t RooterServiceType) PostInstructions(un string) *Markup

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

+ func (t RooterServiceType) ToChecker() Checker

+ func (t RooterServiceType) ToServiceJSON(un string) *jsonw.Wrapper

+ type RunGpg2Arg struct

+ Arguments []string

+ Stderr bool

+ Stdin bool

+ Stdout bool

+ type RunGpg2Res struct

+ Err error

+ Stderr io.ReadCloser

+ Stdin io.WriteCloser

+ Stdout io.ReadCloser

+ Wait func() error

+ type RunMode string

+ func StringToRunMode(s string) (RunMode, error)

+ type RunModeGetter func() RunMode

+ type S struct

+ Val string

+ func B64Arg(b []byte) S

+ func HexArg(b []byte) S

+ func (s S) String() string

+ type SKB struct

+ Priv SKBPriv

+ Pub []byte

+ Type AlgoType

+ func NewSKB(gc *GlobalContext) *SKB

+ func WriteLksSKBToKeyring(g *GlobalContext, k GenericKey, lks *LKSec, lctx LoginContext) (*SKB, error)

+ func (s *SKB) ArmoredEncode() (ret string, err error)

+ func (s *SKB) Dump()

+ func (s *SKB) GetPubKey() (key GenericKey, err error)

+ func (s *SKB) HumanDescription(owner *User) (string, error)

+ func (s *SKB) PromptAndUnlock(arg SecretKeyPromptArg, which string, secretStore SecretStore, me *User) (ret GenericKey, err error)

+ func (s *SKB) RawUnlockedKey() []byte

+ func (s *SKB) ReadKey() (g GenericKey, err error)

+ func (s *SKB) SetUID(uid keybase1.UID)

+ func (s *SKB) ToPacket() (ret *KeybasePacket, err error)

+ func (s *SKB) UnlockNoPrompt(lctx LoginContext, secretStore SecretStore) (GenericKey, error)

+ func (s *SKB) UnlockSecretKey(lctx LoginContext, passphrase string, tsec *triplesec.Cipher, ...) (key GenericKey, err error)

+ func (s *SKB) UnlockWithStoredSecret(lctx LoginContext, secretRetriever SecretRetriever) (ret GenericKey, err error)

+ func (s *SKB) VerboseDescription() (ret string, err error)

+ type SKBKeyringFile struct

+ Blocks []*SKB

+ func LoadSKBKeyring(un NormalizedUsername, g *GlobalContext) (*SKBKeyringFile, error)

+ func NewSKBKeyringFile(n string) *SKBKeyringFile

+ func (k *SKBKeyringFile) HasPGPKeys() bool

+ func (k *SKBKeyringFile) Index() (err error)

+ func (k *SKBKeyringFile) Load() (err error)

+ func (k *SKBKeyringFile) LoadAndIndex() error

+ func (k *SKBKeyringFile) Push(skb *SKB) error

+ func (k *SKBKeyringFile) PushAndSave(skb *SKB) error

+ func (k *SKBKeyringFile) Save() error

+ func (k SKBKeyringFile) FindSecretKey(kids []keybase1.KID) (ret *SKB)

+ func (k SKBKeyringFile) GetFilename() string

+ func (k SKBKeyringFile) LookupByFingerprint(fp PGPFingerprint) *SKB

+ func (k SKBKeyringFile) LookupByKid(kid keybase1.KID) *SKB

+ func (k SKBKeyringFile) SearchWithComputedKeyFamily(ckf *ComputedKeyFamily, ska SecretKeyArg) []*SKB

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

+ type SKBPriv struct

+ Data []byte

+ Encryption int

+ PassphraseGeneration int

+ type SafeWriter interface

+ GetFilename func() string

+ WriteTo func(io.Writer) (int64, error)

+ type SaltpackEncryptArg struct

+ Binary bool

+ HideRecipients bool

+ Receivers []NaclDHKeyPublic

+ Sender NaclDHKeyPair

+ Sink io.WriteCloser

+ Source io.Reader

+ type SaltpackUI interface

+ SaltpackPromptForDecrypt func(context.Context, keybase1.SaltpackPromptForDecryptArg) error

+ SaltpackVerifySuccess func(context.Context, keybase1.SaltpackVerifySuccessArg) error

+ type SecretKeyArg struct

+ ExactMatch bool

+ KeyQuery string

+ KeyType SecretKeyType

+ Me *User

+ type SecretKeyPromptArg struct

+ LoginContext LoginContext

+ Reason string

+ SecretUI SecretUI

+ Ska SecretKeyArg

+ UseCancelCache bool

+ type SecretKeyType int

+ const DeviceEncryptionKeyType

+ const DeviceSigningKeyType

+ const PGPKeyType

+ func (t SecretKeyType) String() string

+ type SecretRetriever interface

+ RetrieveSecret func() ([]byte, error)

+ type SecretStore interface

+ func NewSecretStore(g *GlobalContext, username NormalizedUsername) SecretStore

+ type SecretStoreAll interface

+ ClearSecret func(username NormalizedUsername) error

+ GetUsersWithStoredSecrets func() (ret []string, err error)

+ RetrieveSecret func(username NormalizedUsername) ([]byte, error)

+ StoreSecret func(username NormalizedUsername, secret []byte) error

+ func NewSecretStoreAll(g *GlobalContext) SecretStoreAll

+ func NewTestSecretStoreAll(c SecretStoreContext, g *GlobalContext) SecretStoreAll

+ type SecretStoreContext interface

+ GetAllUserNames func() (NormalizedUsername, []NormalizedUsername, error)

+ GetStoredSecretAccessGroup func() string

+ GetStoredSecretServiceName func() string

+ type SecretStoreError struct

+ Msg string

+ func (e SecretStoreError) Error() string

+ type SecretStoreImp struct

+ func (s SecretStoreImp) RetrieveSecret() ([]byte, error)

+ func (s SecretStoreImp) StoreSecret(secret []byte) error

+ type SecretStorer interface

+ StoreSecret func(secret []byte) error

+ type SecretSyncer struct

+ func NewSecretSyncer(g *GlobalContext) *SecretSyncer

+ func (ss *SecretSyncer) ActiveDevices(includeTypesSet DeviceTypeSet) (DeviceKeyMap, error)

+ func (ss *SecretSyncer) AllActiveKeys(ckf *ComputedKeyFamily) []*SKB

+ func (ss *SecretSyncer) Clear() error

+ func (ss *SecretSyncer) Devices() (DeviceKeyMap, error)

+ func (ss *SecretSyncer) DumpPrivateKeys()

+ func (ss *SecretSyncer) FindActiveKey(ckf *ComputedKeyFamily) (ret *SKB, err error)

+ func (ss *SecretSyncer) FindDevice(id keybase1.DeviceID) (DeviceKey, error)

+ func (ss *SecretSyncer) FindPrivateKey(kid string) (ServerPrivateKey, bool)

+ func (ss *SecretSyncer) HasActiveDevice(includeTypesSet DeviceTypeSet) (bool, error)

+ func (ss *SecretSyncer) HasDevices() bool

+ func (ss *SecretSyncer) IsDeviceNameTaken(name string, includeTypesSet DeviceTypeSet) bool

+ type SecretUI interface

+ GetPassphrase func(pinentry keybase1.GUIEntryArg, terminal *keybase1.SecretEntryArg) (keybase1.GetPassphraseRes, error)

+ type SelfNotFoundError struct

+ func (e SelfNotFoundError) Error() string

+ func (e SelfNotFoundError) ToStatus() keybase1.Status

+ type SelfSigChainLink struct

+ func ParseSelfSigChainLink(base GenericChainLink) (ret *SelfSigChainLink, err error)

+ func (s *SelfSigChainLink) CheckDataJSON() *jsonw.Wrapper

+ func (s *SelfSigChainLink) ComputeTrackDiff(tl *TrackLookup) TrackDiff

+ func (s *SelfSigChainLink) DisplayCheck(ui IdentifyUI, lcr LinkCheckResult)

+ func (s *SelfSigChainLink) GetDevice() *Device

+ func (s *SelfSigChainLink) GetHostname() string

+ func (s *SelfSigChainLink) GetPGPFullHash() string

+ func (s *SelfSigChainLink) GetProofType() keybase1.ProofType

+ func (s *SelfSigChainLink) GetProtocol() string

+ func (s *SelfSigChainLink) GetRemoteUsername() string

+ func (s *SelfSigChainLink) LastWriterWins() bool

+ func (s *SelfSigChainLink) ParseDevice() (err error)

+ func (s *SelfSigChainLink) ProofText() string

+ func (s *SelfSigChainLink) TableKey() string

+ func (s *SelfSigChainLink) ToDisplayString() string

+ func (s *SelfSigChainLink) ToIDString() string

+ func (s *SelfSigChainLink) ToKeyValuePair() (string, string)

+ func (s *SelfSigChainLink) ToTrackingStatement(keybase1.ProofState) (*jsonw.Wrapper, error)

+ func (s *SelfSigChainLink) Type() string

+ type SelfTrackError struct

+ func (e SelfTrackError) Error() string

+ type Seqno int64

+ type Server interface

+ type ServerChainError struct

+ func NewServerChainError(d string, a ...interface{}) ServerChainError

+ func (e ServerChainError) Error() string

+ type ServerPrivateKey struct

+ Bundle string

+ Ctime int

+ KeyAlgo int

+ KeyBits int

+ KeyType int

+ Kid string

+ Mtime int

+ func (k *ServerPrivateKey) FindActiveKey(ckf *ComputedKeyFamily) (ret *SKB, err error)

+ func (k ServerPrivateKey) ToSKB(gc *GlobalContext) (*SKB, error)

+ type ServerPrivateKeyMap map[string]ServerPrivateKey

+ type ServerPrivateKeys struct

+ Devices DeviceKeyMap

+ Mtime *int

+ PrivateKeys ServerPrivateKeyMap

+ Status APIStatus

+ Version int

+ type ServiceBlock struct

+ func ParseServiceBlock(jw *jsonw.Wrapper, pt keybase1.ProofType) (sb *ServiceBlock, err error)

+ func (sb ServiceBlock) GetProofState() keybase1.ProofState

+ func (sb ServiceBlock) GetProofType() keybase1.ProofType

+ func (sb ServiceBlock) IsSocial() bool

+ func (sb ServiceBlock) LastWriterWins() bool

+ func (sb ServiceBlock) ToIDString() string

+ func (sb ServiceBlock) ToKeyValuePair() (string, string)

+ type ServiceInfo struct

+ Label string

+ Pid int

+ Version string

+ func KeybaseServiceInfo(g *GlobalContext) ServiceInfo

+ func NewServiceInfo(version string, prerelease string, label string, pid int) ServiceInfo

+ func WaitForServiceInfoFile(g *GlobalContext, path string, label string, pid string, maxAttempts int, ...) (*ServiceInfo, error)

+ func (s ServiceInfo) WriteFile(path string) error

+ type ServiceType interface

+ AllStringKeys func() []string

+ CaseSensitiveUsername func() bool

+ CheckProofText func(text string, id keybase1.SigID, sig string) error

+ CheckUsername func(string) error

+ DisplayName func(username string) string

+ FormatProofText func(*PostProofRes) (string, error)

+ GetAPIArgKey func() string

+ GetPrompt func() string

+ GetProofType func() string

+ GetTypeName func() string

+ LastWriterWins func() bool

+ NormalizeUsername func(string) (string, error)

+ PostInstructions func(remotename string) *Markup

+ PreProofCheck func(username string) (*Markup, error)

+ PreProofWarning func(remotename string) *Markup

+ RecheckProofPosting func(tryNumber int, status keybase1.ProofStatus, username string) (warning *Markup, err error)

+ ToChecker func() Checker

+ ToServiceJSON func(remotename string) *jsonw.Wrapper

+ func GetServiceType(s string) ServiceType

+ type Session struct

+ func NewSessionThin(uid keybase1.UID, username NormalizedUsername, token string) *Session

+ func (s *Session) APIArgs() (token, csrf string)

+ func (s *Session) GetCsrf() string

+ func (s *Session) GetDictionary() *jsonw.Wrapper

+ func (s *Session) GetToken() string

+ func (s *Session) GetUID() keybase1.UID

+ func (s *Session) GetUsername() *NormalizedUsername

+ func (s *Session) HasSessionToken() bool

+ func (s *Session) Invalidate()

+ func (s *Session) IsLoggedIn() bool

+ func (s *Session) IsLoggedInAndProvisioned() bool

+ func (s *Session) IsRecent() bool

+ func (s *Session) IsValid() bool

+ func (s *Session) Load() error

+ func (s *Session) Logout() error

+ func (s *Session) SetCsrf(t string)

+ func (s *Session) SetDeviceProvisioned(devid keybase1.DeviceID) error

+ func (s *Session) SetLoggedIn(sessionID, csrfToken string, username NormalizedUsername, uid keybase1.UID, ...) error

+ func (s *Session) SetUsername(username NormalizedUsername)

+ type SessionReader interface

+ APIArgs func() (token, csrf string)

+ Invalidate func()

+ IsLoggedIn func() bool

+ type ShutdownHook func() error

+ type SibkeyAlreadyExistsError struct

+ func (e SibkeyAlreadyExistsError) Error() string

+ func (e SibkeyAlreadyExistsError) ToStatus() keybase1.Status

+ type SibkeyChainLink struct

+ func ParseSibkeyChainLink(b GenericChainLink) (ret *SibkeyChainLink, err error)

+ func (s *SibkeyChainLink) GetDelegatedKid() keybase1.KID

+ func (s *SibkeyChainLink) GetDevice() *Device

+ func (s *SibkeyChainLink) GetPGPFullHash() string

+ func (s *SibkeyChainLink) GetRole() KeyRole

+ func (s *SibkeyChainLink) ToDisplayString() string

+ func (s *SibkeyChainLink) Type() string

+ func (s *SibkeyChainLink) VerifyReverseSig(ckf ComputedKeyFamily) (err error)

+ type SigChain struct

+ func (sc *SigChain) Bump(mt MerkleTriple)

+ func (sc *SigChain) CheckFreshness(srv *MerkleTriple) (current bool, err error)

+ func (sc *SigChain) Dump(w io.Writer)

+ func (sc *SigChain) GetCurrentSubchain(eldest keybase1.KID) (links []*ChainLink, err error)

+ func (sc *SigChain) GetLinkFromSeqno(seqno int) *ChainLink

+ func (sc *SigChain) GetLinkFromSigID(id keybase1.SigID) *ChainLink

+ func (sc *SigChain) GetLinkFromSigIDQuery(query string) *ChainLink

+ func (sc *SigChain) LoadFromServer(t *MerkleTriple, selfUID keybase1.UID) (dirtyTail *MerkleTriple, err error)

+ func (sc *SigChain) LocalDelegate(kf *KeyFamily, key GenericKey, sigID keybase1.SigID, signingKid keybase1.KID, ...) (err error)

+ func (sc *SigChain) Store() (err error)

+ func (sc *SigChain) VerifiedChainLinks(fp PGPFingerprint) (ret []*ChainLink)

+ func (sc *SigChain) VerifyChain() (err error)

+ func (sc *SigChain) VerifySigsAndComputeKeys(eldest keybase1.KID, ckf *ComputedKeyFamily) (cached bool, err error)

+ func (sc SigChain) GetComputedKeyInfos() (cki *ComputedKeyInfos)

+ func (sc SigChain) GetCurrentTailTriple() (ret *MerkleTriple)

+ func (sc SigChain) GetFirstLink() *ChainLink

+ func (sc SigChain) GetFutureChainTail() (ret *MerkleTriple)

+ func (sc SigChain) GetLastKnownID() (ret LinkID)

+ func (sc SigChain) GetLastKnownSeqno() (ret Seqno)

+ func (sc SigChain) GetLastLink() *ChainLink

+ func (sc SigChain) GetLastLoadedID() (ret LinkID)

+ func (sc SigChain) GetLastLoadedSeqno() (ret Seqno)

+ func (sc SigChain) Len() int

+ type SigChainLoader struct

+ func (l *SigChainLoader) AccessPreload() bool

+ func (l *SigChainLoader) CheckFreshness() (current bool, err error)

+ func (l *SigChainLoader) GetKeyFamily() (err error)

+ func (l *SigChainLoader) GetMerkleTriple() (ret *MerkleTriple)

+ func (l *SigChainLoader) Load() (ret *SigChain, err error)

+ func (l *SigChainLoader) LoadFromServer() (err error)

+ func (l *SigChainLoader) LoadLastLinkIDFromStorage() (mt *MerkleTriple, err error)

+ func (l *SigChainLoader) LoadLinksFromStorage() (err error)

+ func (l *SigChainLoader) MakeSigChain() error

+ func (l *SigChainLoader) Store() (err error)

+ func (l *SigChainLoader) StoreTail() (err error)

+ func (l *SigChainLoader) VerifySigsAndComputeKeys() (err error)

+ type SigHint struct

+ func NewSigHint(jw *jsonw.Wrapper) (sh *SigHint, err error)

+ func (sh SigHint) Export() *keybase1.SigHint

+ func (sh SigHint) GetAPIURL() string

+ func (sh SigHint) GetCheckText() string

+ func (sh SigHint) GetHumanURL() string

+ func (sh SigHint) MarshalToJSON() *jsonw.Wrapper

+ type SigHints struct

+ func LoadAndRefreshSigHints(uid keybase1.UID, g *GlobalContext) (sh *SigHints, err error)

+ func LoadSigHints(uid keybase1.UID, g *GlobalContext) (sh *SigHints, err error)

+ func NewSigHints(jw *jsonw.Wrapper, uid keybase1.UID, dirty bool, g *GlobalContext) (sh *SigHints, err error)

+ func (sh *SigHints) PopulateWith(jw *jsonw.Wrapper) (err error)

+ func (sh *SigHints) Refresh() error

+ func (sh *SigHints) Store() (err error)

+ func (sh SigHints) Lookup(i keybase1.SigID) *SigHint

+ func (sh SigHints) MarshalToJSON() *jsonw.Wrapper

+ type SignatureStatus struct

+ Entity *openpgp.Entity

+ IsSigned bool

+ KeyID uint64

+ RecipientKeyIDs []uint64

+ SignatureError error

+ SignatureTime time.Time

+ Verified bool

+ func PGPDecrypt(g *GlobalContext, source io.Reader, sink io.Writer, kr openpgp.KeyRing) (*SignatureStatus, error)

+ func PGPDecryptWithBundles(g *GlobalContext, source io.Reader, sink io.Writer, keys []*PGPKeyBundle) (*SignatureStatus, error)

+ type SimpleTimer struct

+ func (s *SimpleTimer) GetTotal() int64

+ func (s *SimpleTimer) Reset()

+ func (s *SimpleTimer) Start()

+ func (s *SimpleTimer) Stop() int64

+ type SkipSecretPromptError struct

+ func (e SkipSecretPromptError) Error() string

+ func (e SkipSecretPromptError) ToStatus() (s keybase1.Status)

+ type SocialAssertion struct

+ func NormalizeSocialAssertion(s string) (SocialAssertion, bool)

+ func (s SocialAssertion) Service() string

+ func (s SocialAssertion) String() string

+ func (s SocialAssertion) Username() string

+ type SocialProofChainLink struct

+ func NewSocialProofChainLink(b GenericChainLink, s, u, proofText string) *SocialProofChainLink

+ func (s *SocialProofChainLink) CheckDataJSON() *jsonw.Wrapper

+ func (s *SocialProofChainLink) ComputeTrackDiff(tl *TrackLookup) TrackDiff

+ func (s *SocialProofChainLink) DisplayCheck(ui IdentifyUI, lcr LinkCheckResult)

+ func (s *SocialProofChainLink) GetHostname() string

+ func (s *SocialProofChainLink) GetProofType() keybase1.ProofType

+ func (s *SocialProofChainLink) GetProtocol() string

+ func (s *SocialProofChainLink) GetRemoteUsername() string

+ func (s *SocialProofChainLink) GetService() string

+ func (s *SocialProofChainLink) LastWriterWins() bool

+ func (s *SocialProofChainLink) ProofText() string

+ func (s *SocialProofChainLink) TableKey() string

+ func (s *SocialProofChainLink) ToDisplayString() string

+ func (s *SocialProofChainLink) ToIDString() string

+ func (s *SocialProofChainLink) ToKeyValuePair() (string, string)

+ func (s *SocialProofChainLink) ToTrackingStatement(state keybase1.ProofState) (*jsonw.Wrapper, error)

+ func (s *SocialProofChainLink) Type() string

+ type Socket interface

+ BindToSocket func() (net.Listener, error)

+ DialSocket func() (net.Conn, error)

+ GetFile func() string

+ func NewSocket(g *GlobalContext) (ret Socket, err error)

+ type SocketInfo struct

+ func (s SocketInfo) BindToSocket() (ret net.Listener, err error)

+ func (s SocketInfo) DialSocket() (ret net.Conn, err error)

+ func (s SocketInfo) GetFile() string

+ type SocketWrapper struct

+ type SpecialKeyRing struct

+ func NewSpecialKeyRing(v []keybase1.KID, g *GlobalContext) *SpecialKeyRing

+ func (sk *SpecialKeyRing) IsValidKID(kid keybase1.KID) bool

+ func (sk *SpecialKeyRing) Load(kid keybase1.KID) (GenericKey, error)

+ type StreamClassification struct

+ Armored bool

+ Format CryptoMessageFormat

+ Type CryptoMessageType

+ func ClassifyStream(r io.Reader) (sc StreamClassification, out io.Reader, err error)

+ type StreamExistsError struct

+ func (e StreamExistsError) ToStatus(s keybase1.Status)

+ func (s StreamExistsError) Error() string

+ type StreamNotFoundError struct

+ func (e StreamNotFoundError) ToStatus(s keybase1.Status)

+ func (s StreamNotFoundError) Error() string

+ type StreamPeeker struct

+ func NewStreamPeeker(r io.Reader) *StreamPeeker

+ func (p *StreamPeeker) Peek(buf []byte) (n int, err error)

+ func (p *StreamPeeker) Read(buf []byte) (n int, err error)

+ type StreamWrongKindError struct

+ func (e StreamWrongKindError) ToStatus(s keybase1.Status)

+ func (s StreamWrongKindError) Error() string

+ type StringWarning string

+ func (s StringWarning) Warn()

+ func (s StringWarning) Warning() string

+ type StubAPIEngine struct

+ func NewStubAPIEngine() *StubAPIEngine

+ func (e *StubAPIEngine) Get(arg APIArg) (res *ExternalAPIRes, err error)

+ func (e *StubAPIEngine) GetHTML(arg APIArg) (res *ExternalHTMLRes, err error)

+ func (e *StubAPIEngine) GetText(arg APIArg) (*ExternalTextRes, error)

+ type SubkeyChainLink struct

+ func ParseSubkeyChainLink(b GenericChainLink) (ret *SubkeyChainLink, err error)

+ func (s *SubkeyChainLink) GetDelegatedKid() keybase1.KID

+ func (s *SubkeyChainLink) GetParentKid() keybase1.KID

+ func (s *SubkeyChainLink) GetRole() KeyRole

+ func (s *SubkeyChainLink) ToDisplayString() string

+ func (s *SubkeyChainLink) Type() string

+ type Syncer interface

+ type TerminalUI interface

+ ErrorWriter func() io.Writer

+ Output func(string) error

+ OutputDesc func(OutputDescriptor, string) error

+ OutputWriter func() io.Writer

+ Printf func(fmt string, args ...interface{}) (int, error)

+ Prompt func(PromptDescriptor, string) (string, error)

+ PromptForConfirmation func(prompt string) error

+ PromptPassword func(PromptDescriptor, string) (string, error)

+ PromptYesNo func(PromptDescriptor, string, PromptDefault) (bool, error)

+ type TestCancelSecretUI struct

+ CallCount int

+ func (t *TestCancelSecretUI) GetPassphrase(_ keybase1.GUIEntryArg, _ *keybase1.SecretEntryArg) (keybase1.GetPassphraseRes, error)

+ type TestConfig struct

+ func (c *TestConfig) CleanTest()

+ func (c *TestConfig) GetConfigFileName() string

+ func (c *TestConfig) InitTest(t *testing.T, initConfig string)

+ type TestContext struct

+ G *GlobalContext

+ PrevGlobal *GlobalContext

+ T testing.TB

+ Tp TestParameters

+ func SetupTest(tb testing.TB, name string) (tc TestContext)

+ func (tc *TestContext) Cleanup()

+ func (tc *TestContext) GenerateGPGKeyring(ids ...string) error

+ func (tc *TestContext) MakePGPKey(id string) (*PGPKeyBundle, error)

+ func (tc *TestContext) ResetLoginState()

+ func (tc *TestContext) SetRuntimeDir(s string)

+ func (tc TestContext) ClearAllStoredSecrets() error

+ func (tc TestContext) Clone() (ret TestContext)

+ func (tc TestContext) MoveGpgKeyringTo(dst TestContext) error

+ type TestLoginCancelUI struct

+ func (t *TestLoginCancelUI) GetEmailOrUsername(_ context.Context, _ int) (string, error)

+ type TestLoginUI struct

+ CalledGetEmailOrUsername int

+ RevokeBackup bool

+ Username string

+ func (t *TestLoginUI) DisplayPaperKeyPhrase(_ context.Context, arg keybase1.DisplayPaperKeyPhraseArg) error

+ func (t *TestLoginUI) DisplayPrimaryPaperKey(_ context.Context, arg keybase1.DisplayPrimaryPaperKeyArg) error

+ func (t *TestLoginUI) GetEmailOrUsername(_ context.Context, _ int) (string, error)

+ func (t *TestLoginUI) PromptRevokePaperKeys(_ context.Context, arg keybase1.PromptRevokePaperKeysArg) (bool, error)

+ type TestOutput struct

+ func NewTestOutput(e string, t *testing.T, c *bool) TestOutput

+ func (to TestOutput) Write(p []byte) (n int, err error)

+ type TestParameters struct

+ ConfigFilename string

+ Debug bool

+ Devel bool

+ DevelName string

+ GPG string

+ GPGHome string

+ GPGOptions []string

+ Home string

+ RuntimeDir string

+ func (tp TestParameters) GetDebug() (bool, bool)

+ type TestSecretStoreAll struct — js/wasm, linux/amd64, windows/amd64

+ func (t TestSecretStoreAll) ClearSecret(accountName NormalizedUsername) error

+ func (t TestSecretStoreAll) GetAllUserNames() (NormalizedUsername, []NormalizedUsername, error)

+ func (t TestSecretStoreAll) GetUsersWithStoredSecrets() (ret []string, err error)

+ func (t TestSecretStoreAll) RetrieveSecret(accountName NormalizedUsername) (ret []byte, err error)

+ func (t TestSecretStoreAll) StoreSecret(accountName NormalizedUsername, secret []byte) error

+ type TestSecretUI struct

+ CalledGetPassphrase bool

+ Passphrase string

+ StoreSecret bool

+ func (t *TestSecretUI) GetPassphrase(p keybase1.GUIEntryArg, terminal *keybase1.SecretEntryArg) (keybase1.GetPassphraseRes, error)

+ type TimeoutError struct

+ func (e TimeoutError) Error() string

+ func (e TimeoutError) ToStatus() keybase1.Status

+ type TimerSelector int

+ const TimerAPI

+ const TimerNone

+ const TimerRPC

+ const TimerXAPI

+ type TimerSet struct

+ func NewTimerSet(g *GlobalContext) *TimerSet

+ func (s TimerSet) Start(sel TimerSelector) ReportingTimer

+ type Token struct

+ Typ int

+ func NewToken(typ int) *Token

+ func (t Token) Eq(t2 Token) bool

+ type TooManyKeysError struct

+ func (e TooManyKeysError) Error() string

+ type TorMode int

+ const TorLeaky

+ const TorNone

+ const TorStrict

+ func StringToTorMode(s string) (ret TorMode, err error)

+ func (m TorMode) Enabled() bool

+ func (m TorMode) UseCSRF() bool

+ func (m TorMode) UseCookies() bool

+ func (m TorMode) UseHeaders() bool

+ func (m TorMode) UseSession() bool

+ type TorSessionRequiredError struct

+ func (t TorSessionRequiredError) Error() string

+ type TrackCache struct

+ func NewTrackCache() *TrackCache

+ func (c *TrackCache) Delete(key keybase1.TrackToken) error

+ func (c *TrackCache) Get(key keybase1.TrackToken) (*IdentifyOutcome, error)

+ func (c *TrackCache) Insert(outcome *IdentifyOutcome) (keybase1.TrackToken, error)

+ func (c *TrackCache) Shutdown()

+ type TrackChainLink struct

+ func LocalTmpTrackChainLinkFor(tracker, trackee keybase1.UID, g *GlobalContext) (ret *TrackChainLink, err error)

+ func LocalTrackChainLinkFor(tracker, trackee keybase1.UID, g *GlobalContext) (ret *TrackChainLink, err error)

+ func ParseTrackChainLink(b GenericChainLink) (ret *TrackChainLink, err error)

+ func (l *TrackChainLink) DoOwnNewLinkFromServerNotifications(g *GlobalContext)

+ func (l *TrackChainLink) GetEldestKID() (kid keybase1.KID, err error)

+ func (l *TrackChainLink) GetTmpExpireTime() (ret time.Time)

+ func (l *TrackChainLink) GetTrackedKeys() ([]TrackedKey, error)

+ func (l *TrackChainLink) GetTrackedUID() (keybase1.UID, error)

+ func (l *TrackChainLink) GetTrackedUsername() (string, error)

+ func (l *TrackChainLink) IsRevoked() bool

+ func (l *TrackChainLink) RemoteKeyProofs() *jsonw.Wrapper

+ func (l *TrackChainLink) ToDisplayString() string

+ func (l *TrackChainLink) ToServiceBlocks() (ret []*ServiceBlock)

+ func (l *TrackChainLink) Type() string

+ func (l TrackChainLink) IsRemote() bool

+ type TrackDiff interface

+ BreaksTracking func() bool

+ GetTrackDiffType func() keybase1.TrackDiffType

+ IsSameAsTracked func() bool

+ ToDisplayMarkup func() *Markup

+ ToDisplayString func() string

+ type TrackDiffClash struct

+ func (t TrackDiffClash) BreaksTracking() bool

+ func (t TrackDiffClash) GetTrackDiffType() keybase1.TrackDiffType

+ func (t TrackDiffClash) IsSameAsTracked() bool

+ func (t TrackDiffClash) ToDisplayMarkup() *Markup

+ func (t TrackDiffClash) ToDisplayString() string

+ type TrackDiffNew struct

+ func (t TrackDiffNew) BreaksTracking() bool

+ func (t TrackDiffNew) GetTrackDiffType() keybase1.TrackDiffType

+ func (t TrackDiffNew) IsSameAsTracked() bool

+ func (t TrackDiffNew) ToDisplayMarkup() *Markup

+ func (t TrackDiffNew) ToDisplayString() string

+ type TrackDiffNewEldest struct

+ func (t TrackDiffNewEldest) BreaksTracking() bool

+ func (t TrackDiffNewEldest) GetTrackDiffType() keybase1.TrackDiffType

+ func (t TrackDiffNewEldest) IsSameAsTracked() bool

+ func (t TrackDiffNewEldest) ToDisplayMarkup() *Markup

+ func (t TrackDiffNewEldest) ToDisplayString() string

+ type TrackDiffNone struct

+ func (t TrackDiffNone) BreaksTracking() bool

+ func (t TrackDiffNone) GetTrackDiffType() keybase1.TrackDiffType

+ func (t TrackDiffNone) IsSameAsTracked() bool

+ func (t TrackDiffNone) ToDisplayMarkup() *Markup

+ func (t TrackDiffNone) ToDisplayString() string

+ type TrackDiffNoneViaTemporary struct

+ func (t TrackDiffNoneViaTemporary) BreaksTracking() bool

+ func (t TrackDiffNoneViaTemporary) GetTrackDiffType() keybase1.TrackDiffType

+ func (t TrackDiffNoneViaTemporary) IsSameAsTracked() bool

+ func (t TrackDiffNoneViaTemporary) ToDisplayMarkup() *Markup

+ func (t TrackDiffNoneViaTemporary) ToDisplayString() string

+ type TrackDiffRemoteChanged struct

+ func (t TrackDiffRemoteChanged) BreaksTracking() bool

+ func (t TrackDiffRemoteChanged) GetTrackDiffType() keybase1.TrackDiffType

+ func (t TrackDiffRemoteChanged) IsSameAsTracked() bool

+ func (t TrackDiffRemoteChanged) ToDisplayMarkup() *Markup

+ func (t TrackDiffRemoteChanged) ToDisplayString() string

+ type TrackDiffRemoteFail struct

+ func (t TrackDiffRemoteFail) BreaksTracking() bool

+ func (t TrackDiffRemoteFail) GetTrackDiffType() keybase1.TrackDiffType

+ func (t TrackDiffRemoteFail) IsSameAsTracked() bool

+ func (t TrackDiffRemoteFail) ToDisplayMarkup() *Markup

+ func (t TrackDiffRemoteFail) ToDisplayString() string

+ type TrackDiffRemoteWorking struct

+ func (t TrackDiffRemoteWorking) BreaksTracking() bool

+ func (t TrackDiffRemoteWorking) GetTrackDiffType() keybase1.TrackDiffType

+ func (t TrackDiffRemoteWorking) IsSameAsTracked() bool

+ func (t TrackDiffRemoteWorking) ToDisplayMarkup() *Markup

+ func (t TrackDiffRemoteWorking) ToDisplayString() string

+ type TrackDiffRevoked struct

+ func (t TrackDiffRevoked) BreaksTracking() bool

+ func (t TrackDiffRevoked) GetTrackDiffType() keybase1.TrackDiffType

+ func (t TrackDiffRevoked) IsSameAsTracked() bool

+ func (t TrackDiffRevoked) ToDisplayMarkup() *Markup

+ func (t TrackDiffRevoked) ToDisplayString() string

+ type TrackDiffUpgraded struct

+ func (t TrackDiffUpgraded) BreaksTracking() bool

+ func (t TrackDiffUpgraded) GetCurr() string

+ func (t TrackDiffUpgraded) GetPrev() string

+ func (t TrackDiffUpgraded) GetTrackDiffType() keybase1.TrackDiffType

+ func (t TrackDiffUpgraded) IsSameAsTracked() bool

+ func (t TrackDiffUpgraded) ToDisplayMarkup() *Markup

+ func (t TrackDiffUpgraded) ToDisplayString() string

+ type TrackIDComponent interface

+ GetProofState func() keybase1.ProofState

+ GetProofType func() keybase1.ProofType

+ LastWriterWins func() bool

+ ToIDString func() string

+ ToKeyValuePair func() (string, string)

+ type TrackInstructions struct

+ Local bool

+ Remote bool

+ type TrackLookup struct

+ func NewTrackLookup(link *TrackChainLink) *TrackLookup

+ func (l *TrackLookup) GetCTime() time.Time

+ func (l TrackLookup) GetEldestKID() keybase1.KID

+ func (l TrackLookup) GetProofState(id string) keybase1.ProofState

+ func (l TrackLookup) GetTmpExpireTime() (ret time.Time)

+ func (l TrackLookup) GetTrackedKeys() []TrackedKey

+ func (l TrackLookup) GetTrackerSeqno() Seqno

+ func (l TrackLookup) IsRemote() bool

+ func (l TrackLookup) ToSummary() TrackSummary

+ type TrackSet struct

+ func NewTrackSet() *TrackSet

+ func (ts TrackSet) Add(t TrackIDComponent)

+ func (ts TrackSet) GetProofState(id string) keybase1.ProofState

+ func (ts TrackSet) HasMember(t TrackIDComponent) bool

+ func (ts TrackSet) LenEq(b TrackSet) bool

+ func (ts TrackSet) Subtract(b TrackSet) (out []TrackIDComponent)

+ type TrackStaleError struct

+ FirstTrack bool

+ func (e TrackStaleError) Error() string

+ type TrackSummary struct

+ func ImportTrackSummary(s *keybase1.TrackSummary) *TrackSummary

+ func (s TrackSummary) Export(username string) (ret keybase1.TrackSummary)

+ func (s TrackSummary) GetCTime() time.Time

+ func (s TrackSummary) IsRemote() bool

+ func (s TrackSummary) Username() string

+ type TrackedKey struct

+ Fingerprint *PGPFingerprint

+ KID keybase1.KID

+ type Tracker keybase1.Tracker

+ func (t Tracker) Eq(t2 Tracker) bool

+ func (t Tracker) Export() keybase1.Tracker

+ func (t Tracker) GetUID() keybase1.UID

+ type TrackerSyncer struct

+ func NewTrackerSyncer(uid keybase1.UID, g *GlobalContext) *TrackerSyncer

+ func (t *TrackerSyncer) Trackers() *Trackers

+ type Trackers struct

+ Trackers []Tracker

+ Version int

+ type TrackingBrokeError struct

+ func (e TrackingBrokeError) Error() string

+ func (e TrackingBrokeError) ToStatus() keybase1.Status

+ type TwitterChecker struct

+ func (rc *TwitterChecker) CheckHint(h SigHint) ProofError

+ func (rc *TwitterChecker) CheckStatus(h SigHint) ProofError

+ func (rc *TwitterChecker) GetTorError() ProofError

+ func (rc *TwitterChecker) ScreenNameCompare(s1, s2 string) bool

+ type TwitterServiceType struct

+ func (t TwitterServiceType) AllStringKeys() []string

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

+ func (t TwitterServiceType) CheckUsername(s string) (err error)

+ func (t TwitterServiceType) DisplayName(un string) string

+ func (t TwitterServiceType) GetPrompt() string

+ func (t TwitterServiceType) GetProofType() string

+ func (t TwitterServiceType) GetTypeName() string

+ func (t TwitterServiceType) NormalizeUsername(s string) (string, error)

+ func (t TwitterServiceType) PostInstructions(un string) *Markup

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

+ func (t TwitterServiceType) ToChecker() Checker

+ func (t TwitterServiceType) ToServiceJSON(un string) *jsonw.Wrapper

+ type TypedChainLink interface

+ DoOwnNewLinkFromServerNotifications func(g *GlobalContext)

+ GetArmoredSig func() string

+ GetCTime func() time.Time

+ GetDelegatedKid func() keybase1.KID

+ GetDevice func() *Device

+ GetETime func() time.Time

+ GetKID func() keybase1.KID

+ GetMerkleSeqno func() int

+ GetPGPFingerprint func() *PGPFingerprint

+ GetPGPFullHash func() string

+ GetParentKid func() keybase1.KID

+ GetRevocations func() []keybase1.SigID

+ GetRevokeKids func() []keybase1.KID

+ GetRole func() KeyRole

+ GetSeqno func() Seqno

+ GetSigID func() keybase1.SigID

+ GetUID func() keybase1.UID

+ GetUsername func() string

+ IsInCurrentFamily func(u *User) bool

+ IsRevocationIsh func() bool

+ IsRevoked func() bool

+ ToDebugString func() string

+ ToDisplayString func() string

+ Type func() string

+ VerifyReverseSig func(ckf ComputedKeyFamily) error

+ type U struct

+ Val uint64

+ func (u U) String() string

+ type UHex struct

+ Val uint64

+ func (h UHex) String() string

+ type UI interface

+ Configure func() error

+ GetDumbOutputUI func() DumbOutputUI

+ GetGPGUI func() GPGUI

+ GetIdentifyTrackUI func() IdentifyUI

+ GetIdentifyUI func() IdentifyUI

+ GetLogUI func() LogUI

+ GetLoginUI func() LoginUI

+ GetPgpUI func() PgpUI

+ GetProveUI func() ProveUI

+ GetProvisionUI func(role KexRole) ProvisionUI

+ GetSecretUI func() SecretUI

+ GetTerminalUI func() TerminalUI

+ GetUpdateUI func() UpdateUI

+ Shutdown func() error

+ type UIConsumer interface

+ Name func() string

+ RequiredUIs func() []UIKind

+ SubConsumers func() []UIConsumer

+ type UIDMismatchError struct

+ Msg string

+ func (u UIDMismatchError) Error() string

+ type UIDelegationUnavailableError struct

+ func (e UIDelegationUnavailableError) Error() string

+ func (e UIDelegationUnavailableError) ToStatus() keybase1.Status

+ type UIKind int

+ const GPGUIKind

+ const IdentifyUIKind

+ const LogUIKind

+ const LoginUIKind

+ const PgpUIKind

+ const ProveUIKind

+ const ProvisionUIKind

+ const SaltpackUIKind

+ const SecretUIKind

+ const UpdateUIKind

+ func (u UIKind) String() string

+ type UIRouter interface

+ GetIdentifyUI func() (IdentifyUI, error)

+ GetSecretUI func(sessionID int) (SecretUI, error)

+ GetUpdateUI func() (UpdateUI, error)

+ SetUI func(ConnectionID, UIKind)

+ Shutdown func()

+ type UnexpectedKeyError struct

+ func (e UnexpectedKeyError) Error() string

+ type UnknownKeyTypeError struct

+ func (e UnknownKeyTypeError) Error() string

+ type UnknownSpecialKIDError struct

+ func (u UnknownSpecialKIDError) Error() string

+ type UnknownStreamError struct

+ func (e UnknownStreamError) Error() string

+ type UnmarshalError struct

+ T string

+ func (u UnmarshalError) Error() string

+ type UnmetAssertionError struct

+ Remote bool

+ User string

+ func (e UnmetAssertionError) Error() string

+ type UntrackChainLink struct

+ func ParseUntrackChainLink(b GenericChainLink) (ret *UntrackChainLink, err error)

+ func (u *UntrackChainLink) DoOwnNewLinkFromServerNotifications(g *GlobalContext)

+ func (u *UntrackChainLink) IsRevocationIsh() bool

+ func (u *UntrackChainLink) ToDisplayString() string

+ func (u *UntrackChainLink) Type() string

+ type UntrackError struct

+ func NewUntrackError(d string, a ...interface{}) UntrackError

+ func (e UntrackError) Error() string

+ type UpdateUI interface

+ type Usage struct

+ API bool

+ Config bool

+ GpgKeyring bool

+ KbKeyring bool

+ Socket bool

+ func (u Usage) UseKeyring() bool

+ type User struct

+ func LoadMe(arg LoadUserArg) (*User, error)

+ func LoadMeByUID(g *GlobalContext, uid keybase1.UID) (*User, error)

+ func LoadUser(arg LoadUserArg) (ret *User, err error)

+ func NewUser(g *GlobalContext, o *jsonw.Wrapper) (*User, error)

+ func NewUserFromLocalStorage(g *GlobalContext, o *jsonw.Wrapper) (*User, error)

+ func NewUserFromServer(g *GlobalContext, o *jsonw.Wrapper) (*User, error)

+ func NewUserThin(name string, uid keybase1.UID) *User

+ func (u *User) AllSyncedSecretKeys(lctx LoginContext) (keys []*SKB, err error)

+ func (u *User) AuthenticationProof(key GenericKey, session string, ei int) (ret *jsonw.Wrapper, err error)

+ func (u *User) BaseProofSet() *ProofSet

+ func (u *User) CheckBasicsFreshness(server int64) (current bool, err error)

+ func (u *User) CryptocurrencySig(key GenericKey, address string, sigToRevoke keybase1.SigID) (*jsonw.Wrapper, error)

+ func (u *User) DeviceNames() ([]string, error)

+ func (u *User) Equal(other *User) bool

+ func (u *User) Export() *keybase1.User

+ func (u *User) ExportToUserPlusKeys(idTime keybase1.Time) keybase1.UserPlusKeys

+ func (u *User) ExportToVersionVector(idTime keybase1.Time) keybase1.UserVersionVector

+ func (u *User) FilterActivePGPKeys(sibkey bool, query string) []*PGPKeyBundle

+ func (u *User) GetActivePGPFingerprints(sibkey bool) (ret []PGPFingerprint)

+ func (u *User) GetActivePGPKIDs(sibkey bool) (ret []keybase1.KID)

+ func (u *User) GetActivePGPKeys(sibkey bool) (ret []*PGPKeyBundle)

+ func (u *User) GetComputedKeyFamily() (ret *ComputedKeyFamily)

+ func (u *User) GetComputedKeyInfos() *ComputedKeyInfos

+ func (u *User) GetDevice(id keybase1.DeviceID) (*Device, error)

+ func (u *User) GetDeviceSibkey() (GenericKey, error)

+ func (u *User) GetDeviceSubkey() (subkey GenericKey, err error)

+ func (u *User) GetEldestKID() (ret keybase1.KID)

+ func (u *User) GetIDVersion() (int64, error)

+ func (u *User) GetKeyFamily() *KeyFamily

+ func (u *User) GetName() string

+ func (u *User) GetNormalizedName() NormalizedUsername

+ func (u *User) GetPublicChainTail() *MerkleTriple

+ func (u *User) GetSigChainLastKnownSeqno() Seqno

+ func (u *User) GetSigHintsVersion() int

+ func (u *User) GetSigIDFromSeqno(seqno int) keybase1.SigID

+ func (u *User) GetSyncedSecretKey() (ret *SKB, err error)

+ func (u *User) GetUID() keybase1.UID

+ func (u *User) HasActiveKey() (ret bool)

+ func (u *User) HasCurrentDeviceInCurrentInstall() bool

+ func (u *User) HasDeviceInCurrentInstall(did keybase1.DeviceID) bool

+ func (u *User) HasEncryptionSubkey() bool

+ func (u *User) IDTable() *IdentityTable

+ func (u *User) IsCachedIdentifyFresh(upk *keybase1.UserPlusKeys) bool

+ func (u *User) IsSigIDActive(sigID keybase1.SigID) (bool, error)

+ func (u *User) LinkFromSigID(sigID keybase1.SigID) *ChainLink

+ func (u *User) LoadSigChains(allKeys bool, f *MerkleUserLeaf, self bool) (err error)

+ func (u *User) MakeIDTable() error

+ func (u *User) RevokeKeysProof(key GenericKey, kidsToRevoke []keybase1.KID, deviceToDisable keybase1.DeviceID) (*jsonw.Wrapper, error)

+ func (u *User) RevokeSigsProof(key GenericKey, sigIDsToRevoke []keybase1.SigID) (*jsonw.Wrapper, error)

+ func (u *User) ServiceProof(signingKey GenericKey, typ ServiceType, remotename string) (ret *jsonw.Wrapper, err error)

+ func (u *User) SigChainBump(linkID LinkID, sigID keybase1.SigID)

+ func (u *User) SigChainBumpMT(mt MerkleTriple)

+ func (u *User) SigChainDump(w io.Writer)

+ func (u *User) SigIDSearch(query string) (keybase1.SigID, error)

+ func (u *User) SigningKeyPub() (GenericKey, error)

+ func (u *User) Store() error

+ func (u *User) StoreSigChain() error

+ func (u *User) StoreTopLevel() error

+ func (u *User) SyncSecrets() error

+ func (u *User) SyncedSecretKey(lctx LoginContext) (ret *SKB, err error)

+ func (u *User) TmpTrackChainLinkFor(username string, uid keybase1.UID) (tcl *TrackChainLink, err error)

+ func (u *User) ToTrackingStatement(w *jsonw.Wrapper, outcome *IdentifyOutcome) (err error)

+ func (u *User) ToTrackingStatementBasics(errp *error) *jsonw.Wrapper

+ func (u *User) ToTrackingStatementKey(errp *error) *jsonw.Wrapper

+ func (u *User) ToTrackingStatementPGPKeys(errp *error) *jsonw.Wrapper

+ func (u *User) ToTrackingStatementSeqTail() *jsonw.Wrapper

+ func (u *User) ToUntrackingStatement(w *jsonw.Wrapper) (err error)

+ func (u *User) ToUntrackingStatementBasics() *jsonw.Wrapper

+ func (u *User) TrackChainLinkFor(username string, uid keybase1.UID) (*TrackChainLink, error)

+ func (u *User) TrackStatementJSON(them *User, outcome *IdentifyOutcome) (string, error)

+ func (u *User) TrackingProofFor(signingKey GenericKey, u2 *User, outcome *IdentifyOutcome) (ret *jsonw.Wrapper, err error)

+ func (u *User) UntrackingProofFor(signingKey GenericKey, u2 *User) (ret *jsonw.Wrapper, err error)

+ func (u *User) UpdatePassphraseProof(key GenericKey, pwh string, ppGen PassphraseGeneration) (*jsonw.Wrapper, error)

+ func (u *User) VerifySelfSig() error

+ func (u *User) VerifySelfSigByKey() (ret bool)

+ type UserBasic interface

+ GetName func() string

+ GetUID func() keybase1.UID

+ type UserConfig struct

+ Device *string

+ ID string

+ Name NormalizedUsername

+ Salt string

+ func ImportUserConfigFromJSONWrapper(jw *jsonw.Wrapper) (ret *UserConfig, err error)

+ func NewUserConfig(id keybase1.UID, name NormalizedUsername, salt []byte, dev keybase1.DeviceID) *UserConfig

+ func (u *UserConfig) Import() (err error)

+ func (u *UserConfig) SetDevice(d keybase1.DeviceID)

+ func (u UserConfig) GetDeviceID() keybase1.DeviceID

+ func (u UserConfig) GetSalt() []byte

+ func (u UserConfig) GetUID() keybase1.UID

+ func (u UserConfig) GetUsername() NormalizedUsername

+ type UserConfigWrapper struct

+ type UserInfo struct

+ UID keybase1.UID

+ Username string

+ type UserNotFoundError struct

+ Msg string

+ UID keybase1.UID

+ func (u UserNotFoundError) Error() string

+ type VDebugLevel int

+ const VLog0

+ const VLog1

+ const VLog2

+ const VLog3

+ type VDebugLog struct

+ func NewVDebugLog(l logger.Logger) *VDebugLog

+ func (v *VDebugLog) Configure(s string)

+ func (v *VDebugLog) Log(lev VDebugLevel, fs string, args ...interface{})

+ type VerificationError struct

+ func (v VerificationError) Error() string

+ type VerificationPath struct

+ func (vp *VerificationPath) VerifyUser() (user *MerkleUserLeaf, err error)

+ func (vp *VerificationPath) VerifyUsername() (username string, err error)

+ type WaitForItError struct

+ func (e WaitForItError) Error() string

+ type Warning interface

+ Warn func()

+ Warning func() string

+ func ErrorToWarning(e error) Warning

+ func Warningf(format string, a ...interface{}) Warning

+ type Warnings struct

+ func ImportWarnings(v []string) Warnings

+ func (w *Warnings) Push(e Warning)

+ func (w Warnings) IsEmpty() bool

+ func (w Warnings) Warn()

+ func (w Warnings) Warnings() []Warning

+ type WebChecker struct

+ func (rc *WebChecker) CheckHint(h SigHint) ProofError

+ func (rc *WebChecker) CheckStatus(h SigHint) ProofError

+ func (rc *WebChecker) GetTorError() ProofError

+ type WebProofChainLink struct

+ func NewWebProofChainLink(b GenericChainLink, p, h, proofText string) *WebProofChainLink

+ func (w *WebProofChainLink) CheckDataJSON() *jsonw.Wrapper

+ func (w *WebProofChainLink) ComputeTrackDiff(tl *TrackLookup) (res TrackDiff)

+ func (w *WebProofChainLink) DisplayCheck(ui IdentifyUI, lcr LinkCheckResult)

+ func (w *WebProofChainLink) GetHostname() string

+ func (w *WebProofChainLink) GetProofType() keybase1.ProofType

+ func (w *WebProofChainLink) GetProtocol() string

+ func (w *WebProofChainLink) GetRemoteUsername() string

+ func (w *WebProofChainLink) LastWriterWins() bool

+ func (w *WebProofChainLink) ProofText() string

+ func (w *WebProofChainLink) TableKey() string

+ func (w *WebProofChainLink) ToDisplayString() string

+ func (w *WebProofChainLink) ToIDString() string

+ func (w *WebProofChainLink) ToKeyValuePair() (string, string)

+ func (w *WebProofChainLink) ToTrackingStatement(state keybase1.ProofState) (*jsonw.Wrapper, error)

+ func (w *WebProofChainLink) Type() string

+ type WebServiceType struct

+ func (t WebServiceType) AllStringKeys() []string

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

+ func (t WebServiceType) CheckUsername(s string) error

+ func (t WebServiceType) DisplayName(un string) string

+ func (t WebServiceType) GetAPIArgKey() string

+ func (t WebServiceType) GetPrompt() string

+ func (t WebServiceType) GetProofType() string

+ func (t WebServiceType) GetTypeName() string

+ func (t WebServiceType) LastWriterWins() bool

+ func (t WebServiceType) MarkupFilenames(un string, mkp *Markup)

+ func (t WebServiceType) NormalizeUsername(s string) (ret string, err error)

+ func (t WebServiceType) PostInstructions(un string) *Markup

+ func (t WebServiceType) PreProofWarning(un string) *Markup

+ func (t WebServiceType) PrimaryStringKeys() []string

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

+ func (t WebServiceType) ToChecker() Checker

+ func (t WebServiceType) ToServiceJSON(un string) *jsonw.Wrapper

+ type WebUnreachableError struct

+ func (h WebUnreachableError) Error() string

+ type Win32 struct

+ func (w Win32) CacheDir() string

+ func (w Win32) ConfigDir() string

+ func (w Win32) DataDir() string

+ func (w Win32) Home(emptyOk bool) string

+ func (w Win32) LogDir() string

+ func (w Win32) Normalize(s string) string

+ func (w Win32) RuntimeDir() string

+ func (w Win32) ServiceSpawnDir() (string, error)

+ func (w Win32) Split(s string) []string

+ type WrongCryptoFormatError struct

+ Operation string

+ Received CryptoMessageFormat

+ Wanted CryptoMessageFormat

+ func (e WrongCryptoFormatError) Error() string

+ func (e WrongCryptoFormatError) ToStatus() keybase1.Status

+ type WrongKeyError struct

+ func (e WrongKeyError) Error() string

+ type WrongKidError struct

+ func (w WrongKidError) Error() string

+ type WrongSigError struct

+ func (e WrongSigError) Error() string

+ type XdgPosix struct

+ func (x XdgPosix) CacheDir() string

+ func (x XdgPosix) ConfigDir() string

+ func (x XdgPosix) DataDir() string

+ func (x XdgPosix) Home(emptyOk bool) string

+ func (x XdgPosix) LogDir() string

+ func (x XdgPosix) Normalize(s string) string

+ func (x XdgPosix) RuntimeDir() string

+ func (x XdgPosix) ServiceSpawnDir() (ret string, err error)

v1.0.14-1

Feb 25, 2016

v1.0.14-0

Feb 25, 2016

v1.0.13-0

Feb 18, 2016

v1.0.12-0

Feb 15, 2016

v1.0.11-0

Feb 10, 2016

v1.0.10-0

Feb 5, 2016

v1.0.9-1

Jan 21, 2016

v1.0.9-0

Jan 21, 2016

v1.0.8-0-windows

Jan 13, 2016

v1.0.8-0

Jan 13, 2016

v1.0.7-0-windows

Dec 24, 2015

v1.0.7-0

Dec 23, 2015

v1.0.6-1-windows

Dec 13, 2015

v1.0.6-0-windows

Dec 10, 2015

v1.0.6-1

Dec 11, 2015

v1.0.6-0

Dec 10, 2015

v1.0.5-7-windows

Dec 8, 2015

v1.0.5-6-windows

Dec 7, 2015

v1.0.5-6

Dec 3, 2015

v1.0.5-5

Dec 2, 2015

v1.0.5-4

Dec 2, 2015

v1.0.5-3

Dec 2, 2015

v1.0.5-2

Dec 2, 2015

v1.0.5-1

Dec 1, 2015

v1.0.5-0

Dec 1, 2015

v1.0.4-4

Dec 1, 2015

v1.0.4-0

Nov 30, 2015

v1.0.3-0

Nov 24, 2015

v1.0.2-0

Nov 24, 2015

v1.0.1-0

Nov 23, 2015

v1.0.0-beta.8

Aug 12, 2015

v1.0.0-beta.1

Jun 23, 2015

v1.0.0-29g

Oct 7, 2015

v1.0.0-29f

Oct 7, 2015

v1.0.0-29e

Oct 7, 2015

v1.0.0-29d

Oct 7, 2015

v1.0.0-29c

Oct 7, 2015

v1.0.0-29b

Oct 7, 2015

v1.0.0-29a

Oct 7, 2015

v1.0.0-47

Nov 12, 2015

v1.0.0-46

Nov 10, 2015

v1.0.0-45

Nov 6, 2015

v1.0.0-44

Nov 6, 2015

v1.0.0-43

Nov 3, 2015

v1.0.0-42

Nov 3, 2015

v1.0.0-41

Oct 28, 2015

v1.0.0-40

Oct 27, 2015

v1.0.0-39

Oct 27, 2015

v1.0.0-38

Oct 23, 2015

v1.0.0-37

Oct 23, 2015

v1.0.0-36

Oct 22, 2015

v1.0.0-35

Oct 22, 2015

v1.0.0-34

Oct 14, 2015

v1.0.0-33

Oct 14, 2015

v1.0.0-32

Oct 9, 2015

v1.0.0-31

Oct 9, 2015

v1.0.0-30

Oct 7, 2015

v1.0.0-29

Oct 7, 2015

v1.0.0-28

Oct 6, 2015

v1.0.0-27

Oct 2, 2015

v1.0.0-26

Sep 30, 2015

v1.0.0-25

Sep 25, 2015

v1.0.0-24

Sep 23, 2015

v1.0.0-23

Sep 22, 2015

v1.0.0-22

Sep 22, 2015

v1.0.0-21

Sep 16, 2015

v1.0.0-20

Sep 14, 2015

v1.0.0-19

Sep 14, 2015

v1.0.0-18

Sep 11, 2015

v1.0.0-17

Sep 11, 2015

v1.0.0-16

Sep 11, 2015

v1.0.0-15

Sep 10, 2015

v1.0.0-14

Sep 10, 2015

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL