libkb

package
v0.0.0-...-66acf6f Latest Latest
Warning

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

Go to latest
Published: Jan 18, 2024 License: BSD-3-Clause Imports: 108 Imported by: 0

Documentation

Overview

Copyright 2015 Keybase, Inc. All rights reserved. Use of this source code is governed by the included BSD license.

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

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

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

Index

Constants

View Source
const (
	NONE = iota
	OR
	AND
	LPAREN
	RPAREN
	URL
	EOF
	ERROR
)
View Source
const (
	DevelServerURI      = "http://localhost:3000"
	StagingServerURI    = "https://stage0.keybase.io"
	ProductionServerURI = "https://api-1.core.keybaseapi.com"
	TorServerURI        = "http://keybase5wmilwokqirssclfnsqrjdsi7jdir5wy7y7iu3tanwmtp6oid.onion"
)
View Source
const (
	DevelSiteURI      = DevelServerURI
	StagingSiteURI    = StagingServerURI
	ProductionSiteURI = "https://keybase.io"
)
View Source
const (
	DevelGregorServerURI      = "fmprpc://localhost:9911"
	StagingGregorServerURI    = "fmprpc+tls://gregord.dev.keybase.io:4443"
	ProductionGregorServerURI = "fmprpc+tls://chat-0.core.keybaseapi.com:443"
)
View Source
const (
	DevelMpackAPIServerURI      = "fmprpc://localhost:9914"
	StagingMpackAPIServerURI    = "fmprpc+tls://api.dev.keybase.io:4443"
	ProductionMpackAPIServerURI = "fmprpc+tls://mpack-0.core.keybaseapi.com:443"
)
View Source
const (
	ConfigFile           = "config.json"
	SessionFile          = "session.json"
	UpdaterConfigFile    = "updater.json"
	GUIConfigFile        = "gui_config.json"
	DeviceCloneStateFile = "device_clone.json"
	DBFile               = "keybase.leveldb"
	ChatDBFile           = "keybase.chat.leveldb"
	SocketFile           = "keybased.sock"
	PIDFile              = "keybased.pid"

	SecretKeyringTemplate = "secretkeys.%u.mpack"

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

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

	// How old the merkle root must be to ask for a refresh.
	// Measures time since the root was fetched, not time since published.
	MerkleStoreShouldRefresh time.Duration = 1 * time.Hour
	// An older merkle root than this is too old to use. All identifies will fail.
	MerkleStoreRequireRefresh time.Duration = 24 * time.Hour

	Identify2CacheLongTimeout   = 6 * time.Hour
	Identify2CacheBrokenTimeout = 1 * time.Hour
	Identify2CacheShortTimeout  = 1 * time.Minute

	// How long we'll go without rerequesting hints/merkle seqno. This is used in both
	// CachedUPAKLoader and FullSelfCacher. Note that this timeout has to exceed the
	// dtime value for Gregor IBMs that deal with user and key family changed notifications.
	// Because if the client is offline for more than that amount of time, then our cache
	// could be stale.
	CachedUserTimeout = 10 * time.Minute

	LinkCacheSize     = 4000
	LinkCacheCleanDur = 1 * time.Minute

	UPAKCacheSize                     = 2000
	UIDMapFullNameCacheSize           = 100000
	ImplicitTeamConflictInfoCacheSize = 10000
	ImplicitTeamCacheSize             = 10000

	PayloadCacheSize = 1000

	SigShortIDBytes  = 27
	LocalTrackMaxAge = 48 * time.Hour

	CriticalClockSkewLimit = time.Hour

	ChatBoxerMerkleFreshness    = 10 * time.Minute
	TeamMerkleFreshnessForAdmin = 30 * time.Second
	EphemeralKeyMerkleFreshness = 30 * time.Second

	// By default, only 48 files can be opened.
	LevelDBNumFiles            = 48
	LevelDBWriteBufferMB       = 12
	LevelDBWriteBufferMBMobile = 8

	HomeCacheTimeout       = (time.Hour - time.Minute)
	HomePeopleCacheTimeout = 10 * time.Minute
)
View Source
const (
	OneYearInSeconds = 24 * 60 * 60 * 365

	SigExpireIn            = OneYearInSeconds * 16 // 16 years
	NaclEdDSAExpireIn      = OneYearInSeconds * 16 // 16 years
	NaclDHExpireIn         = OneYearInSeconds * 16 // 16 years
	NaclPerUserKeyExpireIn = OneYearInSeconds * 16 // 16 years
	KeyExpireIn            = OneYearInSeconds * 16 // 16 years
	SubkeyExpireIn         = OneYearInSeconds * 16 // 16 years
	AuthExpireIn           = OneYearInSeconds      // 1 year

	ProvisioningKeyMemoryTimeout = time.Hour
)
View Source
const (
	SCOk                                        = int(keybase1.StatusCode_SCOk)
	SCInputError                                = int(keybase1.StatusCode_SCInputError)
	SCAssertionParseError                       = int(keybase1.StatusCode_SCAssertionParseError)
	SCLoginRequired                             = int(keybase1.StatusCode_SCLoginRequired)
	SCBadSession                                = int(keybase1.StatusCode_SCBadSession)
	SCNoSession                                 = int(keybase1.StatusCode_SCNoSession)
	SCBadLoginUserNotFound                      = int(keybase1.StatusCode_SCBadLoginUserNotFound)
	SCBadLoginPassword                          = int(keybase1.StatusCode_SCBadLoginPassword)
	SCNotFound                                  = int(keybase1.StatusCode_SCNotFound)
	SCDeleted                                   = int(keybase1.StatusCode_SCDeleted)
	SCThrottleControl                           = int(keybase1.StatusCode_SCThrottleControl)
	SCGeneric                                   = int(keybase1.StatusCode_SCGeneric)
	SCAlreadyLoggedIn                           = int(keybase1.StatusCode_SCAlreadyLoggedIn)
	SCCanceled                                  = int(keybase1.StatusCode_SCCanceled)
	SCInputCanceled                             = int(keybase1.StatusCode_SCInputCanceled)
	SCBadUsername                               = int(keybase1.StatusCode_SCBadUsername)
	SCOffline                                   = int(keybase1.StatusCode_SCOffline)
	SCExists                                    = int(keybase1.StatusCode_SCExists)
	SCInvalidAddress                            = int(keybase1.StatusCode_SCInvalidAddress)
	SCReloginRequired                           = int(keybase1.StatusCode_SCReloginRequired)
	SCResolutionFailed                          = int(keybase1.StatusCode_SCResolutionFailed)
	SCProfileNotPublic                          = int(keybase1.StatusCode_SCProfileNotPublic)
	SCRateLimit                                 = int(keybase1.StatusCode_SCRateLimit)
	SCBadSignupUsernameTaken                    = int(keybase1.StatusCode_SCBadSignupUsernameTaken)
	SCBadSignupUsernameReserved                 = int(keybase1.StatusCode_SCBadSignupUsernameReserved)
	SCBadInvitationCode                         = int(keybase1.StatusCode_SCBadInvitationCode)
	SCBadSignupTeamName                         = int(keybase1.StatusCode_SCBadSignupTeamName)
	SCFeatureFlag                               = int(keybase1.StatusCode_SCFeatureFlag)
	SCEmailTaken                                = int(keybase1.StatusCode_SCEmailTaken)
	SCEmailAlreadyAdded                         = int(keybase1.StatusCode_SCEmailAlreadyAdded)
	SCEmailLimitExceeded                        = int(keybase1.StatusCode_SCEmailLimitExceeded)
	SCEmailCannotDeletePrimary                  = int(keybase1.StatusCode_SCEmailCannotDeletePrimary)
	SCEmailUnknown                              = int(keybase1.StatusCode_SCEmailUnknown)
	SCNoUpdate                                  = int(keybase1.StatusCode_SCNoUpdate)
	SCMissingResult                             = int(keybase1.StatusCode_SCMissingResult)
	SCKeyNotFound                               = int(keybase1.StatusCode_SCKeyNotFound)
	SCKeyCorrupted                              = int(keybase1.StatusCode_SCKeyCorrupted)
	SCKeyInUse                                  = int(keybase1.StatusCode_SCKeyInUse)
	SCKeyBadGen                                 = int(keybase1.StatusCode_SCKeyBadGen)
	SCKeyNoSecret                               = int(keybase1.StatusCode_SCKeyNoSecret)
	SCKeyBadUIDs                                = int(keybase1.StatusCode_SCKeyBadUIDs)
	SCKeyNoActive                               = int(keybase1.StatusCode_SCKeyNoActive)
	SCKeyNoSig                                  = int(keybase1.StatusCode_SCKeyNoSig)
	SCKeyBadSig                                 = int(keybase1.StatusCode_SCKeyBadSig)
	SCKeyBadEldest                              = int(keybase1.StatusCode_SCKeyBadEldest)
	SCKeyNoEldest                               = int(keybase1.StatusCode_SCKeyNoEldest)
	SCKeyDuplicateUpdate                        = int(keybase1.StatusCode_SCKeyDuplicateUpdate)
	SCKeySyncedPGPNotFound                      = int(keybase1.StatusCode_SCKeySyncedPGPNotFound)
	SCKeyNoMatchingGPG                          = int(keybase1.StatusCode_SCKeyNoMatchingGPG)
	SCKeyRevoked                                = int(keybase1.StatusCode_SCKeyRevoked)
	SCSigCannotVerify                           = int(keybase1.StatusCode_SCSigCannotVerify)
	SCSibkeyAlreadyExists                       = int(keybase1.StatusCode_SCSibkeyAlreadyExists)
	SCSigCreationDisallowed                     = int(keybase1.StatusCode_SCSigCreationDisallowed)
	SCDecryptionKeyNotFound                     = int(keybase1.StatusCode_SCDecryptionKeyNotFound)
	SCVerificationKeyNotFound                   = int(keybase1.StatusCode_SCVerificationKeyNotFound)
	SCBadTrackSession                           = int(keybase1.StatusCode_SCBadTrackSession)
	SCDeviceBadName                             = int(keybase1.StatusCode_SCDeviceBadName)
	SCDeviceBadStatus                           = int(keybase1.StatusCode_SCDeviceBadStatus)
	SCDeviceNameInUse                           = int(keybase1.StatusCode_SCDeviceNameInUse)
	SCDeviceNotFound                            = int(keybase1.StatusCode_SCDeviceNotFound)
	SCDeviceMismatch                            = int(keybase1.StatusCode_SCDeviceMismatch)
	SCDeviceRequired                            = int(keybase1.StatusCode_SCDeviceRequired)
	SCDevicePrevProvisioned                     = int(keybase1.StatusCode_SCDevicePrevProvisioned)
	SCDeviceProvisionViaDevice                  = int(keybase1.StatusCode_SCDeviceProvisionViaDevice)
	SCDeviceNoProvision                         = int(keybase1.StatusCode_SCDeviceNoProvision)
	SCDeviceProvisionOffline                    = int(keybase1.StatusCode_SCDeviceProvisionOffline)
	SCStreamExists                              = int(keybase1.StatusCode_SCStreamExists)
	SCStreamNotFound                            = int(keybase1.StatusCode_SCStreamNotFound)
	SCStreamWrongKind                           = int(keybase1.StatusCode_SCStreamWrongKind)
	SCStreamUnknown                             = int(keybase1.StatusCode_SCStreamUnknown)
	SCStreamEOF                                 = int(keybase1.StatusCode_SCStreamEOF)
	SCGenericAPIError                           = int(keybase1.StatusCode_SCGenericAPIError)
	SCAPINetworkError                           = int(keybase1.StatusCode_SCAPINetworkError)
	SCTimeout                                   = int(keybase1.StatusCode_SCTimeout)
	SCProofError                                = int(keybase1.StatusCode_SCProofError)
	SCIdentificationExpired                     = int(keybase1.StatusCode_SCIdentificationExpired)
	SCSelfNotFound                              = int(keybase1.StatusCode_SCSelfNotFound)
	SCBadKexPhrase                              = int(keybase1.StatusCode_SCBadKexPhrase)
	SCNoUI                                      = int(keybase1.StatusCode_SCNoUI)
	SCNoUIDelegation                            = int(keybase1.StatusCode_SCNoUIDelegation)
	SCIdentifyFailed                            = int(keybase1.StatusCode_SCIdentifyFailed)
	SCTrackingBroke                             = int(keybase1.StatusCode_SCTrackingBroke)
	SCKeyNoPGPEncryption                        = int(keybase1.StatusCode_SCKeyNoPGPEncryption)
	SCKeyNoNaClEncryption                       = int(keybase1.StatusCode_SCKeyNoNaClEncryption)
	SCWrongCryptoFormat                         = int(keybase1.StatusCode_SCWrongCryptoFormat)
	SCGPGUnavailable                            = int(keybase1.StatusCode_SCGPGUnavailable)
	SCDecryptionError                           = int(keybase1.StatusCode_SCDecryptionError)
	SCWrongCryptoMsgType                        = int(keybase1.StatusCode_SCWrongCryptoMsgType)
	SCChatInternal                              = int(keybase1.StatusCode_SCChatInternal)
	SCChatRateLimit                             = int(keybase1.StatusCode_SCChatRateLimit)
	SCChatConvExists                            = int(keybase1.StatusCode_SCChatConvExists)
	SCChatUnknownTLFID                          = int(keybase1.StatusCode_SCChatUnknownTLFID)
	SCChatNotInConv                             = int(keybase1.StatusCode_SCChatNotInConv)
	SCChatNotInTeam                             = int(keybase1.StatusCode_SCChatNotInTeam)
	SCChatBadMsg                                = int(keybase1.StatusCode_SCChatBadMsg)
	SCChatBroadcast                             = int(keybase1.StatusCode_SCChatBroadcast)
	SCChatAlreadySuperseded                     = int(keybase1.StatusCode_SCChatAlreadySuperseded)
	SCChatAlreadyDeleted                        = int(keybase1.StatusCode_SCChatAlreadyDeleted)
	SCChatTLFFinalized                          = int(keybase1.StatusCode_SCChatTLFFinalized)
	SCChatCollision                             = int(keybase1.StatusCode_SCChatCollision)
	SCChatStalePreviousState                    = int(keybase1.StatusCode_SCChatStalePreviousState)
	SCChatEphemeralRetentionPolicyViolatedError = int(keybase1.StatusCode_SCChatEphemeralRetentionPolicyViolatedError)
	SCMerkleClientError                         = int(keybase1.StatusCode_SCMerkleClientError)
	SCMerkleUpdateRoot                          = int(keybase1.StatusCode_SCMerkleUpdateRoot)
	SCBadEmail                                  = int(keybase1.StatusCode_SCBadEmail)
	SCIdentifySummaryError                      = int(keybase1.StatusCode_SCIdentifySummaryError)
	SCNeedSelfRekey                             = int(keybase1.StatusCode_SCNeedSelfRekey)
	SCNeedOtherRekey                            = int(keybase1.StatusCode_SCNeedOtherRekey)
	SCChatMessageCollision                      = int(keybase1.StatusCode_SCChatMessageCollision)
	SCChatDuplicateMessage                      = int(keybase1.StatusCode_SCChatDuplicateMessage)
	SCChatClientError                           = int(keybase1.StatusCode_SCChatClientError)
	SCChatUsersAlreadyInConversationError       = int(keybase1.StatusCode_SCChatUsersAlreadyInConversationError)
	SCChatBadConversationError                  = int(keybase1.StatusCode_SCChatBadConversationError)
	SCAccountReset                              = int(keybase1.StatusCode_SCAccountReset)
	SCIdentifiesFailed                          = int(keybase1.StatusCode_SCIdentifiesFailed)
	SCTeamReadError                             = int(keybase1.StatusCode_SCTeamReadError)
	SCTeamWritePermDenied                       = int(keybase1.StatusCode_SCTeamWritePermDenied)
	SCNoOp                                      = int(keybase1.StatusCode_SCNoOp)
	SCTeamBadGeneration                         = int(keybase1.StatusCode_SCTeamBadGeneration)
	SCTeamNotFound                              = int(keybase1.StatusCode_SCTeamNotFound)
	SCTeamTarDuplicate                          = int(keybase1.StatusCode_SCTeamTarDuplicate)
	SCTeamTarNotFound                           = int(keybase1.StatusCode_SCTeamTarNotFound)
	SCTeamMemberExists                          = int(keybase1.StatusCode_SCTeamMemberExists)
	SCTeamFTLOutdated                           = int(keybase1.StatusCode_SCTeamFTLOutdated)
	SCTeamContactSettingsBlock                  = int(keybase1.StatusCode_SCTeamContactSettingsBlock)
	SCLoginStateTimeout                         = int(keybase1.StatusCode_SCLoginStateTimeout)
	SCRevokeCurrentDevice                       = int(keybase1.StatusCode_SCRevokeCurrentDevice)
	SCRevokeLastDevice                          = int(keybase1.StatusCode_SCRevokeLastDevice)
	SCRevokeLastDevicePGP                       = int(keybase1.StatusCode_SCRevokeLastDevicePGP)
	SCTeamKeyMaskNotFound                       = int(keybase1.StatusCode_SCTeamKeyMaskNotFound)
	SCGitInternal                               = int(keybase1.StatusCode_SCGitInternal)
	SCGitRepoAlreadyExists                      = int(keybase1.StatusCode_SCGitRepoAlreadyExists)
	SCGitInvalidRepoName                        = int(keybase1.StatusCode_SCGitInvalidRepoName)
	SCGitCannotDelete                           = int(keybase1.StatusCode_SCGitCannotDelete)
	SCGitRepoDoesntExist                        = int(keybase1.StatusCode_SCGitRepoDoesntExist)
	SCTeamBanned                                = int(keybase1.StatusCode_SCTeamBanned)
	SCTeamInvalidBan                            = int(keybase1.StatusCode_SCTeamInvalidBan)
	SCNoSpaceOnDevice                           = int(keybase1.StatusCode_SCNoSpaceOnDevice)
	SCTeamInviteBadToken                        = int(keybase1.StatusCode_SCTeamInviteBadToken)
	SCTeamInviteTokenReused                     = int(keybase1.StatusCode_SCTeamInviteTokenReused)
	SCTeamBadMembership                         = int(keybase1.StatusCode_SCTeamBadMembership)
	SCTeamProvisionalCanKey                     = int(keybase1.StatusCode_SCTeamProvisionalCanKey)
	SCTeamProvisionalCannotKey                  = int(keybase1.StatusCode_SCTeamProvisionalCannotKey)
	SCBadSignupUsernameDeleted                  = int(keybase1.StatusCode_SCBadSignupUsernameDeleted)
	SCEphemeralPairwiseMACsMissingUIDs          = int(keybase1.StatusCode_SCEphemeralPairwiseMACsMissingUIDs)
	SCEphemeralDeviceAfterEK                    = int(keybase1.StatusCode_SCEphemeralDeviceAfterEK)
	SCEphemeralMemberAfterEK                    = int(keybase1.StatusCode_SCEphemeralMemberAfterEK)
	SCEphemeralDeviceStale                      = int(keybase1.StatusCode_SCEphemeralDeviceStale)
	SCEphemeralUserStale                        = int(keybase1.StatusCode_SCEphemeralUserStale)
	SCStellarNeedDisclaimer                     = int(keybase1.StatusCode_SCStellarNeedDisclaimer)
	SCStellarDeviceNotMobile                    = int(keybase1.StatusCode_SCStellarDeviceNotMobile)
	SCStellarMobileOnlyPurgatory                = int(keybase1.StatusCode_SCStellarMobileOnlyPurgatory)
	SCStellarIncompatibleVersion                = int(keybase1.StatusCode_SCStellarIncompatibleVersion)
	SCStellarMissingAccount                     = int(keybase1.StatusCode_SCStellarMissingAccount)
	SCPhoneNumberUnknown                        = int(keybase1.StatusCode_SCPhoneNumberUnknown)
	SCPhoneNumberAlreadyVerified                = int(keybase1.StatusCode_SCPhoneNumberAlreadyVerified)
	SCPhoneNumberVerificationCodeExpired        = int(keybase1.StatusCode_SCPhoneNumberVerificationCodeExpired)
	SCPhoneNumberWrongVerificationCode          = int(keybase1.StatusCode_SCPhoneNumberWrongVerificationCode)
	SCPhoneNumberLimitExceeded                  = int(keybase1.StatusCode_SCPhoneNumberLimitExceeded)
	SCNoPaperKeys                               = int(keybase1.StatusCode_SCNoPaperKeys)
	SCTeambotKeyGenerationExists                = int(keybase1.StatusCode_SCTeambotKeyGenerationExists)
	SCTeamStorageWrongRevision                  = int(keybase1.StatusCode_SCTeamStorageWrongRevision)
	SCTeamStorageBadGeneration                  = int(keybase1.StatusCode_SCTeamStorageBadGeneration)
	SCTeamStorageNotFound                       = int(keybase1.StatusCode_SCTeamStorageNotFound)
)

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

View Source
const (
	MerkleTreeNode = 1
	MerkleTreeLeaf = 2
)
View Source
const (
	LinkTypeAuthentication    LinkType = "auth"
	LinkTypeCryptocurrency    LinkType = "cryptocurrency"
	LinkTypeRevoke            LinkType = "revoke"
	LinkTypeTrack             LinkType = "track"
	LinkTypeUntrack           LinkType = "untrack"
	LinkTypeUpdatePassphrase  LinkType = "update_passphrase_hash"
	LinkTypeUpdateSettings    LinkType = "update_settings"
	LinkTypeWebServiceBinding LinkType = "web_service_binding"
	LinkTypePerUserKey        LinkType = "per_user_key"
	LinkTypeWalletStellar     LinkType = "wallet.stellar"
	LinkTypeWotVouch          LinkType = "wot.vouch"
	LinkTypeWotReact          LinkType = "wot.react"

	// team links
	LinkTypeTeamRoot         LinkType = "team.root"
	LinkTypeNewSubteam       LinkType = "team.new_subteam"
	LinkTypeChangeMembership LinkType = "team.change_membership"
	LinkTypeRotateKey        LinkType = "team.rotate_key"
	LinkTypeLeave            LinkType = "team.leave"
	LinkTypeSubteamHead      LinkType = "team.subteam_head"
	LinkTypeRenameSubteam    LinkType = "team.rename_subteam"
	LinkTypeInvite           LinkType = "team.invite"
	LinkTypeRenameUpPointer  LinkType = "team.rename_up_pointer"
	LinkTypeDeleteRoot       LinkType = "team.delete_root"
	LinkTypeDeleteSubteam    LinkType = "team.delete_subteam"
	LinkTypeDeleteUpPointer  LinkType = "team.delete_up_pointer"
	LinkTypeKBFSSettings     LinkType = "team.kbfs"
	LinkTypeSettings         LinkType = "team.settings"
	LinkTypeTeamBotSettings  LinkType = "team.bot_settings"

	DelegationTypeEldest    DelegationType = "eldest"
	DelegationTypePGPUpdate DelegationType = "pgp_update"
	DelegationTypeSibkey    DelegationType = "sibkey"
	DelegationTypeSubkey    DelegationType = "subkey"
)
View Source
const (
	SigTypeNone           = 0
	SigTypeSelfSig        = 1
	SigTypeRemoteProof    = 2
	SigTypeTrack          = 3
	SigTypeUntrack        = 4
	SigTypeRevoke         = 5
	SigTypeCryptocurrency = 6
	SigTypeAnnouncement   = 7
)
View Source
const (
	DeviceStatusNone    = 0
	DeviceStatusActive  = 1
	DeviceStatusDefunct = 2
)
View Source
const (
	HTTPDefaultTimeout        = 60 * time.Second
	HTTPDefaultScraperTimeout = 10 * time.Second
	HTTPPollMaximum           = 5 * time.Second
	HTTPFastTimeout           = 5 * time.Second
)
View Source
const (
	HTTPRetryInitialTimeout = 1 * time.Second
	HTTPRetryMutliplier     = 1.5
	HTTPRetryCount          = 6
)

The following constants apply to APIArg parameters for critical idempotent API calls

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

key_revocation_types

View Source
const (
	Kex2PhraseEntropy  = 88
	Kex2PhraseEntropy2 = 99 // we've upped the entropy to 99 bits after the 2018 NCC Audit
	Kex2ScryptCost     = 1 << 17
	Kex2ScryptLiteCost = 1 << 10
	Kex2ScryptR        = 8
	Kex2ScryptP        = 1
	Kex2ScryptKeylen   = 32
)
View Source
const (
	PaperKeyScryptCost    = 32768
	PaperKeyScryptR       = 8
	PaperKeyScryptP       = 1
	PaperKeyScryptKeylen  = 128
	PaperKeySecretEntropy = 117
	PaperKeyIDBits        = 22
	PaperKeyVersionBits   = 4
	PaperKeyVersion       = 0
	PaperKeyWordCountMin  = 13 // this should never change to a value greater than 13
	PaperKeyNoPrefixLen   = 11 // word count min - 2
)

PaperKeyWordCountMin of 13 is based on the current state: entropy: 143 (PaperKeySecretEntropy [117] + PaperKeyIDBits [22] + PaperKeyVersionBits [4]) len(secwords): 2048

View Source
const (
	IdentifySourceKBFS = "kbfs"
	TestInvitationCode = "202020202020202020202020"
)
View Source
const (
	ServiceLogFileName  = "keybase.service.log"
	EKLogFileName       = "keybase.ek.log"
	PerfLogFileName     = "keybase.perf.log"
	KBFSLogFileName     = kbconst.KBFSLogFileName
	KBFSPerfLogFileName = "keybase.kbfs.perf.log"
	GitLogFileName      = "keybase.git.log"
	GitPerfLogFileName  = "keybase.git.perf.log"
	UpdaterLogFileName  = "keybase.updater.log"
	GUILogFileName      = "Keybase.app.log"
	// StartLogFileName is where services can log to (on startup) before they handle their own logging
	StartLogFileName = "keybase.start.log"
)
View Source
const (
	NotificationDismissPGPPrefix = "pgp_secret_store"
	NotificationDismissPGPValue  = "dismissed"
)
View Source
const (
	TeamDHDerivationString               = "Keybase-Derived-Team-NaCl-DH-1"
	TeamEdDSADerivationString            = "Keybase-Derived-Team-NaCl-EdDSA-1"
	TeamKBFSDerivationString             = "Keybase-Derived-Team-NaCl-KBFS-1"
	TeamChatDerivationString             = "Keybase-Derived-Team-NaCl-Chat-1"
	TeamSaltpackDerivationString         = "Keybase-Derived-Team-NaCl-Saltpack-1"
	TeamPrevKeySecretBoxDerivationString = "Keybase-Derived-Team-NaCl-SecretBox-1"
	TeamGitMetadataDerivationString      = "Keybase-Derived-Team-NaCl-GitMetadata-1"
	TeamSeitanTokenDerivationString      = "Keybase-Derived-Team-NaCl-SeitanInviteToken-1"
	TeamStellarRelayDerivationString     = "Keybase-Derived-Team-NaCl-StellarRelay-1"
	TeamKVStoreDerivationString          = "Keybase-Derived-Team-NaCl-KVStore-1"
	TeamKeySeedCheckDerivationString     = "Keybase-Derived-Team-Seedcheck-1"
)
View Source
const (
	MaxStellarPaymentNoteLength       = 500
	MaxStellarPaymentBoxedNoteLength  = 2000
	MaxStellarPaymentPublicNoteLength = 28
)
View Source
const (
	AutoresetEventStart  = 0
	AutoresetEventVerify = 1
	AutoresetEventCancel = 2
	AutoresetEventNotify = 3
	AutoresetEventReady  = 4
	AutoresetEventReset  = 5
)

Also defined in lib_public/public_constants.iced

View Source
const (
	ExternalURLsBaseKey         = "external_urls"
	ExternalURLsStellarPartners = "stellar_partners"
)
View Source
const (
	DBUser              = 0x00
	DBSig               = 0x0f
	DBTeamChain         = 0x10
	DBUserPlusAllKeysV1 = 0x19

	DBIncomingSharePreference        = 0xa4
	DBChatUserEmojis                 = 0xa5
	DBChatInboxIndex                 = 0xa6
	DBChatInboxConvs                 = 0xa7
	DBChatParticipants               = 0xa8
	DBOpenTeams                      = 0xa9
	DBNetworkInstrumentation         = 0xaa
	DBFeaturedBots                   = 0xab
	DBChatEphemeralTracker           = 0xac
	DBLoginTimes                     = 0xad
	DBChatJourney                    = 0xae
	DBTeamRoleMap                    = 0xaf
	DBMisc                           = 0xb0
	DBTeamMerkleCheck                = 0xb1
	DBUidToServiceMap                = 0xb2
	DBChatPinIgnore                  = 0xb3
	DBTeambotKey                     = 0xb4
	DBTeambotKeyWrongKID             = 0xb5
	DBChatBotCommands                = 0xb6
	DBSavedContacts                  = 0xb7
	DBChatLocation                   = 0xb8
	DBHiddenChainStorage             = 0xb9
	DBContactResolution              = 0xba
	DBBoxAuditorPermanent            = 0xbb
	DBBoxAuditor                     = 0xbc
	DBUserPlusKeysVersionedUnstubbed = 0xbd
	DBOfflineRPC                     = 0xbe
	DBChatCollapses                  = 0xbf
	DBSupportsHiddenFlagStorage      = 0xc0
	DBMerkleAudit                    = 0xca
	DBUnfurler                       = 0xcb
	DBStellarDisclaimer              = 0xcc
	DBFTLStorage                     = 0xcd
	DBTeamAuditor                    = 0xce
	DBAttachmentUploader             = 0xcf
	DBLegacyHasRandomPW              = 0xd0
	DBDiskLRUEntries                 = 0xda
	DBDiskLRUIndex                   = 0xdb
	DBImplicitTeamConflictInfo       = 0xdc
	DBUidToFullName                  = 0xdd
	DBUidToUsername                  = 0xde
	DBUserPlusKeysVersioned          = 0xdf
	DBLink                           = 0xe0
	DBLocalTrack                     = 0xe1
	DBPGPKey                         = 0xe3
	DBSigHints                       = 0xe4
	DBProofCheck                     = 0xe5
	DBUserSecretKeys                 = 0xe6
	DBSigChainTailPublic             = 0xe7
	DBSigChainTailSemiprivate        = 0xe8
	DBSigChainTailEncrypted          = 0xe9
	DBChatActive                     = 0xea
	DBUserEKBox                      = 0xeb
	DBTeamEKBox                      = 0xec
	DBChatIndex                      = 0xed
	DBChatGiphy                      = 0xee
	DBChatReacji                     = 0xef
	DBMerkleRoot                     = 0xf0
	DBTrackers                       = 0xf1
	DBGregor                         = 0xf2
	DBUnverifiedTrackersFollowers    = 0xf3
	DBUnverifiedTrackersFollowing    = 0xf4
	DBNotificationDismiss            = 0xf5
	DBChatBlockIndex                 = 0xf6
	DBChatBlocks                     = 0xf7
	DBChatOutbox                     = 0xf8
	DBChatInbox                      = 0xf9
	DBIdentify                       = 0xfa
	DBResolveUsernameToUID           = 0xfb
	DBChatBodyHashIndex              = 0xfc
	DBMerkleStore                    = 0xfd
	DBChatConvFailures               = 0xfe
	DBTeamList                       = 0xff
)
View Source
const (
	DBLookupUsername = 0x00
	// was once used to store latest merkle root with Key:"HEAD"
	DBLookupMerkleRoot = 0x01
)
View Source
const (
	DeviceIDLen    = 16
	DeviceIDSuffix = 0x18
)
View Source
const (
	EnvironmentFeatureAllowHighSkips   = Feature("env_allow_high_skips")
	EnvironmentFeatureMerkleCheckpoint = Feature("merkle_checkpoint")
)
View Source
const (
	FeatureBoxAuditor                 = Feature("box_auditor3")
	ExperimentalGenericProofs         = Feature("experimental_generic_proofs")
	FeatureCheckForHiddenChainSupport = Feature("check_for_hidden_chain_support")

	// Show journeycards. This 'preview' flag is for development and admin testing.
	// This 'preview' flag is known to clients with old buggy journeycard code. For that reason, don't enable it for external users.
	FeatureJourneycardPreview = Feature("journeycard_preview")
	FeatureJourneycard        = Feature("journeycard")
)
View Source
const (
	NodeHashLenLong  = sha512.Size // = 64
	NodeHashLenShort = sha256.Size // = 32
)
View Source
const (
	ResolveCacheMaxAge        = 12 * time.Hour
	ResolveCacheMaxAgeMutable = 20 * time.Minute
)
View Source
const (
	VLogNone VDebugLevel = iota - 1
	VLog0
	VLog1
	VLog2
	VLog3

	VLogNoneString       = "mobile"
	VLog0String          = "vlog0"
	VLog1String          = "vlog1"
	VLog2String          = "vlog2"
	VLog3String          = "vlog3"
	VLogDumpSiteLoadUser = "dump-site-load-user"
	VLogDumpPayload      = "dump-payload"
)
View Source
const APICA = `` /* 2188-byte string literal not displayed */
View Source
const BuildTagProduction = false
View Source
const CanonicalHost = "keybase.io"
View Source
const ClientTriplesecVersion = 3
View Source
const CurrentGitMetadataEncryptionVersion = 1
View Source
const (
	DBSlowTeamsAlias = DBChatInbox
)

Note(maxtaco) 2018.10.08 --- Note a bug here, that we used the `libkb.DBChatInbox` type here. That's a copy-paste bug, but we get away with it since we have a `tid:` prefix that disambiguates these entries from true Chat entries. We're not going to fix it now since it would kill the team cache, but sometime in the future we should fix it.

View Source
const DefaultBgTickerWait = 5 * time.Second
View Source
const (
	DefaultCloneTokenValue string = "00000000000000000000000000000000"
)
View Source
const (
	// Do not fetch the merkle root again if it was fetched within this
	// threshold. Note that the server can always not tell us about a new root
	// even if we set this threshold to a very short value (unless we learn
	// about it otherwise), and that if we poll an honest server will tell us if
	// we should update the root (which will override this threshold).
	DefaultMerkleRootFreshness = 1 * time.Minute
)
View Source
const DefaultRunMode = DevelRunMode
View Source
const DeriveReasonPUKStellarNoteShared string = "Keybase-Derived-Stellar-Note-PUK-Sbox-NaCl-DH-1"

Not a DeriveReason because it is not used in the same way.

View Source
const DisableRootRedirectorConfigKey = "disable-root-redirector"

Also hard-coded in packaging/linux/{post_install.sh,run_keybase}

View Source
const DownloadURL = "https://keybase.io/download"
View Source
const EphemeralKeyGenInterval = time.Hour * 24 // one day

Everyday we want to generate a new key if possible

View Source
const GenericSocialWebServiceBinding = "web_service_binding.generic_social"
View Source
const (
	InviteIDTag = 0x27
)
View Source
const IsBrewBuild = false
View Source
const KBFSDevCA = `
-----BEGIN CERTIFICATE-----
MIIFjTCCA3WgAwIBAgIQFpAR2yGFjPGpRawSbyV+JzANBgkqhkiG9w0BAQsFADBP
MRIwEAYKCZImiZPyLGQBGRYCaW8xGzAZBgoJkiaJk/IsZAEZFgtkZXYua2V5YmFz
ZTEcMBoGA1UEAwwTS2V5YmFzZSBLQkZTIENBIGRldjAgFw0xNzA5MjYxNzA3MDZa
GA83MDE0MDYwMjE3MDcwNlowTzESMBAGCgmSJomT8ixkARkWAmlvMRswGQYKCZIm
iZPyLGQBGRYLZGV2LmtleWJhc2UxHDAaBgNVBAMME0tleWJhc2UgS0JGUyBDQSBk
ZXYwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCfzXIB3edtDpdpyOrS
8rSBL6STOIucCQUf8737uk1FyA8kg84YCyDUtGFe242tCncQMJ3i/3Fo4542txKf
UQ6C7XCIUKP76ZvnG6N+KJkb0Tnr3N6pOYj0xQE6dldcXHNOgOC14m84mDABH0L9
0ZSpsVKmS7svn+Nr5y8hO9J2gg8/HBGl6MupJci4VGaTFgzT22D7IvjsBEcr4Pwd
qX6VafdeXlRONrVvPTHWJilpwpDkOo2EV6Un+61bVxTejFVsDpSRlwxE/R4zUJjm
sscE0GOpyZRyzmdAPlzEVhTqlMTjpFyODukQnXUq8CvkoZzzc+aCCFQbRw33T3eF
Je+pjqJS38pzQeaxCWs35WG53+xqiAuGVuXTcc5R31gVK2E92UmrGL96V9gRSTfg
YEoT4wVHzFscMIQUpKqQ2uoJm1asiOcJG6rPFSrkTTMSiCu1ITXeL62dj7Id+6gT
wdUv/r2W8tt4cCv24mfZPKI1cHjXUjZFslHJtFXn1kG19ka+JLj7kIAeglCona22
xTwdsla5nsAX2xOhtiteYlmmOkhIj3CJLDm86PYcTcsTByiDqNdgUdFGk4uvnSph
1yW/NulAuY4BX7yIRGqwGLgQQvnsbdsvcH+kYxu3I2nNz8dsaoAsX6cMSLQ9tH/I
6Cu/3jaXanvem7yFnfuFuO3abQIDAQABo2MwYTAPBgNVHRMBAf8EBTADAQH/MA4G
A1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUknKQ73ecH+pEfJicSJdhi7Ud4ekwHwYD
VR0jBBgwFoAUknKQ73ecH+pEfJicSJdhi7Ud4ekwDQYJKoZIhvcNAQELBQADggIB
AI8dK0HiAvXtdvU3sMdK1K18JKroirK7yJL2MPKAy5Fr8IT30g/9zsoWY22zTRbD
iTcvjAoK/9DlcTSdxjYqh5s8D5jALBOxWi9e6TFWK71m6eec103TJJIOtwS2jC6u
R3hk1W56XL7cbdptAtrUfcEf3iohbnORdd50iAsGOAl/Iv4FduQeGZNJXIBpINYc
Mjo8CLA5Iw94XlyCcc8OJPYEk33Af2MiYCnccndWlophZq8fpLTaEcPGtlIYv2sA
sJhGWAdvEtZ9RoI5Rp66NuP7ZuD8GSjBwglC4PsKQS+7VdLOtt2HrzX3ZXp9DT9T
zjt/PriziUbyadK8PaYaJzTkGgJe4J0nA0UlNbRl8peEpepomPG2SyJSuNpkWh0d
zHeusngGowrBMqn54hmBwGaAGPA+b4faIq9sHnZm1TRlg0f7GeQegeJhjigAsv7q
iq2keQ2AXXnb1SUU2NbQ6GcdNEdi1eaatiWCkmp+pZLOAAJq7FsQiOF0oqo6OicX
gRQVL8BaIiQ6OQYO+XpLP0Efji0aK11X0yh02oUjdTWGBfQyBAFtccwUUDZZEaRV
FWG2uwh+ewaxA+3q+goIbIpzwbV8HMUcBAvEGajprdkv0Qmv3PY/ZVW+Y1SaSlIN
We3c57PSYN4UV4034Wr8gAZY5nzlYb0irQnl/Kw5oyNP
-----END CERTIFICATE-----
` + `
-----BEGIN CERTIFICATE-----
MIIDjDCCAnSgAwIBAgIRANRMeoRz3Xg5c8kT2f5k9wMwDQYJKoZIhvcNAQELBQAw
TzESMBAGCgmSJomT8ixkARkWAmlvMRswGQYKCZImiZPyLGQBGRYLZGV2LmtleWJh
c2UxHDAaBgNVBAMME0tleWJhc2UgS0JGUyBDQSBkZXYwHhcNMTUwOTIzMTk0NzM3
WhcNMTcwOTIyMTk0NzM3WjBPMRIwEAYKCZImiZPyLGQBGRYCaW8xGzAZBgoJkiaJ
k/IsZAEZFgtkZXYua2V5YmFzZTEcMBoGA1UEAwwTS2V5YmFzZSBLQkZTIENBIGRl
djCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALWCTpo8NNeGM6nIkNW+
4qiM8ocuFjDw2Er6XJhncgj7xjTGf/9yZqnXeGHyHGT66AtKl5bc8son4+npWmvs
47OXORF7YGi89d9KBlIC4NCetZLBSVWiSG+XXSKrmIffi6D0UojpZc2blnzgejEO
ii1uCDSaj6TRLcC8z/eXKq+DtPcfNnPL0pu5CiUNrH1cA9PS+jO1OonCGPG5yVjW
bBw0nQfThhapm9IohtdbYzlQiSbE1+3ctNwCPLas3mmUWkcrrVbn1Fa54LnfNR2u
pnZRNZ7czfB/vtymUJ6/y8dLYTmnzMFFYy416FOmvr4NqLBkaMWg9xp+KeR30044
AicCAwEAAaNjMGEwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYD
VR0OBBYEFBdb6+h+Qq5vXUWo99QbatQTX6u+MB8GA1UdIwQYMBaAFBdb6+h+Qq5v
XUWo99QbatQTX6u+MA0GCSqGSIb3DQEBCwUAA4IBAQArhp0KXfJHEhVcUXqYYjdn
pZQjq3+0aKjMjgnVWekxwwBARh4ycy2e7066ru1eDZr6myGYK+/vjXituWtq7/c/
Fifezgje6o9lB1TPamgQeE8slqqAgc3OxTqbAAf+rxJelcI6aOm7tqX04k8Aiuhm
dr64cM/NsZTKUbrCHCVNHPNj8wWkrb9pbXH/q0+Gt/gw4MiL6p1YuSr4SIENqDpP
VFiOCcbOSiw5OHPe/VwLts/g3e3NSXqd53nQW1/CgpSBdT73oWw+SBfv21KuJN5K
745S8d9JfbLItWgM73o94MSLOpUEl2F7qqXj2eOBEYWIMbRjMMZ7Vzmuo5wo3M8i
-----END CERTIFICATE-----
`
View Source
const KBFSProdCA = `
-----BEGIN CERTIFICATE-----
MIIFkjCCA3qgAwIBAgIRALpii0WkmMIt0pcl7fLxvogwDQYJKoZIhvcNAQELBQAw
UTESMBAGCgmSJomT8ixkARkWAmlvMRwwGgYKCZImiZPyLGQBGRYMa2Jmcy5rZXli
YXNlMR0wGwYDVQQDDBRLZXliYXNlIEtCRlMgQ0EgcHJvZDAgFw0xNzA5MjYxNzA3
NDJaGA83MDE0MDYwMjE3MDc0MlowUTESMBAGCgmSJomT8ixkARkWAmlvMRwwGgYK
CZImiZPyLGQBGRYMa2Jmcy5rZXliYXNlMR0wGwYDVQQDDBRLZXliYXNlIEtCRlMg
Q0EgcHJvZDCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBALtjrV8B+9ly
JjyMBX3m+9O8UbotvW9OQrPbQwVUY4LG8UJEeFETjtrZlYH4MZM7QhltBgxhnPlt
elCFxquCZTo8TScDzc6GdWZrvewDWjQTWRvxmNX++3dq5U9mbY8NqONoMoA9V4ZF
HL2xKrOITum0dSYjAzxfx5ofvdlmZ9MXTSDRu04lB0b0i2k3MnOfGQW7fxUA11lS
O5b3QrTvae20Pzhb5psjKUiaHDGMzulVO+Lz1gdsotahgxe/NCWiGjdS3OcjRbAV
BqNu7K/4xbxb580P1MOE+HSrziF3RDUSuryCzP8YMMqRXIf4rjaFYFrpazKbMoqG
pFZ//935i1lUopmIuaAkQjz/8Y11hYkdvSqVTHH0kyX7/kbEm+yIkLzn3VzoSJ5X
EL07XmHNY46LXBeDtIs3+Fdg0ISSMeHuSVYsm/TFK1VOrsToj8mbA0mF96laNMP6
d8OPWIVCbMN48MuZCT22gZCyAeHO57vXdd0Lg456WCcYcm3rQAHP0xoiHDLGxpoF
Yawl4dpj3qEdV1XJH0LQE450FVSrwfwL2FcH2+/6GVBhPEeJQgCECVbOwCbp/BPW
85Q7GntStVQQH89CqJnZEa1hglMwhaWCxVGfFDsPpM8GCh+BfXuSpQTlvOojo518
VRHxlMduI42VZMhnmHw7G4WorhhRC6inAgMBAAGjYzBhMA8GA1UdEwEB/wQFMAMB
Af8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRQmQ3lv6fySPlfpNjyUKG3wzh9
5jAfBgNVHSMEGDAWgBRQmQ3lv6fySPlfpNjyUKG3wzh95jANBgkqhkiG9w0BAQsF
AAOCAgEAEoOPz2/LQJZQId69QR5nedpoWZ7d7ob0tkM0/+S5fIgQCCsC31417pRD
QxFuPPnYh5XaEcdzWq3ECGMZZfSsDmfgJSgPwCOwtK6rXshKK+W66PK2/OGQD3Jx
QuBzBN1ZGT6saXg1pjhY1gdYCXuYiszXoYjpJZnp+sKegRB5BujEn9a1dnBCjVM3
BzXBB9PI34yc1+OJ6RusZtMa9fNgNAKJdMSTkCzVEU9qh3MhkqD/xEneUsZmdSDk
skv6/B1fpes0ctZM/JV99FrKDqq7eWnAlsF0e6GdnWL5MNOW0UupPK8edcDjr9op
cULw/+/2Hp60r50L1WWIcYEjrVmGIMpybrX1eqNilpJSjgrhX0ZqtiHh03+DcxXw
kZHxDQZf1bn+WwMxy0nb6YNBwcBXZEePb4S5KKy4V0T10YEDv7oOMrF6wIy/MxtU
wXHjIp+cd+lZkMngsGYZQExt9dq2BVmAncUiXj4ZAGQjpgSjaEuFkKDxEnRU908n
s+ljmQv1mMwPJqVyR+VIcwmAzhDSK1bwRpKgPjhkB10fBbiqPVllPuU40lSWCGEA
JB1KvwsOTY92T/h43MIeXWD2q1yzLtNmXp434uTUiZZwu2rFUYJTwagGp+z7d8TO
Zdjxkm8d4rsrfgqIWXdOQejJwYm8+LpRiOcUNpA47JR5l+HQAMQ=
-----END CERTIFICATE-----
` + `
-----BEGIN CERTIFICATE-----
MIIDkDCCAnigAwIBAgIRAL1MQ3C37AuGO8gFqfhqb9EwDQYJKoZIhvcNAQELBQAw
UTESMBAGCgmSJomT8ixkARkWAmlvMRwwGgYKCZImiZPyLGQBGRYMa2Jmcy5rZXli
YXNlMR0wGwYDVQQDDBRLZXliYXNlIEtCRlMgQ0EgcHJvZDAeFw0xNTExMDgyMzM3
MDFaFw0xNzExMDcyMzM3MDFaMFExEjAQBgoJkiaJk/IsZAEZFgJpbzEcMBoGCgmS
JomT8ixkARkWDGtiZnMua2V5YmFzZTEdMBsGA1UEAwwUS2V5YmFzZSBLQkZTIENB
IHByb2QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCr9ttTzL093jPt
WstzWR19qvLprd778ALqShZYZughuXPULgOck4AQW27vlp1nY8+7sBnWgstzL6Gv
dTQU61e34yOeAFYyKoWPFHyeo/g1y+LANgLdLbeOatOlWyM2sb/f0K3SKpusp/9J
0ylpDyko97MAI28spwX1d7L/qlDV6ryce4GrzElp3J8j3TZ3cju5rEldn8BSnLYw
i/2/Sc93GwhkjI03MZvuWaJQXQjTMALVzx5gFzshUymV4yrJfQbmBTwODf1yucsQ
NrWDiKWcFXe5dR8BWBZG7lslZeGYaHQ6lc3TgGwaPobpaZpzVEt3Crb9HAuTVl8/
Ynlw2XvzAgMBAAGjYzBhMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEG
MB0GA1UdDgQWBBSg9AYko8IqCwg2awZOZO6TW+ITsjAfBgNVHSMEGDAWgBSg9AYk
o8IqCwg2awZOZO6TW+ITsjANBgkqhkiG9w0BAQsFAAOCAQEAAJ2oOlY+DCDWr73m
TrR3Kfx+bDzvU1IZviKKooGGPjG+apcz5rWoKhjkO593ORCrygAvITnAI4v2Eaic
h2zYfWkOnCI2YYvVChR0TSJfa2+gxZFUqxRb68zMgcTxGZTZUonEX4nCJjkrSx3M
ATZkFWJDPPVci6o87VbpnKOc3mep3i1s3Cvw0GMHP+yVgw8Y0BpXII5hGbCODmoh
d2mdg2gjlOVBCfTEAe7cgUx9/lraQwUurUjDO3g54NZo/pcoc9koIW+Ai+saF5gA
UnFkqAOuEw0y4Fxzr9pw9naKF3KMlEJf6CiDJ4xspNzPZFupuepKitRrlrzofYuW
OXgZAw==
-----END CERTIFICATE-----
`
View Source
const KeyPseudonymVersion = 1
View Source
const LKSecLen = 32
View Source
const LKSecVersion = 100
View Source
const (
	LinkIDLen = 32
)
View Source
const LoginSessionMemoryTimeout time.Duration = time.Minute * 5
View Source
const MaxCPUProfileFileCount = 5

The number of CPU profile files to keep around and to bundle with sent logs.

View Source
const MaxEphemeralContentLifetime = time.Hour * 24 * 7

NOTE if you change these values you should change them in go/chatbase/storage/ephemeral.go as well.

View Source
const MaxEphemeralKeyStaleness = time.Hour * 24 * 38 // 1.25 months

NOTE: If you change this value you should change it in lib/constants.iced and go/ekreaperd/reaper.go as well. Devices are considered stale and not included in new keys after this interval

View Source
const MaxTeamMembersForPairwiseMAC = 100
View Source
const MaxTraceFileCount = 5

The number of trace files to keep around and to bundle with sent logs.

View Source
const MinEphemeralContentLifetime = time.Second * 30

Our keys must last at least this long.

View Source
const MinPassphraseLength = 8
View Source
const NaclDHKeySecretSize = 32

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

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

Todo: Ideally, box would specify nonce size

View Source
const NaclSecretBoxKeySize = 32
View Source
const NaclSigningKeySecretSize = 32

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

View Source
const (
	PGPAssertionKey = "pgp"
)
View Source
const (
	PGPFingerprintLen = 20
)
View Source
const PerUserKeySeedSize = 32
View Source
const ProfileProofSuggestions = true
View Source
const ProofIconTypeFull = "logo_full"
View Source
const ProofIconTypeFullDarkmode = "logo_full_darkmode"
View Source
const ProofIconTypeSmall = "logo_black"
View Source
const ProofIconTypeSmallDarkmode = "logo_white"
View Source
const RPCCancelerReasonAll = RPCCancelerReasonMax - 1
View Source
const RemoteIdentifyUITimeout = 5 * time.Second
View Source
const (
	SecretPromptCancelDuration = 5 * time.Minute
)
View Source
const (
	ServerUpdateLag = time.Minute
)
View Source
const SharedTeamKeyBoxVersion1 = 1
View Source
const TAliceUID = keybase1.UID("295a7eea607af32040647123732bc819")

UID of t_alice

View Source
const TeamBackoffBeforeAuditOnNeedRotate = time.Minute
View Source
const TrackingRateLimitSeconds = 50
View Source
const UPK2MinorVersionCurrent = keybase1.UPK2MinorVersion_V6
View Source
const UPKLiteMinorVersionCurrent = keybase1.UPKLiteMinorVersion_V0
View Source
const UserSummaryLimit = 500 // max number of user summaries in one request
View Source
const Version = "6.3.0"

Version is the current version (should be MAJOR.MINOR.PATCH)

Variables

View Source
var BackoffDefault = BackoffPolicy{
	[]int{0, 10, 10, 100, 100, 500, 500, 3000, 3000, 5000},
}

BackoffDefault is a backoff policy ranging up to 5 seconds.

View Source
var Base30 = NewBaseX("abcdefghjkmnpqrsuvwxyz23456789")
View Source
var Base58 = NewBaseX("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
View Source
var CheckDeviceName = Checker{
	F: func(s string) bool {
		normalized := normalizeDeviceName(s)

		return len(normalized) >= 3 &&
			len(normalized) <= 64 &&
			deviceRE.MatchString(s) &&
			!badDeviceRE.MatchString(s)
	},
	Transform: func(s string) string {
		s = strings.ReplaceAll(s, "—", "-")
		s = strings.ReplaceAll(s, "–", "-")
		s = strings.ReplaceAll(s, "‘", "'")
		s = strings.ReplaceAll(s, "’", "'")
		return s
	},
	Normalize: normalizeDeviceName,
	Hint:      "between 3 and 64 characters long; use a-Z, 0-9, space, plus, underscore, dash and apostrophe",
}
View Source
var CheckEmail = Checker{
	F: func(s string) bool {
		return len(s) > 3 && emailRE.MatchString(s)
	},
	Hint: "must be a valid email address",
}
View Source
var CheckEmailOrUsername = Checker{
	F: func(s string) bool {
		return CheckEmail.F(s) || CheckUsername.F(s)
	},
	Hint: "valid usernames are 2-16 letters long",
}
View Source
var CheckInviteCode = Checker{
	F: func(s string) bool {
		return len(s) > 4
	},
	Hint: "Invite codes are 4 or more characters",
}
View Source
var CheckNotEmpty = Checker{
	F: func(s string) bool {
		return len(s) > 0
	},
	Hint: "cannot be empty",
}
View Source
var CheckPassphraseNew = Checker{
	F: func(s string) bool {
		r := []rune(s)
		if len(r) > 0 && unicode.IsSpace(r[0]) {
			return false
		}
		return len(s) >= MinPassphraseLength
	},
	Hint:          fmt.Sprintf("passphrase must be %d or more characters", MinPassphraseLength),
	PreserveSpace: true,
}
View Source
var CheckPassphraseSimple = Checker{
	F: func(s string) bool {
		return len(s) > 0
	},
	Hint: "passphrase cannot be empty",
}
View Source
var CheckUsername = Checker{
	F:    kbun.CheckUsername,
	Hint: "between 2 and 16 characters long",
}
View Source
var CheckYesNo = Checker{
	F: func(s string) bool {
		return IsYes(s) || IsNo(s)
	},
	Hint: "'yes' or 'no'",
}
View Source
var CodeSigningProdKIDs = []string{
	"01209092ae4e790763dc7343851b977930f35b16cf43ab0ad900a2af3d3ad5cea1a10a",
	"012045891a45f03cec001196ad05207f3f80045b2b9f0ca38288a85f8120ac74db960a",
	"012065ae849d1949a8b0021b165b0edaf722e2a7a9036e07817e056e2d721bddcc0e0a",
	"01202a70fa31596ae2afabbbea827c7d1efb205c4b02b2b98b8f8c75915be433ccb50a",
	"0120f2f55c76151b3eaf91d20dfb673d8591d8b49fd5cb210a10f6e0dd8724bf34f30a",
	"0120deaa8ae7d06ea9aa49cc678ec49f2b1e1dddb63683e384db539a8649c47925f90a",
}
View Source
var CodeSigningStagingKIDs = []string{}
View Source
var CodeSigningTestKIDs = []string{}
View Source
var DefaultDesktopDbCleanerConfig = DbCleanerConfig{
	MaxSize:       2 * opt.GiB,
	HaltSize:      1.5 * opt.GiB,
	CleanInterval: time.Hour,
	CacheCapacity: 100000,
	MinCacheSize:  10000,
	SleepInterval: 50 * time.Millisecond,
}
View Source
var DefaultMobileDbCleanerConfig = DbCleanerConfig{
	MaxSize:       opt.GiB,
	HaltSize:      opt.GiB * .75,
	CleanInterval: time.Hour,
	CacheCapacity: 100000,
	MinCacheSize:  10000,
	SleepInterval: 10 * time.Millisecond,
}
View Source
var ErrLoginSessionCleared = errors.New("LoginSession already cleared")
View Source
var ErrLoginSessionNotLoaded = errors.New("LoginSession not loaded")
View Source
var ErrNilUser = errors.New("User is nil")
View Source
var ErrTrackingExpired = errors.New("Local track expired")
View Source
var ErrUnlockNotPossible = errors.New("unlock not possible")
View Source
var FirstProdMerkleSeqnoWithHiddenRootHash = keybase1.Seqno(14145980)

FirstProdMerkleSeqnoWithHiddenRootHash is the first merkle root on production that contains the hash of a blind merkle tree root.

View Source
var FirstProdMerkleSeqnoWithSigs = keybase1.Seqno(796)

We didn't have valid signatures before 796, so don't try to load them.

View Source
var FirstProdMerkleSeqnoWithSkips = keybase1.Seqno(835903)

FirstProdMerkleSeqnoWithSkips is the first merkle root on production that has skip pointers indicating log(n) previous merkle roots.

View Source
var FirstProdMerkleTreeWithModernShape = keybase1.Seqno(531408)

Before this merkle seqno, we had the other, more bushy shape. From this point on, we have the modern shape. It's possible to tweak our clients to handle both shapes, but it's not really worth it at this time.

View Source
var HashToName = map[crypto.Hash]string{
	crypto.MD4:         "MD4",
	crypto.MD5:         "MD5",
	crypto.SHA1:        "SHA1",
	crypto.SHA224:      "SHA2-224",
	crypto.SHA256:      "SHA2-256",
	crypto.SHA384:      "SHA2-384",
	crypto.SHA512:      "SHA2-512",
	crypto.RIPEMD160:   "RIPEMD-160",
	crypto.SHA3_224:    "SHA3-224",
	crypto.SHA3_256:    "SHA3-256",
	crypto.SHA3_384:    "SHA3-384",
	crypto.SHA3_512:    "SHA3-512",
	crypto.SHA512_224:  "SHA2-512/224",
	crypto.SHA512_256:  "SHA2-512/256",
	crypto.BLAKE2s_256: "BLAKE2s-256",
	crypto.BLAKE2b_256: "BLAKE2b-256",
	crypto.BLAKE2b_384: "BLAKE2b-384",
	crypto.BLAKE2b_512: "BLAKE2b-512",
}
View Source
var IsIPad bool // Set by bind's Init.
View Source
var MerkleProdKIDs = []string{
	"010159baae6c7d43c66adf8fb7bb2b8b4cbe408c062cfc369e693ccb18f85631dbcd0a",
	"01209ec31411b9b287f62630c2486005af27548ba62a59bbc802e656b888991a20230a",
}
View Source
var MerkleStagingKIDs = []string{
	"0101bed85ce72cc315828367c28b41af585b6b7d95646a62ca829691d70f49184fa70a",
	"01202e045e19e8d68ddd3d1582113bfd397f244f0529025ad8ccad7f0397e13d69c60a",
}
View Source
var MerkleTestKIDs = []string{
	"0101be58b6c82db64f6ccabb05088db443c69f87d5d48857d709ed6f73948dabe67d0a",
	"0120328031cf9d2a6108036408aeb3646b8985f7f8ff1a8e635e829d248a48b1014d0a",
}
View Source
var PGPArmorHeaders = map[string]string{
	"Version": PGPVersion,
	"Comment": DownloadURL,
}
View Source
var PGPVersion = "Keybase Go " + Version + " (" + runtime.GOOS + ")"
View Source
var PrereleaseBuild string

PrereleaseBuild can be set at compile time for prerelease builds. CAUTION: Don't change the name of this variable without grepping for occurrences in shell scripts!

View Source
var ProofErrorDNSOverTor = &ProofErrorImpl{
	Status: keybase1.ProofStatus_TOR_SKIPPED,
	Desc:   "DNS proofs aren't reliable over Tor",
}
View Source
var ProofErrorHTTPOverTor = &ProofErrorImpl{
	Status: keybase1.ProofStatus_TOR_SKIPPED,
	Desc:   "HTTP proofs aren't reliable over Tor",
}
View Source
var ProofErrorUnchecked = &ProofErrorImpl{
	Status: keybase1.ProofStatus_UNCHECKED,
	Desc:   "Proof unchecked due to privacy concerns",
}
View Source
var ProxyTypeEnumToStr = map[ProxyType]string{Socks: "socks", HTTPConnect: "http_connect", NoProxy: "no_proxy"}
View Source
var ProxyTypeStrToEnum = map[string]ProxyType{"socks": Socks, "http_connect": HTTPConnect}

Maps a string to an enum. Used to list the different types of supported proxies and to convert config options into the enum

View Source
var PublicChain = &ChainType{
	DbType:          DBSigChainTailPublic,
	Private:         false,
	Encrypted:       false,
	GetMerkleTriple: func(u *MerkleUserLeaf) *MerkleTriple { return u.public },
}

remove when ShouldUseParameterizedProofs is removed

View Source
var ServiceUsage = Usage{
	Config:     true,
	KbKeyring:  true,
	GpgKeyring: true,
	API:        true,
	Socket:     true,
}

If changed, make sure to correct standalone usage in g.Configure below

View Source
var TorProxy = "localhost:9050"
View Source
var UserAgent = runtime.GOOS + ":" + "Keybase CLI (" + runtime.Version() + "):" + Version

Right now reddit is the only site that seems to have any requirements for our User-Agent string. (See https://github.com/reddit/reddit/wiki/API.) If something else comes up, we'll want to make this more configurable.

Functions

func AcquireWithContext

func AcquireWithContext(ctx context.Context, lock sync.Locker) (err error)

AcquireWithContext attempts to acquire a lock with a context. Returns nil if the lock was acquired. Returns an error if it was not. The error is from ctx.Err().

func AcquireWithContextAndTimeout

func AcquireWithContextAndTimeout(ctx context.Context, lock sync.Locker, timeout time.Duration) (err error)

AcquireWithContextAndTimeout attempts to acquire a lock with a context and a timeout. Convenience wrapper around AcquireWithContext. Returns nil if the lock was acquired. Returns context.DeadlineExceeded or the error from ctx.Err() if it was not.

func AcquireWithTimeout

func AcquireWithTimeout(lock sync.Locker, timeout time.Duration) (err error)

AcquireWithTimeout attempts to acquire a lock with a timeout. Convenience wrapper around AcquireWithContext. Returns nil if the lock was acquired. Returns context.DeadlineExceeded if it was not.

func AddEnvironmentFeatureForTest

func AddEnvironmentFeatureForTest(tc TestContext, feature Feature)

func AddPerUserKeyServerArg

func AddPerUserKeyServerArg(serverArg JSONPayload, generation keybase1.PerUserKeyGeneration,
	pukBoxes []keybase1.PerUserKeyBox, pukPrev *PerUserKeyPrev)

Make the "per_user_key" section of an API arg. Requires one or more `pukBoxes` `pukPrev` is optional. Modifies `serverArg`.

func AddToProofSetNoChecks

func AddToProofSetNoChecks(r RemoteProofChainLink, ps *ProofSet)

func AddUserEKReBoxServerArg

func AddUserEKReBoxServerArg(serverArg JSONPayload, arg *keybase1.UserEkReboxArg)

Make the "user_ek_rebox" and "device_eks" section of an API arg. Modifies `serverArg` unless arg is nil.

func AppDataDir

func AppDataDir() (string, error)

func AssertUsernameMatchesUID

func AssertUsernameMatchesUID(g *GlobalContext, uid keybase1.UID, username string) error

func AssertionIsTeam

func AssertionIsTeam(au AssertionURL) bool

func AttachedSignWrapper

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

func BinaryKIDToRawNaCl

func BinaryKIDToRawNaCl(k keybase1.BinaryKID) (ret []byte, err error)

func BootstrapActiveDeviceFromConfig

func BootstrapActiveDeviceFromConfig(m MetaContext, online bool) (uid keybase1.UID, err error)

BootstrapActiveDeviceFromConfig takes the user's config.json, keys.mpack file and secret store to populate ActiveDevice, and to have all credentials necessary to sign NIST tokens, allowing the user to act as if "logged in". Will return nil if everything work, LoginRequiredError if a real "login" is required to make the app work, and various errors on unexpected failures.

func BootstrapActiveDeviceWithMetaContext

func BootstrapActiveDeviceWithMetaContext(m MetaContext) (ok bool, uid keybase1.UID, err error)

BootstrapActiveDeviceWithMetaContext will setup an ActiveDevice with a NIST Factory for the caller. The m.loginContext passed through isn't really needed for anything aside from assertions, but as we phase out LoginState, we'll leave it here so that assertions in LoginState can still pass.

func BootstrapActiveDeviceWithMetaContextAndAssertUID

func BootstrapActiveDeviceWithMetaContextAndAssertUID(m MetaContext, uid keybase1.UID) (ok bool, err error)

BootstrapActiveDeviceWithMetaContextAndAssertUID will setup an ActiveDevice with a NIST Factory for the caller. It only works if we're logged in as the given UID

func BoxPublicKeyToKeybaseKID

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

func BtcAddrCheck

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

func BuildProxyAddressWithProtocol

func BuildProxyAddressWithProtocol(proxyType ProxyType, proxyAddress string) string

Get a string that represents a proxy including the protocol needed for the proxy

func CITimeMultiplier

func CITimeMultiplier(g *GlobalContext) time.Duration

func CTimeLog

func CTimeLog(ctx context.Context, name string, start time.Time, out func(context.Context, string, ...interface{}))

CTimeLog calls out with the time since start. Use like this:

defer CTimeLog(ctx, "MyFunc", time.Now(), e.G().Log.Warning)

func CTrace

func CTrace(ctx context.Context, log logger.Logger, msg string, err *error, cl clockwork.Clock) func()

func CanEncrypt

func CanEncrypt(key GenericKey) bool

func CanExec

func CanExec(p string) error

func CanLogout

func CanLogout(mctx MetaContext) (res keybase1.CanLogoutRes)

func CancelDowngradeLease

func CancelDowngradeLease(ctx context.Context, g *GlobalContext, l keybase1.LeaseID) error

func CancelResetPipeline

func CancelResetPipeline(mctx MetaContext) (err error)

func CanonicalProofName

func CanonicalProofName(t TypedChainLink) string

func ChangeMountIcon

func ChangeMountIcon(oldMount string, newMount string) error

func CheckCurrentUIDDeviceID

func CheckCurrentUIDDeviceID(m MetaContext) (err error)

func CheckInvitationCode

func CheckInvitationCode(m MetaContext, code string) error

func CheckKID

func CheckKID(u *keybase1.UserPlusKeysV2AllIncarnations, kid keybase1.KID) (found bool, revokedAt *keybase1.KeybaseTime, deleted bool)

func CheckPosted

func CheckPosted(mctx MetaContext, sigID keybase1.SigID) (found bool, status keybase1.ProofStatus, state keybase1.ProofState, err error)

func CheckTracking

func CheckTracking(g *GlobalContext) error

func CheckUIDAgainstUsername

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

func Cicmp

func Cicmp(s1, s2 string) bool

func ClearPwhashEddsaPassphraseStream

func ClearPwhashEddsaPassphraseStream(mctx MetaContext, username NormalizedUsername) error

func ClearSecretsOnDeprovision

func ClearSecretsOnDeprovision(mctx MetaContext, username NormalizedUsername) error

XXX: THIS DELETES SECRET KEYS. Deleting the wrong secret keys can make you lose all your data forever. We only run this in the DeprovisionEngine and if we detect that our device was revoked in LogoutAndDeprovisionIfRevoked.

func ClearStoredSecret

func ClearStoredSecret(m MetaContext, username NormalizedUsername) error

func CollectAssertions

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

func CombineErrors

func CombineErrors(errs ...error) error

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

func Contains

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

Contains returns true if string is contained in string slice

func CopyTagsToBackground

func CopyTagsToBackground(ctx context.Context) context.Context

func CreateClonedDevice

func CreateClonedDevice(tc TestContext, m MetaContext)

func CreateReadOnlySecretStoreDir

func CreateReadOnlySecretStoreDir(tc TestContext) (string, func())

func CurrentBinaryRealpath

func CurrentBinaryRealpath() (string, error)

func CurrentSaltpackVersion

func CurrentSaltpackVersion() saltpack.Version

func DebugDumpKey

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

DebugDumpKey is used only in debugging. For now it's not in use but we might need it in the future.

func DecodeHexFixed

func DecodeHexFixed(dst, src []byte) error

Decode decodes src into dst. Errors unless all of: - src is valid hex - src decodes into exactly len(dst) bytes

func DecodeWindowsNameForKbfs

func DecodeWindowsNameForKbfs(windowsName string) (kbfsName string, err error)

DecodeWindowsNameForKbfs decodes a path element encoded by EncodeKbfsNameForWindows.

func DefaultPassphraseArg

func DefaultPassphraseArg(m MetaContext) keybase1.GUIEntryArg

func DefaultPassphrasePromptArg

func DefaultPassphrasePromptArg(mctx MetaContext, username string) keybase1.GUIEntryArg

func DelegatorAggregator

func DelegatorAggregator(m MetaContext, ds []Delegator, extra AggSigProducer,
	pukBoxes []keybase1.PerUserKeyBox, pukPrev *PerUserKeyPrev, userEKReboxArg *keybase1.UserEkReboxArg) (err error)

Run posts an array of delegations to the server. Keeping this simple as we don't need any state (yet) `extra` is optional and adds an extra sig, produced by something other than a Delegator, after the others.

func DeleteAccount

func DeleteAccount(mctx MetaContext, username NormalizedUsername, passphrase *string) (err error)

func DeletePrimary

func DeletePrimary(m MetaContext) (err error)

func DeriveFromSecret

func DeriveFromSecret(inKey [32]byte, reason DeriveReason) (outKey [32]byte, err error)

Derive a key from another. Uses HMAC(key=key, data=reason) Not to be confused with DeriveSymmetricKey which has hmac inputs swapped. This one makes sense for derivation from secrets used only to derive from.

func DeviceStatusToString

func DeviceStatusToString(i *int) string

func Digest

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

Digest returns a SHA256 digest

func DigestForFileAtPath

func DigestForFileAtPath(path string) (string, error)

DigestForFileAtPath returns a SHA256 digest for file at specified path

func DisableProcessTracing

func DisableProcessTracing() error

func DiscardAndCloseBody

func DiscardAndCloseBody(resp *http.Response) error

DiscardAndCloseBody reads as much as possible from the body of the given response, and then closes it.

This is because, in order to free up the current connection for re-use, a response body must be read from before being closed; see http://stackoverflow.com/a/17953506 .

Instead of doing:

res, _ := ...
defer res.Body.Close()

do

res, _ := ...
defer DiscardAndCloseBody(res)

instead.

func DismissWotNotifications

func DismissWotNotifications(mctx MetaContext, voucherUsername, voucheeUsername string) (err error)

func DisplayTrackArg

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

func DisplayUserCardAsync

func DisplayUserCardAsync(m MetaContext, uid keybase1.UID, useSession bool) <-chan error

func DrainPipe

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

func EmbedExpansionObj

func EmbedExpansionObj(statement *jsonw.Wrapper) (expansion *jsonw.Wrapper, sum []byte, err error)

func EncodeKbfsNameForWindows

func EncodeKbfsNameForWindows(kbfsName string) (windowsName string)

EncodeKbfsNameForWindows encodes a KBFS path element for Windows by escaping disallowed characters.

func EncryptPGPKey

func EncryptPGPKey(bundle *openpgp.Entity, passphrase string) error

func EncryptionKIDToPublicKeyBytes

func EncryptionKIDToPublicKeyBytes(bk []byte) ([]byte, error)

func ErrToOk

func ErrToOk(err error) string

func ErrToOkPtr

func ErrToOkPtr(err *error) string

func ExportErrorAsStatus

func ExportErrorAsStatus(g *GlobalContext, e error) (ret *keybase1.Status)

func ExportPGPIdentity

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

func ExportProofError

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

func ExportTrackDiff

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

func ExportTrackIDComponentToRevokedProof

func ExportTrackIDComponentToRevokedProof(tidc TrackIDComponent) keybase1.RevokedProof

func ExportTrackSummary

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

func ExtractExpansionObj

func ExtractExpansionObj(expansionID string, expansionJSON string) (expansionObj []byte, err error)

ExtractExpansionObj extracts the `obj` field from a sig expansion and verifies the hash of the content matches the expected id. This is reusable beyond WotVouchChainLink.

func ExtractPGPSignatureHashMethod

func ExtractPGPSignatureHashMethod(keyring openpgp.KeyRing, sig []byte) (crypto.Hash, uint64, error)

func FastByteArrayEq

func FastByteArrayEq(a, b []byte) bool

func FetchWotVouches

func FetchWotVouches(mctx MetaContext, arg FetchWotVouchesArg) (res []keybase1.WotVouch, err error)

FetchWotVouches gets vouches written for vouchee (if specified) by voucher (if specified).

func FileExists

func FileExists(path string) (bool, error)

exists returns whether the given file or directory exists or not

func FindBase64Block

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

func FindBase64Blocks

func FindBase64Blocks(s string) []string

func FindBase64Snippets

func FindBase64Snippets(s string) []string

func FindBestIdentifyComponent

func FindBestIdentifyComponent(e AssertionExpression) string

func FindFilePathWithNumberSuffix

func FindFilePathWithNumberSuffix(parentDir string, basename string, useArbitraryName bool) (filePath string, err error)

func FindFirstBase64Block

func FindFirstBase64Block(s string) string

func FindNextMerkleRootAfterRevoke

func FindNextMerkleRootAfterRevoke(m MetaContext, arg keybase1.FindNextMerkleRootAfterRevokeArg) (res keybase1.NextMerkleRootRes, err error)

FindNextMerkleRootAfterRevoke loads the user for the given UID, and find the next merkle root after the given key revocation happens. It uses the parameter arg.Prev to figure out where to start looking and then keeps searching forward until finding a leaf that matches arg.Loc.

func FindPGPPrivateKey

func FindPGPPrivateKey(k *PGPKeyBundle) bool

FindPGPPrivateKey checks if supposed secret key PGPKeyBundle contains any valid PrivateKey entities. Sometimes primary private key is stoopped out but there are subkeys with secret keys.

func FindPreferredKBFSMountDirs

func FindPreferredKBFSMountDirs() (mountDirs []string)

func ForceWallClock

func ForceWallClock(t time.Time) time.Time

ForceWallClock takes a multi-personality Go time and converts it to a regular old WallClock time.

func FormatImplicitTeamDisplayNameSuffix

func FormatImplicitTeamDisplayNameSuffix(conflict keybase1.ImplicitTeamConflictInfo) string

func FormatTime

func FormatTime(tm time.Time) string

func GenericKeyEqual

func GenericKeyEqual(k1, k2 GenericKey) bool

func GetAllProvisionedUsernames

func GetAllProvisionedUsernames(mctx MetaContext) (current NormalizedUsername, all []NormalizedUsername, err error)

GetAllProvisionedUsernames looks into the current config.json file, and finds all usernames that are currently provisioned on this device. Then, it asks the server to filter out revoked devices or reset users.

func GetAppStatusCode

func GetAppStatusCode(err error) (code keybase1.StatusCode, ok bool)

If the error is an AppStatusError, returns its code. Otherwise returns (SCGeneric, false).

func GetBundledCAsFromHost

func GetBundledCAsFromHost(host string) (rootCA []byte, ok bool)

GetBundledCAsFromHost returns in root CA in []byte for given host, or nil if no matching CA is found for host.

func GetClientStatus

func GetClientStatus(mctx MetaContext) (res []keybase1.ClientStatus)

func GetCommaSeparatedListOfProxyTypes

func GetCommaSeparatedListOfProxyTypes() string

func GetConfiguredAccountsFromProvisionedUsernames

func GetConfiguredAccountsFromProvisionedUsernames(m MetaContext, s SecretStoreAll, currentUsername NormalizedUsername, allUsernames []NormalizedUsername) ([]keybase1.ConfiguredAccount, error)

func GetContactSettings

func GetContactSettings(mctx MetaContext) (ret keybase1.ContactSettings, err error)

func GetFullName

func GetFullName(m MetaContext, uid keybase1.UID) (string, error)

func GetInvitationCode

func GetInvitationCode(m MetaContext) (string, error)

func GetKBFSPathInfo

func GetKBFSPathInfo(standardPath string) (pathInfo keybase1.KBFSPathInfo, err error)

func GetKID

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

func GetLinkIDVoid

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

func GetNewKeybasePassphrase

func GetNewKeybasePassphrase(mctx MetaContext, ui SecretUI, arg keybase1.GUIEntryArg, confirm string) (keybase1.GetPassphraseRes, error)

func GetNodeHashVoid

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

func GetOneKey

func GetOneKey(jw *jsonw.Wrapper) (*PGPKeyBundle, *Warnings, error)

func GetPGPFingerprintVoid

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

func GetPaperKeyForCryptoPassphrase

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

func GetPaperKeyPassphrase

func GetPaperKeyPassphrase(m MetaContext, ui SecretUI, username string, lastErr error, expectedPrefix *string) (string, error)

func GetPassphraseStreamViaPrompt

func GetPassphraseStreamViaPrompt(m MetaContext) (pps *PassphraseStream, tsec Triplesec, err error)

GetPassphraseStreamViaPrompt prompts the user for a passphrase and on success returns a PassphraseStream and Triplesec derived from the user's passphrase. As a side effect, it stores the full LKSec in the secret store.

func GetPassphraseUntilCheckWithChecker

func GetPassphraseUntilCheckWithChecker(m MetaContext, arg keybase1.GUIEntryArg, prompter PassphrasePrompter, checker *Checker) (keybase1.GetPassphraseRes, error)

func GetPlatformString

func GetPlatformString() string

func GetProxyCAs

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

func GetSafeFilename

func GetSafeFilename(filename string) (safeFilename string)

func GetSafePath

func GetSafePath(path string) (safePath string)

func GetSecret

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

func GetSigID

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

func GetSigIDBase

func GetSigIDBase(w *jsonw.Wrapper) (keybase1.SigIDBase, error)

func GetSortedCPUProfileFiles

func GetSortedCPUProfileFiles(dir string) ([]string, error)

GetSortedCPUProfileFiles returns all CPU profile files in the given directory approximately sorted by increasing start time.

func GetSortedTraceFiles

func GetSortedTraceFiles(dir string) ([]string, error)

GetSortedTraceFiles returns all trace files in the given directory approximately sorted by increasing start time.

func GetTriplesecMaybePrompt

func GetTriplesecMaybePrompt(m MetaContext) (tsec Triplesec, ppgen PassphraseGeneration, err error)

GetTriplesecMaybePrompt will try to get the user's current triplesec. It will either pluck it out of the environment or prompt the user for a passphrase if it can't be found. The secret store is of no use here, so skip it. Recall that the full passphrase stream isn't stored to the secret store, only the bits that encrypt local keys.

func GetUID

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

func GetUIDByNormalizedUsername

func GetUIDByNormalizedUsername(g *GlobalContext, username NormalizedUsername) keybase1.UID

GetUIDByNormalizedUsername returns UID for normalized username. Works offline for all usernames.

func GetUIDByUsername

func GetUIDByUsername(g *GlobalContext, username string) keybase1.UID

GetUIDByUsername returns UID for username strings with potentially mixed letter casing. Works offline for all usernames.

func GetUIDVoid

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

func GiveMeAnS

func GiveMeAnS(i int) string

func HeaderVersion

func HeaderVersion() string

func HexDecodeQuoted

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

func HumanError

func HumanError(err error) error

HumanError takes an error and returns the topmost human error that's in the error, maybe to export to the CLI, KBFS, or Electron. It's a mashup of the pkg/errors Error() function, and also our own desire to return the topmost HumanError.

See https://github.com/pkg/errors/blob/master/errors.go for the original pkg/errors code

func HumanizeResetTime

func HumanizeResetTime(t time.Time) string

func ImportStatusAsError

func ImportStatusAsError(g *GlobalContext, s *keybase1.Status) error

func InstrumentationTagFromRequest

func InstrumentationTagFromRequest(req *http.Request) string

func IsAndroid

func IsAndroid() bool

func IsAppStatusCode

func IsAppStatusCode(err error, code keybase1.StatusCode) bool

func IsArmored

func IsArmored(buf []byte) bool

func IsAssertionParseErrorWithReason

func IsAssertionParseErrorWithReason(err error, reason AssertionParseErrorReason) bool

func IsDirEmpty

func IsDirEmpty(dir string) (bool, error)

IsDirEmpty returns whether directory has any files.

func IsEmpty

func IsEmpty(s string) bool

func IsEphemeralRetryableError

func IsEphemeralRetryableError(err error) bool

func IsExecError

func IsExecError(err error) bool

func IsHashSecure

func IsHashSecure(hash crypto.Hash) bool

func IsIOS

func IsIOS() bool

func IsIdentifyProofError

func IsIdentifyProofError(err error) bool

func IsIn

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

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

func IsKBFSAfterKeybasePath

func IsKBFSAfterKeybasePath(afterKeybase string) bool

IsKBFSAfterKeybasePath returns true if afterKeybase, after prefixed by /keybase, is a valid KBFS path.

func IsKeybaseAdmin

func IsKeybaseAdmin(uid keybase1.UID) bool

IsKeybaseAdmin returns true if uid is a keybase admin.

func IsLowercase

func IsLowercase(s string) bool

func IsMobilePlatform

func IsMobilePlatform() bool

func IsNo

func IsNo(s string) bool

func IsNoKeyError

func IsNoKeyError(err error) bool

func IsNoSpaceOnDeviceError

func IsNoSpaceOnDeviceError(err error) bool

IsNoSpaceOnDeviceError will return true if err is an `os` error for "no space left on device".

func IsNotFoundError

func IsNotFoundError(err error) bool

func IsPGP

func IsPGP(key GenericKey) bool

func IsPGPAlgo

func IsPGPAlgo(algo kbcrypto.AlgoType) bool

func IsPGPSig

func IsPGPSig(s string) bool

func IsPermDbKey

func IsPermDbKey(typ ObjType) bool

IsPermDbKey returns true for keys ignored by the leveldb cleaner and always persisted to disk. Ideally these keys handling some cleanup/size bounding themselves.

func IsPossiblePhoneNumber

func IsPossiblePhoneNumber(phone keybase1.PhoneNumber) error

IsPossiblePhoneNumber checks if s is string of digits in phone number format

func IsPossiblePhoneNumberAssertion

func IsPossiblePhoneNumberAssertion(s string) bool

IsPossiblePhoneNumberAssertion checks if s is string of digits without a `+` prefix for SBS assertions

func IsResolutionError

func IsResolutionError(err error) bool

func IsResolutionNotFoundError

func IsResolutionNotFoundError(err error) bool

func IsSocialAssertion

func IsSocialAssertion(ctx AssertionContext, s string) bool

IsSocialAssertion returns true for strings that are valid social assertions. They do not need to be normalized, so user@twitter and twitter:user will work, as will USER@Twitter.

func IsSocketClosedError

func IsSocketClosedError(e error) bool

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

func IsSystemAdminUser

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

IsSystemAdminUser returns true if current user is root or admin (system user, not Keybase user). WARNING: You shouldn't rely on this for security purposes.

func IsTooManyFilesError

func IsTooManyFilesError(err error) bool

func IsUserByUsernameOffline

func IsUserByUsernameOffline(m MetaContext, un NormalizedUsername) bool

IsUserByUsernameOffline checks to see if the given username is a legit Keybase username, using only our offline cache and materials. Useful if you don't mean to share info with the server, as in chat @-mentions. Will return true if it's known to be a legit user, and false if it can't say for sure. "Legit" users in this context might be deleted or reset; they just once existing as a user.

func IsValidHostname

func IsValidHostname(s string) bool

func IsYes

func IsYes(s string) bool

func JoinPredicate

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

JoinPredicate joins strings with predicate

func JsonwStringArray

func JsonwStringArray(a []string) *jsonw.Wrapper

func KIDIsDeviceEncrypt

func KIDIsDeviceEncrypt(kid keybase1.KID) bool

func KIDIsDeviceVerify

func KIDIsDeviceVerify(kid keybase1.KID) bool

func KIDIsPGP

func KIDIsPGP(kid keybase1.KID) bool

func KbOpenSig

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

func KeyLookupByBoxPublicKey

func KeyLookupByBoxPublicKey(mctx MetaContext, k saltpack.BoxPublicKey) (username string, uid keybase1.UID, err error)

func KeyLookupKIDIncludingRevoked

func KeyLookupKIDIncludingRevoked(mctx MetaContext, k keybase1.KID) (username string, uid keybase1.UID, err error)

func KeyMatchesQuery

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

Any valid key matches the empty string.

func KeyProof

func KeyProof(m MetaContext, arg Delegator) (*jsonw.Wrapper, error)

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

func KeybaseEmailAddress

func KeybaseEmailAddress(s string) string

func LinkEntropy

func LinkEntropy() (string, error)

func LoadPassphraseState

func LoadPassphraseState(mctx MetaContext) (passphraseState keybase1.PassphraseState, err error)

func LoadPassphraseStateFromRemote

func LoadPassphraseStateFromRemote(mctx MetaContext) (passphraseState keybase1.PassphraseState, err error)

func LoadPassphraseStateWithForceRepoll

func LoadPassphraseStateWithForceRepoll(mctx MetaContext) (passphraseState keybase1.PassphraseState, err error)

forceRepoll only forces repoll when the state is RANDOM, but not when it is KNOWN.

func LoadUPAKLite

func LoadUPAKLite(arg LoadUserArg) (ret *keybase1.UPKLiteV1AllIncarnations, err error)

func LoadUnlockedDeviceKeys

func LoadUnlockedDeviceKeys(m MetaContext, uid keybase1.UID, deviceID keybase1.DeviceID, mode LoadUnlockedDeviceKeysMode) (uv keybase1.UserVersion, sib GenericKey, sub GenericKey, deviceName string, err error)

func LoadUserEmails

func LoadUserEmails(m MetaContext) (emails []keybase1.Email, err error)

LoadUserEmails returns emails for logged in user

func LoadUserPlusKeys

func LoadUserPlusKeys(ctx context.Context, g *GlobalContext, uid keybase1.UID, pollForKID keybase1.KID) (keybase1.UserPlusKeys, error)

LoadUserPlusKeys loads user and keys for the given UID. If `pollForKID` is provided, we'll request this user potentially twice: the first time can hit the cache for the UID, but will force a repoll unless the pollForKID is found for the user. If pollForKID is empty, then just access the cache as normal.

func LocalDataDir

func LocalDataDir() (string, error)

func LogTagsFromContext

func LogTagsFromContext(ctx context.Context) (map[interface{}]string, bool)

LogTagsFromContext is a wrapper around logger.LogTagsFromContext that simply casts the result to the type expected by rpc.Connection.

func LogTagsFromString

func LogTagsFromString(tags string) map[string]string

func LogTagsToString

func LogTagsToString(ctx context.Context) string

func LoginFromPassphraseStream

func LoginFromPassphraseStream(mctx MetaContext, username string, pps *PassphraseStream) (err error)

func LookupSaltForUID

func LookupSaltForUID(m MetaContext, uid keybase1.UID) (salt []byte, err error)

func MPackDecode

func MPackDecode(data []byte, res interface{}) error

func MPackEncode

func MPackEncode(input interface{}) ([]byte, error)

func MakeAndPostKeyPseudonyms

func MakeAndPostKeyPseudonyms(m MetaContext, pnymInfos *[]KeyPseudonymInfo) (err error)

MakeAndPostKeyPseudonyms fills the KeyPseudonym field of each of the pnymInfos with the appropriate KeyPseudonym.

func MakeByte24

func MakeByte24(a []byte) [24]byte

func MakeByte32

func MakeByte32(a []byte) [32]byte

func MakeByte32Soft

func MakeByte32Soft(a []byte) ([32]byte, error)

func MakeCPUProfileFilename

func MakeCPUProfileFilename(dir string, start time.Time, duration time.Duration) string

MakeCPUProfileFilename returns a filename to use for a CPU profile file in the given directory with the given start time and duration.

func MakeParentDirs

func MakeParentDirs(log SkinnyLogger, filename string) error

func MakeProofIcons

func MakeProofIcons(mctx MetaContext, serviceKey, iconType string, size int) (res []keybase1.SizedImage)

func MakeProxy

func MakeProxy(e *Env) func(r *http.Request) (*url.URL, error)

Return a function that can be passed to the http library in order to configure a proxy

func MakeTraceFilename

func MakeTraceFilename(dir string, start time.Time, duration time.Duration) string

MakeTraceFilename returns a filename to use for a trace file in the given directory with the given start time and duration.

func MakeURI

func MakeURI(prot string, host string) string

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

func MakeWrapError

func MakeWrapError(g *GlobalContext) func(e error) interface{}

func MaybeSavePassphraseState

func MaybeSavePassphraseState(mctx MetaContext, passphraseState keybase1.PassphraseState)

func MerkleCheckPostedUserSig

func MerkleCheckPostedUserSig(mctx MetaContext, uid keybase1.UID,
	seqno keybase1.Seqno, linkID LinkID) (err error)

Verify that the given link has been posted to the merkle tree. Used to detect a malicious server silently dropping sigchain link posts.

func MobilePermissionDeniedCheck

func MobilePermissionDeniedCheck(g *GlobalContext, err error, msg string)

MobilePermissionDeniedCheck panics if err is a permission denied error and if app is a mobile app. This has caused issues opening config.json and secretkeys files, where it seems to be stuck in a permission denied state and force-killing the app is the only option.

func NameCmp

func NameCmp(n1, n2 string) bool

NameCmp removes whitespace and underscores, compares tolower.

func NameTrim

func NameTrim(s string) string

func NewAPIEngines

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

func NewChainLinkBadUnstubError

func NewChainLinkBadUnstubError(s string) error

func NewChainLinkWrongSeqnoError

func NewChainLinkWrongSeqnoError(s string) error

func NewDeviceID

func NewDeviceID() (keybase1.DeviceID, error)

func NewFeatureFlagError

func NewFeatureFlagError(s string, f Feature) error

func NewIdentify3GUIID

func NewIdentify3GUIID() (keybase1.Identify3GUIID, error)

func NewInvalidPVLSelectorError

func NewInvalidPVLSelectorError(selector keybase1.SelectorEntry) error

func NewLoginRequiredError

func NewLoginRequiredError(s string) error

func NewLoopbackConnPair

func NewLoopbackConnPair() (*LoopbackConn, *LoopbackConn)

NewLoopbackConnPair makes a new loopback connection pair

func NewNoTriplesecError

func NewNoTriplesecError() error

func NewNotFoundError

func NewNotFoundError(s string) error

func NewOfflineError

func NewOfflineError() error

func NewPaperKeyError

func NewPaperKeyError(s string, t bool) error

func NewPerUserKeyBox

func NewPerUserKeyBox(contents PerUserKeySeed, receiverKey NaclDHKeyPair, senderKey NaclDHKeyPair, generation keybase1.PerUserKeyGeneration) (keybase1.PerUserKeyBox, error)

func NewPushSecretWithoutPasswordError

func NewPushSecretWithoutPasswordError(msg string) error

func NewRecipientNotFoundError

func NewRecipientNotFoundError(message string) error

func NewResetMissingParamsError

func NewResetMissingParamsError(msg string) error

func NewTeamProvisionalError

func NewTeamProvisionalError(canKey bool, isPublic bool, dn string) error

func NewTransportFromSocket

func NewTransportFromSocket(g *GlobalContext, s net.Conn, src keybase1.NetworkSource) rpc.Transporter
func NewTypedChainLink(cl *ChainLink) (ret TypedChainLink, w Warning)

func NewUserReverifyNeededError

func NewUserReverifyNeededError(s string) error

func NewWotProof

func NewWotProof(proofType keybase1.ProofType, key, value string) (res keybase1.WotProof, err error)

Format a proof for web-of-trust. Does not support all proof types.

func NewWotProofUI

func NewWotProofUI(mctx MetaContext, proof keybase1.WotProof) (res keybase1.WotProofUI, err error)

Format a web-of-trust proof for gui display.

func NoiseXOR

func NoiseXOR(secret [32]byte, noise NoiseBytes) ([]byte, error)

func NormalizeSocialAssertion

func NormalizeSocialAssertion(ctx AssertionContext, s string) (keybase1.SocialAssertion, bool)

NormalizeSocialAssertion creates a SocialAssertion from its input and normalizes it. The service name will be lowercased. If the service is case-insensitive, then the username will also be lowercased. Colon assertions (twitter:user) will be transformed to the user@twitter format.

func OSVersionAndBuild

func OSVersionAndBuild() (string, string, error)

OSVersionAndBuild returns OS version, and build too on some platforms

func Once

func Once(f func()) func()

func OpenSig

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

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

func OpenTempFile

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

OpenTempFile creates an opened termporary file. Use mode=0 for default permissions.

OpenTempFile("foo", ".zip", 0755) => "foo.RCG2KUSCGYOO3PCKNWQHBOXBKACOPIKL.zip" OpenTempFile(path.Join(os.TempDir(), "foo"), "", 0) => "/tmp/foo.RCG2KUSCGYOO3PCKNWQHBOXBKACOPIKL"

func PGPEncrypt

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

func PGPEncryptString

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

func PGPKeyRawToArmored

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

func PGPLookup

func PGPLookup(mctx MetaContext, id uint64) (username string, uid keybase1.UID, err error)

func PGPLookupFingerprint

func PGPLookupFingerprint(mctx MetaContext, fp *PGPFingerprint) (username string, uid keybase1.UID, err error)

func PGPLookupHex

func PGPLookupHex(mctx MetaContext, hexID string) (username string, uid keybase1.UID, err error)

func ParseCA

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

func ParseGenericKey

func ParseGenericKey(bundle string) (GenericKey, *Warnings, error)

func ParseGpgIndexStream

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

func ParseImplicitTeamDisplayName

func ParseImplicitTeamDisplayName(ctx AssertionContext, s string, isPublic bool) (ret keybase1.ImplicitTeamDisplayName, err error)

Parse a name like "mlsteele,malgorithms@twitter#bot (conflicted copy 2017-03-04 #2)"

func ParseImplicitTeamDisplayNameSuffix

func ParseImplicitTeamDisplayNameSuffix(suffix string) (ret *keybase1.ImplicitTeamConflictInfo, err error)

func ParseImplicitTeamTLFName

func ParseImplicitTeamTLFName(ctx AssertionContext, s string) (keybase1.ImplicitTeamDisplayName, error)

Parse a name like "/keybase/private/mlsteele,malgorithms@twitter#bot (conflicted copy 2017-03-04 #2)"

func ParseStellarAccountID

func ParseStellarAccountID(idStr string) (stellar1.AccountID, error)

ParseStellarAccountID parses an account ID and returns it. Returns helpful error messages than can be shown to users.

func ParseStellarAssetCode

func ParseStellarAssetCode(codeStr string) (res stellar1.AssetCode, err error)

func ParseStellarSecretKey

func ParseStellarSecretKey(secStr string) (stellar1.SecretKey, stellar1.AccountID, *keypair.Full, error)

ParseStellarSecretKey parses a secret key and returns it and the AccountID it is the master key of. Returns helpful error messages than can be shown to users.

func ParseTeamPrivateKBFSPath

func ParseTeamPrivateKBFSPath(s string) (ret keybase1.TeamName, err error)

Parse a name like "/keybase/team/happy.toucans"

func PassphraseLoginNoPrompt

func PassphraseLoginNoPrompt(m MetaContext, usernameOrEmail string, passphrase string) (err error)

func PassphraseLoginNoPromptThenSecretStore

func PassphraseLoginNoPromptThenSecretStore(m MetaContext, usernameOrEmail string, passphrase string, failOnStoreError bool) (err error)

func PassphraseLoginPrompt

func PassphraseLoginPrompt(m MetaContext, usernameOrEmail string, maxAttempts int) (err error)

func PassphraseLoginPromptThenSecretStore

func PassphraseLoginPromptThenSecretStore(m MetaContext, usernameOrEmail string, maxAttempts int, failOnStoreError bool) (err error)

func PassphraseLoginPromptWithArg

func PassphraseLoginPromptWithArg(m MetaContext, maxAttempts int, arg keybase1.GUIEntryArg) (err error)

func PickFirstError

func PickFirstError(errors ...error) error

func PlatformSpecificUpgradeInstructions

func PlatformSpecificUpgradeInstructions(g *GlobalContext, upgradeURI string)

func PlatformSpecificUpgradeInstructionsString

func PlatformSpecificUpgradeInstructionsString() (string, error)

func Pluralize

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

Pluralize returns pluralized string with value. For example,

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

func PosixLineEndings

func PosixLineEndings(arg string) string

func PostDeviceLKS

func PostDeviceLKS(m MetaContext, deviceID keybase1.DeviceID, deviceType keybase1.DeviceTypeV2, serverHalf LKSecServerHalf,
	ppGen PassphraseGeneration,
	clientHalfRecovery string, clientHalfRecoveryKID keybase1.KID) error

func PostInviteRequest

func PostInviteRequest(m MetaContext, arg InviteRequestArg) (err error)

func PrefixString

func PrefixString(typ ObjType) string

func PrimeSecretStore

func PrimeSecretStore(mctx MetaContext, ss SecretStoreAll) (err error)

PrimeSecretStore runs a test with current platform's secret store, trying to store, retrieve, and then delete a secret with an arbitrary name. This should be done before provisioning or logging in

func ProofErrorIsPvlBad

func ProofErrorIsPvlBad(pe ProofError) bool

func ProofErrorIsSoft

func ProofErrorIsSoft(pe ProofError) bool

func ProofErrorToState

func ProofErrorToState(pe ProofError) keybase1.ProofState

func ProofIconKey

func ProofIconKey(mctx MetaContext, proofType keybase1.ProofType, genericKeyAndFallback string) (iconKey string)

func ProofUserAgent

func ProofUserAgent() string

Returns a simplified UserAgent that's used as the kb_ua GET param.

func ProxyDial

func ProxyDial(env *Env, network string, address string) (net.Conn, error)

The equivalent of net.Dial except it uses the proxy configured in Env

func ProxyDialTimeout

func ProxyDialTimeout(env *Env, network string, address string, timeout time.Duration) (net.Conn, error)

The equivalent of net.DialTimeout except it uses the proxy configured in Env

func ProxyDialWithOpts

func ProxyDialWithOpts(ctx context.Context, env *Env, network string, address string, opts *ProxyDialOpts) (net.Conn, error)

func ProxyHTTPGet

func ProxyHTTPGet(g *GlobalContext, env *Env, u, instrumentationTag string) (*http.Response, error)

The equivalent of http.Get except it uses the proxy configured in Env `instrumentationTag` should be a static tag for all requests identifying the type of request we are proxying so we don't leak URL information to the instrumenter.

func RandBytes

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

func RandBytesWithSuffix

func RandBytesWithSuffix(length int, suffix byte) ([]byte, error)

func RandHexString

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

func RandInt

func RandInt() (int, error)

func RandInt64

func RandInt64() (int64, error)

func RandIntn

func RandIntn(n int) int

func RandString

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

RandString returns random (base32) string with prefix.

func RandStringB64

func RandStringB64(numTriads int) string

func RandomHmacKey

func RandomHmacKey() [32]byte

func RandomJitter

func RandomJitter(d time.Duration) time.Duration

RandomJitter takes a duration of d, and output a duration uniformly and randomly distributed in [.5d, 1.5d].

func RandomNaclDHNonce

func RandomNaclDHNonce() (nonce [NaclDHNonceSize]byte, err error)

func ReadOneKeyFromBytes

func ReadOneKeyFromBytes(b []byte) (*PGPKeyBundle, *Warnings, error)

func ReadOneKeyFromString

func ReadOneKeyFromString(originalArmor string) (*PGPKeyBundle, *Warnings, error)

note: openpgp.ReadArmoredKeyRing only returns the first block. It will never return multiple entities.

func ReadOneKeyFromStringLiberal

func ReadOneKeyFromStringLiberal(originalArmor string) (*PGPKeyBundle, *Warnings, error)

note: openpgp.ReadArmoredKeyRing only returns the first block. It will never return multiple entities.

func ReadPrivateKeyFromString

func ReadPrivateKeyFromString(s string) (*PGPKeyBundle, *Warnings, error)

ReadPrivateKeyFromString finds the first private key block in s and decodes it into a PGPKeyBundle. It is useful in the case where s contains multiple key blocks and you want the private key block. For example, the result of gpg export.

func RecordLoginTime

func RecordLoginTime(mctx MetaContext, username NormalizedUsername) (err error)

func RemoveEnvironmentFeatureForTest

func RemoveEnvironmentFeatureForTest(tp *TestParameters, feature Feature)

func RemoveLocalTracks

func RemoveLocalTracks(m MetaContext, tracker keybase1.UID, trackee keybase1.UID) error

func RemoveNilErrors

func RemoveNilErrors(errs []error) []error

RemoveNilErrors returns error slice with ni errors removed.

func ReplaceSecretStoreForTests

func ReplaceSecretStoreForTests(tc TestContext, dataDir string)

func RequestDowngradeLeaseByKID

func RequestDowngradeLeaseByKID(ctx context.Context, g *GlobalContext, kids []keybase1.KID) (lease *Lease, mr *MerkleRoot, err error)

func RequestDowngradeLeaseBySigIDs

func RequestDowngradeLeaseBySigIDs(ctx context.Context, g *GlobalContext, sigIDs []keybase1.SigID) (lease *Lease, mr *MerkleRoot, err error)

func RequestDowngradeLeaseByTeam

func RequestDowngradeLeaseByTeam(ctx context.Context, g *GlobalContext, teamID keybase1.TeamID, uids []keybase1.UID) (lease *Lease, mr *MerkleRoot, err error)

func ResetAccount

func ResetAccount(mctx MetaContext, username NormalizedUsername, passphrase string) (err error)

func RunBug3964Repairman

func RunBug3964Repairman(m MetaContext) error

func RunSyncer

func RunSyncer(m MetaContext, s Syncer, uid keybase1.UID, loggedIn bool, forceReload bool) (err error)

func RunSyncerCached

func RunSyncerCached(m MetaContext, s Syncer, uid keybase1.UID) (err error)

func RuntimeGroup

func RuntimeGroup() keybase1.RuntimeGroup

func SafeWriteToFile

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

SafeWriteToFile is a pass-through to safeWriteToFileOnce on non-Windows.

func SaferDLLLoading

func SaferDLLLoading() error

SaferDLLLoading dummy for platforms not needing this.

func SaltpackDecrypt

func SaltpackDecrypt(m MetaContext, source io.Reader, sink io.WriteCloser,
	decryptionKeyring saltpack.SigncryptKeyring,
	checkSenderMki func(*saltpack.MessageKeyInfo) error,
	checkSenderSigningKey func(saltpack.SigningPublicKey) error,
	keyResolver saltpack.SymmetricKeyResolver) (mki *saltpack.MessageKeyInfo, err error)

func SaltpackEncrypt

func SaltpackEncrypt(m MetaContext, arg *SaltpackEncryptArg) error

SaltpackEncrypt reads from the given source, encrypts it for the given receivers from the given sender, and writes it to sink. If Binary is false, the data written to sink will be armored.

func SaltpackSign

func SaltpackSign(g *GlobalContext, source io.ReadCloser, sink io.WriteCloser, key NaclSigningKeyPair, binary bool, saltpackVersion saltpack.Version) error

func SaltpackSignDetached

func SaltpackSignDetached(g *GlobalContext, source io.ReadCloser, sink io.WriteCloser, key NaclSigningKeyPair, binary bool, saltpackVersion saltpack.Version) error

func SaltpackVerify

func SaltpackVerify(g SaltpackVerifyContext, source io.Reader, sink io.WriteCloser, checkSender func(saltpack.SigningPublicKey) error) (err error)

func SaltpackVerifyDetached

func SaltpackVerifyDetached(g SaltpackVerifyContext, message io.Reader, signature []byte, checkSender func(saltpack.SigningPublicKey) error) (err error)

func SaltpackVersionFromArg

func SaltpackVersionFromArg(saltpackVersionArg int) (saltpack.Version, error)

func SecWord

func SecWord(n int) string

SecWord returns the n'th word from the BIP-0039 list, mod the size of the list.

func SecWordList

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

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

func SecureByteArrayEq

func SecureByteArrayEq(a, b []byte) bool

func ServerLookup

func ServerLookup(env *Env, mode RunMode) (string, error)

func SetContactSettings

func SetContactSettings(mctx MetaContext, arg keybase1.ContactSettings) (err error)

func SetDeviceCloneState

func SetDeviceCloneState(m MetaContext, d DeviceCloneState) error

func SetDisableBackup

func SetDisableBackup(mctx MetaContext, name string) error

func ShortCA

func ShortCA(raw string) string

func ShredFile

func ShredFile(filename string) error

func SigAssertKbPayload

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

func SigAssertPGPPayload

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

func SigAssertPayload

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

func SigExtractKbPayloadAndKID

func SigExtractKbPayloadAndKID(armored string) (payload []byte, kid keybase1.KID, sigID keybase1.SigIDBase, err error)

func SigExtractPGPPayload

func SigExtractPGPPayload(armored string) (payload []byte, sigID keybase1.SigIDBase, err error)

func SigExtractPayloadAndKID

func SigExtractPayloadAndKID(armored string) (payload []byte, kid keybase1.KID, sigID keybase1.SigIDBase, err error)

SigExtractPayloadAndKID extracts the payload and KID of the key that was supposedly used to sign this message. A KID will only be returned for KB messages, and not for PGP messages

func SigningPublicKeyToKeybaseKID

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

func SimpleSign

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

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

func Sleep

func Sleep(ctx context.Context, duration time.Duration) error

func SleepUntilWithContext

func SleepUntilWithContext(ctx context.Context, clock clockwork.Clock, deadline time.Time) error

Sleep until `deadline` or until `ctx` is canceled, whichever occurs first. Returns an error BUT the error is not really an error. It is nil if the sleep finished, and the non-nil result of Context.Err()

func SplitByRunes

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

SplitByRunes splits string by runes

func SplitHost

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

func SplitPath

func SplitPath(s string) []string

SplitPath return string split by path separator: SplitPath("/a/b/c") => []string{"a", "b", "c"}

func StatSKBKeyringMTime

func StatSKBKeyringMTime(un NormalizedUsername, g *GlobalContext) (mtime time.Time, err error)

func StellarSimplifyAmount

func StellarSimplifyAmount(amount string) string

SimplifyAmount Amount must be a decimal amount like "1.0" or "50" Strip trailing zeros after a "." Example: "1.0010000" -> "1.001" Example: "1.0000000" -> "1"

func StoreLocalTrack

func StoreLocalTrack(m MetaContext, tracker keybase1.UID, trackee keybase1.UID, expiringLocal bool, statement *jsonw.Wrapper) error

func StorePwhashEddsaPassphraseStream

func StorePwhashEddsaPassphraseStream(mctx MetaContext, username NormalizedUsername, pps *PassphraseStream) (err error)

func StoreSecretAfterLoginWithLKSWithOptions

func StoreSecretAfterLoginWithLKSWithOptions(m MetaContext, n NormalizedUsername, lks *LKSec, options *SecretStoreOptions) (err error)

func StoreSecretAfterLoginWithOptions

func StoreSecretAfterLoginWithOptions(m MetaContext, n NormalizedUsername, uid keybase1.UID, deviceID keybase1.DeviceID, options *SecretStoreOptions) (err error)

func StretchPassphrase

func StretchPassphrase(g *GlobalContext, passphrase string, salt []byte) (tsec Triplesec, pps *PassphraseStream, err error)

func Tablify

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

func TablifyWithTabWriter

func TablifyWithTabWriter(w *tabwriter.Writer, headings []string, rowfunc func() []string)

func TempFile

func TempFile(prefix string) (string, error)

TempFile returns a random path name in os.TempDir()

func TempFileName

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

TempFileName returns a temporary random filename

func ThrottleBatch

func ThrottleBatch(f func(interface{}), batcher func(interface{}, interface{}) interface{},
	reset func() interface{}, delay time.Duration, leadingFire bool) (func(interface{}), func())

func TimeLog

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

TimeLog calls out with the time since start. Use like this:

defer TimeLog("MyFunc", time.Now(), e.G().Log.Warning)

func TorParseProxy

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

func Trace

func Trace(log logger.Logger, msg string, err *error) func()

func TrimCicmp

func TrimCicmp(s1, s2 string) bool

func UIDFromHex

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

func UIDWrapper

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

func UidsToString

func UidsToString(uids []keybase1.UID) string

func Uniquify

func Uniquify(inp []string) []string

func UnixToTimeMappingZero

func UnixToTimeMappingZero(unixTime int64) time.Time

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

func Unquote

func Unquote(data []byte) string

func UnverifiedPassphraseStream

func UnverifiedPassphraseStream(m MetaContext, uid keybase1.UID, passphrase string) (tsec Triplesec, ret *PassphraseStream, err error)

UnverifiedPassphraseStream takes a passphrase as a parameter and also the salt from the Account and computes a Triplesec and a passphrase stream. It's not verified through a Login.

func UpdateDeviceCloneState

func UpdateDeviceCloneState(m MetaContext) (before, after int, err error)

func UseCITime

func UseCITime(g *GlobalContext) bool

func UserCard

func UserCard(m MetaContext, uid keybase1.UID, useSession bool) (ret *keybase1.UserCard, err error)

func UserErrorFromStatus

func UserErrorFromStatus(s keybase1.StatusCode) error

func UsernameToUID

func UsernameToUID(s string) keybase1.UID

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

func VID

func VID(mctx MetaContext, uid keybase1.UID) (ret keybase1.VID)

VID gets the VID that corresponds to the given UID. A VID is a pseudonymous UID. Should never error.

func ValidSecWord

func ValidSecWord(w string) bool

func VerifyMerkleRootAndKBFS

func VerifyMerkleRootAndKBFS(m MetaContext, arg keybase1.VerifyMerkleRootAndKBFSArg) (err error)

func VerifyReverseSig

func VerifyReverseSig(g *GlobalContext, key GenericKey, path string, payload *jsonw.Wrapper, reverseSig string) (err error)

VerifyReverseSig checks reverse signature using the key provided. does not modify `payload`. `path` is the path to the reverse sig spot to null before checking.

func VersionMessage

func VersionMessage(linefn func(string))

func VersionString

func VersionString() string

VersionString returns semantic version string

func WhitespaceNormalize

func WhitespaceNormalize(s string) string

func WithLogTag

func WithLogTag(ctx context.Context, k string) context.Context

func WithLogTagWithValue

func WithLogTagWithValue(ctx context.Context, k, v string) context.Context

func WrapError

func WrapError(e error) interface{}

func XORBytes

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

Types

type APIArg

type APIArg struct {
	Endpoint string

	Args            HTTPArgs
	JSONPayload     JSONPayload
	SessionType     APISessionType
	HTTPStatus      []int
	AppStatusCodes  []int
	InitialTimeout  time.Duration // optional
	RetryMultiplier float64       // optional
	RetryCount      int           // optional
	UseText         bool
	// contains filtered or unexported fields
}

func NewAPIArg

func NewAPIArg(endpoint string) APIArg

NewAPIArg creates a standard APIArg that will result in one API request with the default timeout.

func NewRetryAPIArg

func NewRetryAPIArg(endpoint string) APIArg

NewRetryAPIArg creates an APIArg that will cause the http client to use a much smaller request timeout, but retry the request several times, backing off on the timeout each time.

type APIArgRecorder

type APIArgRecorder struct {
	API
	Records []APIRecord
}

APIArgRecorder forwards all its calls to the underlying API, but records all the inputs and outputs to be used in tests.

func NewAPIArgRecorder

func NewAPIArgRecorder(inner API) *APIArgRecorder

func NewAPIArgRecorderWithNullAPI

func NewAPIArgRecorderWithNullAPI() *APIArgRecorder

func (*APIArgRecorder) Delete

func (a *APIArgRecorder) Delete(mctx MetaContext, arg APIArg) (*APIRes, error)

func (*APIArgRecorder) Get

func (a *APIArgRecorder) Get(mctx MetaContext, arg APIArg) (*APIRes, error)

func (*APIArgRecorder) GetDecode

func (a *APIArgRecorder) GetDecode(mctx MetaContext, arg APIArg, arw APIResponseWrapper) error

func (*APIArgRecorder) GetDecodeCtx

func (a *APIArgRecorder) GetDecodeCtx(ctx context.Context, arg APIArg, arw APIResponseWrapper) error

func (*APIArgRecorder) GetFilteredRecordsAndReset

func (a *APIArgRecorder) GetFilteredRecordsAndReset(filter func(*APIRecord) bool) (filtered []APIRecord)

func (*APIArgRecorder) GetResp

func (a *APIArgRecorder) GetResp(mctx MetaContext, arg APIArg) (*http.Response, func(), error)

func (*APIArgRecorder) NumCalls

func (a *APIArgRecorder) NumCalls() int

func (*APIArgRecorder) Post

func (a *APIArgRecorder) Post(mctx MetaContext, arg APIArg) (*APIRes, error)

func (*APIArgRecorder) PostDecode

func (a *APIArgRecorder) PostDecode(mctx MetaContext, arg APIArg, arw APIResponseWrapper) error

func (*APIArgRecorder) PostDecodeCtx

func (a *APIArgRecorder) PostDecodeCtx(ctx context.Context, arg APIArg, arw APIResponseWrapper) error

func (*APIArgRecorder) PostJSON

func (a *APIArgRecorder) PostJSON(mctx MetaContext, arg APIArg) (*APIRes, error)

func (*APIArgRecorder) PostRaw

func (a *APIArgRecorder) PostRaw(mctx MetaContext, arg APIArg, s string, r io.Reader) (*APIRes, error)

func (*APIArgRecorder) Reset

func (a *APIArgRecorder) Reset()

type APIContext

type APIContext interface {
	GetAPI() API
	GetExternalAPI() ExternalAPI
	GetServerURI() (string, error)
}

APIContext defines methods for accessing API server

type APIError

type APIError struct {
	Msg  string
	Code int
}

func NewAPIErrorFromHTTPResponse

func NewAPIErrorFromHTTPResponse(r *http.Response) *APIError

func (*APIError) Error

func (a *APIError) Error() string

func (*APIError) ToStatus

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

type APIHeader

type APIHeader struct {
	Key   string
	Value string
}

type APIMethodType

type APIMethodType int
const (
	MethodGet APIMethodType = iota
	MethodGetDecode
	MethodGetDecodeCtx
	MethodGetResp
	MethodPost
	MethodPostJSON
	MethodPostDecode
	MethodPostDecodeCtx
	MethodPostRaw
	MethodDelete
)

type APINetError

type APINetError struct {
	Err error
}

func (APINetError) Error

func (e APINetError) Error() string

func (APINetError) ToStatus

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

type APIRecord

type APIRecord struct {
	Arg    APIArg
	Method APIMethodType
	// various inputs and outputs of the API interface methods.
	Res         *APIRes
	RespWrapper APIResponseWrapper
	HTTPResp    *http.Response
	Func        func()
	S           string
	R           io.Reader
	Err         error
}

func FilterAPIRecords

func FilterAPIRecords(recs []APIRecord, filter func(*APIRecord) bool) (filtered []APIRecord)

FilterAPIRecords returns only the records on which the filter function outputs true

type APIRes

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

type APIResponseWrapper

type APIResponseWrapper interface {
	GetAppStatus() *AppStatus
}

type APIRouter

type APIRouter struct {
	APIs   []API
	Filter func(arg APIArg, method APIMethodType) int
}

APIRouter forwards each API call to one of the underlying API implementations depending on an internal filter function passed to its constructor. Be careful that the filter always returns a value in bound for the api array. This is meant to be used in tests to mock some but not all api calls.

func NewAPIRouter

func NewAPIRouter(apis []API, filter func(arg APIArg, method APIMethodType) int) *APIRouter

func (*APIRouter) Delete

func (a *APIRouter) Delete(mctx MetaContext, arg APIArg) (*APIRes, error)

func (*APIRouter) Get

func (a *APIRouter) Get(mctx MetaContext, arg APIArg) (*APIRes, error)

func (*APIRouter) GetDecode

func (a *APIRouter) GetDecode(mctx MetaContext, arg APIArg, arw APIResponseWrapper) error

func (*APIRouter) GetDecodeCtx

func (a *APIRouter) GetDecodeCtx(ctx context.Context, arg APIArg, arw APIResponseWrapper) error

func (*APIRouter) GetResp

func (a *APIRouter) GetResp(mctx MetaContext, arg APIArg) (*http.Response, func(), error)

func (*APIRouter) Post

func (a *APIRouter) Post(mctx MetaContext, arg APIArg) (*APIRes, error)

func (*APIRouter) PostDecode

func (a *APIRouter) PostDecode(mctx MetaContext, arg APIArg, arw APIResponseWrapper) error

func (*APIRouter) PostDecodeCtx

func (a *APIRouter) PostDecodeCtx(ctx context.Context, arg APIArg, arw APIResponseWrapper) error

func (*APIRouter) PostJSON

func (a *APIRouter) PostJSON(mctx MetaContext, arg APIArg) (*APIRes, error)

func (*APIRouter) PostRaw

func (a *APIRouter) PostRaw(mctx MetaContext, arg APIArg, s string, r io.Reader) (*APIRes, error)

type APISessionType

type APISessionType int
const (
	APISessionTypeNONE     APISessionType = 0
	APISessionTypeOPTIONAL APISessionType = 1
	APISessionTypeREQUIRED APISessionType = 2
)

type APIStatus

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

type APITokener

type APITokener interface {
	Tokens() (session, csrf string)
}

type AccountResetError

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

func (AccountResetError) Error

func (e AccountResetError) Error() string

func (AccountResetError) ToStatus

func (e AccountResetError) ToStatus() keybase1.Status

type ActiveDevice

type ActiveDevice struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func LoadProvisionalActiveDevice

func LoadProvisionalActiveDevice(m MetaContext, uid keybase1.UID, deviceID keybase1.DeviceID, online bool) (ret *ActiveDevice, err error)

func NewActiveDevice

func NewActiveDevice() *ActiveDevice

func NewActiveDeviceWithDeviceWithKeys

func NewActiveDeviceWithDeviceWithKeys(m MetaContext, uv keybase1.UserVersion, d *DeviceWithKeys) *ActiveDevice

func NewProvisionalActiveDevice

func NewProvisionalActiveDevice(m MetaContext, uv keybase1.UserVersion, d keybase1.DeviceID, sigKey GenericKey, encKey GenericKey, deviceName string, keychainMode KeychainMode) *ActiveDevice

NewProvisionalActiveDevice creates an ActiveDevice that is "provisional", in that it should not be considered the global ActiveDevice. Instead, it should reside in thread-local context, and can be weaved through the login machinery without trampling the actual global ActiveDevice.

func NewProvisioningKeyActiveDevice

func NewProvisioningKeyActiveDevice(m MetaContext, uv keybase1.UserVersion, d *DeviceWithKeys) *ActiveDevice

func (*ActiveDevice) AllFields

func (a *ActiveDevice) AllFields() (uv keybase1.UserVersion, deviceID keybase1.DeviceID, deviceName string, sigKey GenericKey, encKey GenericKey)

AllFields returns all the ActiveDevice fields via one lock for consistency. Safe for use by concurrent goroutines.

func (*ActiveDevice) CachePassphraseStream

func (a *ActiveDevice) CachePassphraseStream(c *PassphraseStreamCache)

func (*ActiveDevice) CacheProvisioningKey

func (a *ActiveDevice) CacheProvisioningKey(m MetaContext, k *DeviceWithKeys)

func (*ActiveDevice) CheckForUsername

func (a *ActiveDevice) CheckForUsername(m MetaContext, n NormalizedUsername, suppressNetworkErrors bool) (err error)

func (*ActiveDevice) Clear

func (a *ActiveDevice) Clear() error

func (*ActiveDevice) ClearCaches

func (a *ActiveDevice) ClearCaches()

func (*ActiveDevice) ClearGetKeychainMode

func (a *ActiveDevice) ClearGetKeychainMode() (KeychainMode, error)

func (*ActiveDevice) ClearPassphraseStreamCache

func (a *ActiveDevice) ClearPassphraseStreamCache()

func (*ActiveDevice) ClearPassphraseStreamCacheIfOutdated

func (a *ActiveDevice) ClearPassphraseStreamCacheIfOutdated(mctx MetaContext) error

func (*ActiveDevice) ClearProvisioningKey

func (a *ActiveDevice) ClearProvisioningKey(m MetaContext)

func (*ActiveDevice) Copy

func (a *ActiveDevice) Copy(m MetaContext, src *ActiveDevice) error

Copy ActiveDevice info from the given ActiveDevice.

func (*ActiveDevice) CopyCacheToLoginContextIfForUserVersion

func (a *ActiveDevice) CopyCacheToLoginContextIfForUserVersion(m MetaContext, lc LoginContext, uv keybase1.UserVersion) (err error)

func (*ActiveDevice) Ctime

func (a *ActiveDevice) Ctime(m MetaContext) (keybase1.Time, error)

func (*ActiveDevice) DeviceID

func (a *ActiveDevice) DeviceID() keybase1.DeviceID

DeviceID returns the device ID that was provided when the device keys were cached. Safe for use by concurrent goroutines.

func (*ActiveDevice) DeviceKeys

func (a *ActiveDevice) DeviceKeys() (*DeviceWithKeys, error)

func (*ActiveDevice) DeviceType

func (a *ActiveDevice) DeviceType(mctx MetaContext) (keybase1.DeviceTypeV2, error)

func (*ActiveDevice) Dump

func (a *ActiveDevice) Dump(m MetaContext, prefix string)

func (*ActiveDevice) EncryptionKey

func (a *ActiveDevice) EncryptionKey() (GenericKey, error)

EncryptionKey returns the encryption key for the active device. Safe for use by concurrent goroutines.

func (*ActiveDevice) EncryptionKeyWithUID

func (a *ActiveDevice) EncryptionKeyWithUID(uid keybase1.UID) (GenericKey, error)

EncryptionKeyWithUID returns the encryption key for the active device. Returns an error if uid is not active. Safe for use by concurrent goroutines.

func (*ActiveDevice) GetUsernameAndUserVersionIfValid

func (a *ActiveDevice) GetUsernameAndUserVersionIfValid(m MetaContext) (uv keybase1.UserVersion, un NormalizedUsername)

func (*ActiveDevice) HaveKeys

func (a *ActiveDevice) HaveKeys() bool

func (*ActiveDevice) IsValidFor

func (a *ActiveDevice) IsValidFor(uid keybase1.UID, deviceID keybase1.DeviceID) bool

func (*ActiveDevice) KeyByType

func (a *ActiveDevice) KeyByType(t SecretKeyType) (GenericKey, error)

KeyByType returns a cached key based on SecretKeyType. Safe for use by concurrent goroutines.

func (*ActiveDevice) KeyByTypeWithUID

func (a *ActiveDevice) KeyByTypeWithUID(uid keybase1.UID, t SecretKeyType) (GenericKey, error)

KeyByTypeWithUID is like KeyByType but returns an error if uid is not active. Safe for use by concurrent goroutines.

func (*ActiveDevice) KeychainMode

func (a *ActiveDevice) KeychainMode() KeychainMode

func (*ActiveDevice) Keyring

func (a *ActiveDevice) Keyring(m MetaContext) (ret *SKBKeyringFile, err error)

func (*ActiveDevice) NIST

func (a *ActiveDevice) NIST(ctx context.Context) (*NIST, error)

func (*ActiveDevice) NISTAndUIDDeviceID

func (a *ActiveDevice) NISTAndUIDDeviceID(ctx context.Context) (*NIST, keybase1.UID, keybase1.DeviceID, error)

func (*ActiveDevice) NISTWebAuthToken

func (a *ActiveDevice) NISTWebAuthToken(ctx context.Context) (*NIST, error)

func (*ActiveDevice) NaclEncryptionKey

func (a *ActiveDevice) NaclEncryptionKey() (*NaclDHKeyPair, error)

NaclEncryptionKey returns the encryption key for the active device, as a NaclDHKeyPair. If the cast fails (though that should never happen), it returns an error.

func (*ActiveDevice) Name

func (a *ActiveDevice) Name() string

func (*ActiveDevice) PassphraseStream

func (a *ActiveDevice) PassphraseStream() *PassphraseStream

func (*ActiveDevice) PassphraseStreamCache

func (a *ActiveDevice) PassphraseStreamCache() *PassphraseStreamCache

func (*ActiveDevice) ProvisioningKey

func (a *ActiveDevice) ProvisioningKey(m MetaContext) *DeviceWithKeys

func (*ActiveDevice) ProvisioningKeyWrapper

func (a *ActiveDevice) ProvisioningKeyWrapper(m MetaContext) *SelfDestructingDeviceWithKeys

func (*ActiveDevice) SecretPromptCancelTimer

func (a *ActiveDevice) SecretPromptCancelTimer() *CancelTimer

func (*ActiveDevice) Set

func (a *ActiveDevice) Set(m MetaContext, uv keybase1.UserVersion, deviceID keybase1.DeviceID,
	sigKey, encKey GenericKey, deviceName string, deviceCtime keybase1.Time, keychainMode KeychainMode) error

Set acquires the write lock and sets all the fields in ActiveDevice. The acct parameter is not used for anything except to help ensure that this is called from inside a LoginState account request.

func (*ActiveDevice) SetOrClear

func (a *ActiveDevice) SetOrClear(m MetaContext, a2 *ActiveDevice) error

func (*ActiveDevice) SigningKey

func (a *ActiveDevice) SigningKey() (GenericKey, error)

SigningKey returns the signing key for the active device. Safe for use by concurrent goroutines.

func (*ActiveDevice) SigningKeyForUID

func (a *ActiveDevice) SigningKeyForUID(u keybase1.UID) GenericKey

func (*ActiveDevice) SigningKeyWithUID

func (a *ActiveDevice) SigningKeyWithUID(uid keybase1.UID) (GenericKey, error)

SigningKeyWithUID returns the signing key for the active device. Returns an error if uid is not active. Safe for use by concurrent goroutines.

func (*ActiveDevice) SyncSecrets

func (a *ActiveDevice) SyncSecrets(m MetaContext) (ret *SecretSyncer, err error)

func (*ActiveDevice) SyncSecretsForUID

func (a *ActiveDevice) SyncSecretsForUID(m MetaContext, u keybase1.UID, force bool) (ret *SecretSyncer, err error)

func (*ActiveDevice) SyncSecretsForce

func (a *ActiveDevice) SyncSecretsForce(m MetaContext) (ret *SecretSyncer, err error)

func (*ActiveDevice) TriplesecAndGeneration

func (a *ActiveDevice) TriplesecAndGeneration() (Triplesec, PassphraseGeneration)

func (*ActiveDevice) UID

func (a *ActiveDevice) UID() keybase1.UID

UID returns the user ID that was provided when the device keys were cached. Safe for use by concurrent goroutines.

func (*ActiveDevice) UIDAndEncryptionKey

func (a *ActiveDevice) UIDAndEncryptionKey() (keybase1.UID, GenericKey)

func (*ActiveDevice) UserVersion

func (a *ActiveDevice) UserVersion() keybase1.UserVersion

func (*ActiveDevice) Username

Username tries to get the active user's username by looking into the current environment and mapping an UID to a username based on our config file. It won't work halfway through a provisioning.

func (*ActiveDevice) Valid

func (a *ActiveDevice) Valid() bool

type AggSigProducer

type AggSigProducer func() (JSONPayload, keybase1.Seqno, LinkID, error)

DelegatorAggregator manages delegating multiple keys in one post to the server When run produces a map which goes into the 'key/multi' 'sigs' list.

type AlreadyRegisteredError

type AlreadyRegisteredError struct {
	UID keybase1.UID
}

func (AlreadyRegisteredError) Error

func (u AlreadyRegisteredError) Error() string

type AppConfig

type AppConfig struct {
	NullConfiguration
	DownloadsDir                   string
	HomeDir                        string
	MobileSharedHomeDir            string
	LogFile                        string
	EKLogFile                      string
	PerfLogFile                    string
	GUILogFile                     string
	UseDefaultLogFile              bool
	RunMode                        RunMode
	Debug                          bool
	LocalRPCDebug                  string
	ServerURI                      string
	VDebugSetting                  string
	SecurityAccessGroupOverride    bool
	ChatInboxSourceLocalizeThreads int
	MobileExtension                bool
	AttachmentHTTPStartPort        int
	AttachmentDisableMulti         bool
	LinkCacheSize                  int
	UPAKCacheSize                  int
	PayloadCacheSize               int
	ProofCacheSize                 int
	DisableTeamAuditor             bool
	DisableMerkleAuditor           bool
	DisableTeamBoxAuditor          bool
	DisableEKBackgroundKeygen      bool
	LevelDBWriteBufferMB           int
	LevelDBNumFiles                int
}

func (AppConfig) GetAppType

func (c AppConfig) GetAppType() AppType

func (AppConfig) GetAttachmentDisableMulti

func (c AppConfig) GetAttachmentDisableMulti() (bool, bool)

func (AppConfig) GetAttachmentHTTPStartPort

func (c AppConfig) GetAttachmentHTTPStartPort() (int, bool)

func (AppConfig) GetChatInboxSourceLocalizeThreads

func (c AppConfig) GetChatInboxSourceLocalizeThreads() (int, bool)

func (AppConfig) GetDebug

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

func (AppConfig) GetDisableEKBackgroundKeygen

func (c AppConfig) GetDisableEKBackgroundKeygen() (bool, bool)

func (AppConfig) GetDisableMerkleAuditor

func (c AppConfig) GetDisableMerkleAuditor() (bool, bool)

func (AppConfig) GetDisableTeamAuditor

func (c AppConfig) GetDisableTeamAuditor() (bool, bool)

func (AppConfig) GetDisableTeamBoxAuditor

func (c AppConfig) GetDisableTeamBoxAuditor() (bool, bool)

func (AppConfig) GetDownloadsDir

func (c AppConfig) GetDownloadsDir() string

func (AppConfig) GetEKLogFile

func (c AppConfig) GetEKLogFile() string

func (AppConfig) GetGUILogFile

func (c AppConfig) GetGUILogFile() string

func (AppConfig) GetHome

func (c AppConfig) GetHome() string

func (AppConfig) GetLevelDBNumFiles

func (c AppConfig) GetLevelDBNumFiles() (int, bool)

func (AppConfig) GetLevelDBWriteBufferMB

func (c AppConfig) GetLevelDBWriteBufferMB() (int, bool)

func (AppConfig) GetLinkCacheSize

func (c AppConfig) GetLinkCacheSize() (int, bool)

func (AppConfig) GetLocalRPCDebug

func (c AppConfig) GetLocalRPCDebug() string

func (AppConfig) GetLogFile

func (c AppConfig) GetLogFile() string

func (AppConfig) GetMobileSharedHome

func (c AppConfig) GetMobileSharedHome() string

func (AppConfig) GetPayloadCacheSize

func (c AppConfig) GetPayloadCacheSize() (int, bool)

func (AppConfig) GetPerfLogFile

func (c AppConfig) GetPerfLogFile() string

func (AppConfig) GetProofCacheSize

func (c AppConfig) GetProofCacheSize() (int, bool)

func (AppConfig) GetReadDeletedSigChain

func (c AppConfig) GetReadDeletedSigChain() (bool, bool)

func (AppConfig) GetRunMode

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

func (AppConfig) GetSecurityAccessGroupOverride

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

func (AppConfig) GetServerURI

func (c AppConfig) GetServerURI() (string, error)

func (AppConfig) GetSlowGregorConn

func (c AppConfig) GetSlowGregorConn() (bool, bool)

func (AppConfig) GetUPAKCacheSize

func (c AppConfig) GetUPAKCacheSize() (int, bool)

func (AppConfig) GetUseDefaultLogFile

func (c AppConfig) GetUseDefaultLogFile() (bool, bool)

func (AppConfig) GetVDebugSetting

func (c AppConfig) GetVDebugSetting() string

func (AppConfig) IsMobileExtension

func (c AppConfig) IsMobileExtension() (bool, bool)

type AppOutdatedError

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

AppOutdatedError indicates that an operation failed because the client does not support some necessary feature and needs to be updated.

func NewAppOutdatedError

func NewAppOutdatedError(cause error) AppOutdatedError

func (AppOutdatedError) Error

func (e AppOutdatedError) Error() string

type AppStatus

type AppStatus struct {
	Code   int               `json:"code"`
	Name   string            `json:"name"`
	Desc   string            `json:"desc"`
	Fields map[string]string `json:"fields"`
}

type AppStatusEmbed

type AppStatusEmbed struct {
	Status AppStatus `json:"status"`
}

func (*AppStatusEmbed) GetAppStatus

func (s *AppStatusEmbed) GetAppStatus() *AppStatus

type AppStatusError

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

func NewAppStatusError

func NewAppStatusError(ast *AppStatus) AppStatusError

func (AppStatusError) Error

func (a AppStatusError) Error() string

func (AppStatusError) IsBadField

func (a AppStatusError) IsBadField(s string) bool

func (AppStatusError) ToStatus

func (a AppStatusError) ToStatus() keybase1.Status

func (AppStatusError) WithDesc

func (a AppStatusError) WithDesc(desc string) AppStatusError

type AppType

type AppType string
const (
	MobileAppType  AppType = "mobile"
	DesktopAppType AppType = "desktop"
	NoAppType      AppType = ""
)

func StringToAppType

func StringToAppType(s string) AppType

type ApplyDetailsFn

type ApplyDetailsFn func(i ConnectionID, xp rpc.Transporter, details *keybase1.ClientDetails) bool

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

type ApplyFn

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

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

type AssertionAnd

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

func NewAssertionAnd

func NewAssertionAnd(left, right AssertionExpression) AssertionAnd

func (AssertionAnd) CollectUrls

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

func (AssertionAnd) HasFactor

func (a AssertionAnd) HasFactor(pf Proof) bool

func (AssertionAnd) HasOr

func (a AssertionAnd) HasOr() bool

func (AssertionAnd) Len

func (a AssertionAnd) Len() int

func (AssertionAnd) MatchSet

func (a AssertionAnd) MatchSet(ps ProofSet) bool

func (AssertionAnd) NeedsParens

func (a AssertionAnd) NeedsParens() bool

func (AssertionAnd) String

func (a AssertionAnd) String() string

func (AssertionAnd) ToSocialAssertion

func (a AssertionAnd) ToSocialAssertion() (sa keybase1.SocialAssertion, err error)

type AssertionCheckError

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

func NewAssertionCheckError

func NewAssertionCheckError(s string, a ...interface{}) AssertionCheckError

func (AssertionCheckError) Error

func (e AssertionCheckError) Error() string

type AssertionContext

type AssertionContext interface {
	Ctx() context.Context
	NormalizeSocialName(service string, username string) (string, error)
}

type AssertionDNS

type AssertionDNS struct{ AssertionURLBase }

func (AssertionDNS) CheckAndNormalize

func (a AssertionDNS) CheckAndNormalize(_ AssertionContext) (AssertionURL, error)

func (AssertionDNS) CollectUrls

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

func (AssertionDNS) IsRemote

func (a AssertionDNS) IsRemote() bool

func (AssertionDNS) MatchSet

func (a AssertionDNS) MatchSet(ps ProofSet) bool

func (AssertionDNS) ToLookup

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

func (AssertionDNS) ToSocialAssertion

func (a AssertionDNS) ToSocialAssertion() (sa keybase1.SocialAssertion, err error)

type AssertionEmail

type AssertionEmail struct{ AssertionURLBase }

func (AssertionEmail) CheckAndNormalize

func (a AssertionEmail) CheckAndNormalize(ctx AssertionContext) (AssertionURL, error)

func (AssertionEmail) CollectUrls

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

func (AssertionEmail) IsRemote

func (a AssertionEmail) IsRemote() bool

func (AssertionEmail) IsServerTrust

func (a AssertionEmail) IsServerTrust() bool

func (AssertionEmail) MatchSet

func (a AssertionEmail) MatchSet(ps ProofSet) bool

func (AssertionEmail) String

func (a AssertionEmail) String() string

func (AssertionEmail) ToLookup

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

func (AssertionEmail) ToSocialAssertion

func (a AssertionEmail) ToSocialAssertion() (sa keybase1.SocialAssertion, err error)

type AssertionExpression

type AssertionExpression interface {
	String() string
	MatchSet(ps ProofSet) bool
	HasOr() bool
	NeedsParens() bool
	CollectUrls([]AssertionURL) []AssertionURL
	ToSocialAssertion() (keybase1.SocialAssertion, error)
}

func AssertionParse

func AssertionParse(ctx AssertionContext, s string) (AssertionExpression, error)

func AssertionParseAndOnly

func AssertionParseAndOnly(ctx AssertionContext, s string) (AssertionExpression, error)

func ParseAssertionList

func ParseAssertionList(ctx AssertionContext, assertionsStr string) (res []AssertionExpression, err error)

Parse a string into one or more assertions. Only AND assertions are allowed within each part. like "alice,bob&&bob@twitter"

func ParseAssertionsWithReaders

func ParseAssertionsWithReaders(ctx AssertionContext, assertions string) (writers, readers []AssertionExpression, err error)

Parse an assertion list like "alice,bob&&bob@twitter#char" OR nodes are not allowed (asides from the commas)

type AssertionFingerprint

type AssertionFingerprint struct{ AssertionURLBase }

func (AssertionFingerprint) CheckAndNormalize

func (a AssertionFingerprint) CheckAndNormalize(_ AssertionContext) (AssertionURL, error)

func (AssertionFingerprint) CollectUrls

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

func (AssertionFingerprint) IsFingerprint

func (a AssertionFingerprint) IsFingerprint() bool

func (AssertionFingerprint) MatchProof

func (a AssertionFingerprint) MatchProof(proof Proof) bool

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

func (AssertionFingerprint) MatchSet

func (a AssertionFingerprint) MatchSet(ps ProofSet) bool

func (AssertionFingerprint) ToLookup

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

func (AssertionFingerprint) ToSocialAssertion

func (a AssertionFingerprint) ToSocialAssertion() (sa keybase1.SocialAssertion, err error)

type AssertionHTTP

type AssertionHTTP struct{ AssertionURLBase }

func (AssertionHTTP) CheckAndNormalize

func (a AssertionHTTP) CheckAndNormalize(_ AssertionContext) (AssertionURL, error)

func (AssertionHTTP) CollectUrls

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

func (AssertionHTTP) IsRemote

func (a AssertionHTTP) IsRemote() bool

func (AssertionHTTP) Keys

func (a AssertionHTTP) Keys() []string

func (AssertionHTTP) MatchSet

func (a AssertionHTTP) MatchSet(ps ProofSet) bool

func (AssertionHTTP) ToLookup

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

func (AssertionHTTP) ToSocialAssertion

func (a AssertionHTTP) ToSocialAssertion() (sa keybase1.SocialAssertion, err error)

type AssertionHTTPS

type AssertionHTTPS struct{ AssertionURLBase }

func (AssertionHTTPS) CheckAndNormalize

func (a AssertionHTTPS) CheckAndNormalize(_ AssertionContext) (AssertionURL, error)

func (AssertionHTTPS) CollectUrls

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

func (AssertionHTTPS) IsRemote

func (a AssertionHTTPS) IsRemote() bool

func (AssertionHTTPS) MatchSet

func (a AssertionHTTPS) MatchSet(ps ProofSet) bool

func (AssertionHTTPS) ToLookup

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

func (AssertionHTTPS) ToSocialAssertion

func (a AssertionHTTPS) ToSocialAssertion() (sa keybase1.SocialAssertion, err error)

type AssertionKeybase

type AssertionKeybase struct{ AssertionURLBase }

func NewAssertionKeybaseUsername

func NewAssertionKeybaseUsername(username string) AssertionKeybase

func (AssertionKeybase) CheckAndNormalize

func (a AssertionKeybase) CheckAndNormalize(_ AssertionContext) (AssertionURL, error)

func (AssertionKeybase) CollectUrls

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

func (AssertionKeybase) IsKeybase

func (a AssertionKeybase) IsKeybase() bool

func (AssertionKeybase) MatchSet

func (a AssertionKeybase) MatchSet(ps ProofSet) bool

func (AssertionKeybase) String

func (a AssertionKeybase) String() string

func (AssertionKeybase) ToLookup

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

func (AssertionKeybase) ToSocialAssertion

func (a AssertionKeybase) ToSocialAssertion() (sa keybase1.SocialAssertion, err error)

type AssertionOr

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

func NewAssertionOr

func NewAssertionOr(left, right AssertionExpression, symbol string) AssertionOr

func (AssertionOr) CollectUrls

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

func (AssertionOr) HasOr

func (a AssertionOr) HasOr() bool

func (AssertionOr) MatchSet

func (a AssertionOr) MatchSet(ps ProofSet) bool

func (AssertionOr) NeedsParens

func (a AssertionOr) NeedsParens() bool

func (AssertionOr) String

func (a AssertionOr) String() string

func (AssertionOr) ToSocialAssertion

func (a AssertionOr) ToSocialAssertion() (sa keybase1.SocialAssertion, err error)

type AssertionParseError

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

func NewAssertionParseError

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

func NewAssertionParseErrorWithReason

func NewAssertionParseErrorWithReason(reason AssertionParseErrorReason, s string, a ...interface{}) AssertionParseError

func NewNeedInputError

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

func (AssertionParseError) Error

func (e AssertionParseError) Error() string

func (AssertionParseError) Reason

func (AssertionParseError) ToStatus

func (e AssertionParseError) ToStatus() (ret keybase1.Status)

type AssertionParseErrorReason

type AssertionParseErrorReason int
const (
	AssertionParseErrorReasonGeneric      AssertionParseErrorReason = 0
	AssertionParseErrorReasonUnexpectedOR AssertionParseErrorReason = 1
)

type AssertionPhoneNumber

type AssertionPhoneNumber struct{ AssertionURLBase }

func (AssertionPhoneNumber) CheckAndNormalize

func (a AssertionPhoneNumber) CheckAndNormalize(ctx AssertionContext) (AssertionURL, error)

func (AssertionPhoneNumber) CollectUrls

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

func (AssertionPhoneNumber) IsRemote

func (a AssertionPhoneNumber) IsRemote() bool

func (AssertionPhoneNumber) IsServerTrust

func (a AssertionPhoneNumber) IsServerTrust() bool

func (AssertionPhoneNumber) MatchSet

func (a AssertionPhoneNumber) MatchSet(ps ProofSet) bool

func (AssertionPhoneNumber) ToLookup

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

func (AssertionPhoneNumber) ToSocialAssertion

func (a AssertionPhoneNumber) ToSocialAssertion() (sa keybase1.SocialAssertion, err error)

type AssertionSocial

type AssertionSocial struct{ AssertionURLBase }

func (AssertionSocial) CheckAndNormalize

func (a AssertionSocial) CheckAndNormalize(ctx AssertionContext) (AssertionURL, error)

func (AssertionSocial) CollectUrls

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

func (AssertionSocial) GetValue

func (a AssertionSocial) GetValue() string

func (AssertionSocial) IsRemote

func (a AssertionSocial) IsRemote() bool

func (AssertionSocial) IsSocial

func (a AssertionSocial) IsSocial() bool

func (AssertionSocial) MatchSet

func (a AssertionSocial) MatchSet(ps ProofSet) bool

func (AssertionSocial) ToLookup

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

func (AssertionSocial) ToSocialAssertion

func (a AssertionSocial) ToSocialAssertion() (sa keybase1.SocialAssertion, err error)

type AssertionTeamID

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

func (AssertionTeamID) CheckAndNormalize

func (a AssertionTeamID) CheckAndNormalize(_ AssertionContext) (AssertionURL, error)

func (AssertionTeamID) CollectUrls

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

func (AssertionTeamID) IsTeamID

func (a AssertionTeamID) IsTeamID() bool

func (AssertionTeamID) MatchSet

func (a AssertionTeamID) MatchSet(ps ProofSet) bool

func (AssertionTeamID) ToLookup

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

func (AssertionTeamID) ToSocialAssertion

func (a AssertionTeamID) ToSocialAssertion() (sa keybase1.SocialAssertion, err error)

func (AssertionTeamID) ToTeamID

func (a AssertionTeamID) ToTeamID() keybase1.TeamID

type AssertionTeamName

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

func (AssertionTeamName) CheckAndNormalize

func (a AssertionTeamName) CheckAndNormalize(_ AssertionContext) (AssertionURL, error)

func (AssertionTeamName) CollectUrls

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

func (AssertionTeamName) IsTeamName

func (a AssertionTeamName) IsTeamName() bool

func (AssertionTeamName) MatchSet

func (a AssertionTeamName) MatchSet(ps ProofSet) bool

func (AssertionTeamName) ToLookup

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

func (AssertionTeamName) ToSocialAssertion

func (a AssertionTeamName) ToSocialAssertion() (sa keybase1.SocialAssertion, err error)

func (AssertionTeamName) ToTeamName

func (a AssertionTeamName) ToTeamName() keybase1.TeamName

type AssertionUID

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

func (AssertionUID) CheckAndNormalize

func (a AssertionUID) CheckAndNormalize(_ AssertionContext) (AssertionURL, error)

func (AssertionUID) CollectUrls

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

func (AssertionUID) IsUID

func (a AssertionUID) IsUID() bool

func (AssertionUID) MatchSet

func (a AssertionUID) MatchSet(ps ProofSet) bool

func (AssertionUID) ToLookup

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

func (AssertionUID) ToSocialAssertion

func (a AssertionUID) ToSocialAssertion() (sa keybase1.SocialAssertion, err error)

func (AssertionUID) ToUID

func (a AssertionUID) ToUID() keybase1.UID

type AssertionURL

type AssertionURL interface {
	AssertionExpression
	Keys() []string
	CheckAndNormalize(ctx AssertionContext) (AssertionURL, error)
	IsKeybase() bool
	IsUID() bool
	IsTeamID() bool
	IsTeamName() bool
	IsSocial() bool
	IsRemote() bool
	IsFingerprint() bool
	IsEmail() bool
	MatchProof(p Proof) bool
	ToUID() keybase1.UID
	ToTeamID() keybase1.TeamID
	ToTeamName() keybase1.TeamName
	ToKeyValuePair() (string, string)
	CacheKey() string
	GetValue() string
	GetKey() string
	ToLookup() (string, string, error)
	IsServerTrust() bool
}

func FindBestIdentifyComponentURL

func FindBestIdentifyComponentURL(e AssertionExpression) AssertionURL

func ParseAssertionURL

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

func ParseAssertionURLKeyValue

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

type AssertionURLBase

type AssertionURLBase struct {
	Key, Value string
}

func (AssertionURLBase) CacheKey

func (b AssertionURLBase) CacheKey() string

func (AssertionURLBase) GetKey

func (b AssertionURLBase) GetKey() string

func (AssertionURLBase) GetValue

func (b AssertionURLBase) GetValue() string

func (AssertionURLBase) HasOr

func (b AssertionURLBase) HasOr() bool

func (AssertionURLBase) IsEmail

func (b AssertionURLBase) IsEmail() bool

func (AssertionURLBase) IsFingerprint

func (b AssertionURLBase) IsFingerprint() bool

func (AssertionURLBase) IsKeybase

func (b AssertionURLBase) IsKeybase() bool

func (AssertionURLBase) IsRemote

func (b AssertionURLBase) IsRemote() bool

func (AssertionURLBase) IsServerTrust

func (b AssertionURLBase) IsServerTrust() bool

func (AssertionURLBase) IsSocial

func (b AssertionURLBase) IsSocial() bool

func (AssertionURLBase) IsTeamID

func (b AssertionURLBase) IsTeamID() bool

func (AssertionURLBase) IsTeamName

func (b AssertionURLBase) IsTeamName() bool

func (AssertionURLBase) IsUID

func (b AssertionURLBase) IsUID() bool

func (AssertionURLBase) Keys

func (b AssertionURLBase) Keys() []string

func (AssertionURLBase) MatchProof

func (b AssertionURLBase) MatchProof(proof Proof) bool

func (AssertionURLBase) NeedsParens

func (b AssertionURLBase) NeedsParens() bool

func (AssertionURLBase) String

func (b AssertionURLBase) String() string

func (AssertionURLBase) ToKeyValuePair

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

func (AssertionURLBase) ToSocialAssertionHelper

func (b AssertionURLBase) ToSocialAssertionHelper() (sa keybase1.SocialAssertion, err error)

func (AssertionURLBase) ToTeamID

func (b AssertionURLBase) ToTeamID() (ret keybase1.TeamID)

func (AssertionURLBase) ToTeamName

func (b AssertionURLBase) ToTeamName() (ret keybase1.TeamName)

func (AssertionURLBase) ToUID

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

type AssertionWeb

type AssertionWeb struct{ AssertionURLBase }

func (AssertionWeb) CheckAndNormalize

func (a AssertionWeb) CheckAndNormalize(_ AssertionContext) (AssertionURL, error)

func (AssertionWeb) CollectUrls

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

func (AssertionWeb) IsRemote

func (a AssertionWeb) IsRemote() bool

func (AssertionWeb) Keys

func (a AssertionWeb) Keys() []string

func (AssertionWeb) MatchSet

func (a AssertionWeb) MatchSet(ps ProofSet) bool

func (AssertionWeb) ToLookup

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

func (AssertionWeb) ToSocialAssertion

func (a AssertionWeb) ToSocialAssertion() (sa keybase1.SocialAssertion, err error)

type AvatarLoaderSource

type AvatarLoaderSource interface {
	LoadUsers(MetaContext, []string, []keybase1.AvatarFormat) (keybase1.LoadAvatarsRes, error)
	LoadTeams(MetaContext, []string, []keybase1.AvatarFormat) (keybase1.LoadAvatarsRes, error)

	ClearCacheForName(MetaContext, string, []keybase1.AvatarFormat) error
	OnDbNuke(MetaContext) error // Called after leveldb data goes away after db nuke

	StartBackgroundTasks(MetaContext)
	StopBackgroundTasks(MetaContext)
}

type B

type B struct {
	Val bool
}

func (B) String

func (b B) String() string

type BackoffPolicy

type BackoffPolicy struct {
	Millis []int
}

BackoffPolicy implements a backoff policy, randomizing its delays and saturating at the final value in Millis.

func (BackoffPolicy) Duration

func (b BackoffPolicy) Duration(n int) time.Duration

Duration returns the time duration of the n'th wait cycle in a backoff policy. This is b.Millis[n], randomized to avoid thundering herds.

type BadEmailError

type BadEmailError struct {
	Msg string
}

func (BadEmailError) Error

func (e BadEmailError) Error() string

func (BadEmailError) ToStatus

func (e BadEmailError) ToStatus() keybase1.Status

type BadFingerprintError

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

func (BadFingerprintError) Error

func (b BadFingerprintError) Error() string

type BadInvitationCodeError

type BadInvitationCodeError struct{}

func (BadInvitationCodeError) Error

func (e BadInvitationCodeError) Error() string

func (BadInvitationCodeError) ToStatus

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

type BadRevocationError

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

func (BadRevocationError) Error

func (e BadRevocationError) Error() string

type BadServiceError

type BadServiceError struct {
	Service string
}

func (BadServiceError) Error

func (e BadServiceError) Error() string

type BadSessionError

type BadSessionError struct {
	Desc string
}

func (BadSessionError) Error

func (e BadSessionError) Error() string

func (BadSessionError) ToStatus

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

type BadSigError

type BadSigError struct {
	E string
}

func (BadSigError) Error

func (e BadSigError) Error() string

type BadUsernameError

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

func NewBadUsernameError

func NewBadUsernameError(n string) BadUsernameError

func NewBadUsernameErrorWithFullMessage

func NewBadUsernameErrorWithFullMessage(msg string) BadUsernameError

func (BadUsernameError) Error

func (e BadUsernameError) Error() string

func (BadUsernameError) ToStatus

func (e BadUsernameError) ToStatus() (ret keybase1.Status)

type Base

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

func (Base) IsNonstandardHome

func (b Base) IsNonstandardHome() (bool, error)

func (Base) Join

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

type Base64Finder

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

func NewBase64Finder

func NewBase64Finder(i string) *Base64Finder

func (*Base64Finder) Run

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

type BaseAPIEngine

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

Shared code across Internal and External APIs

func (*BaseAPIEngine) PrepareGet

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

func (*BaseAPIEngine) PrepareMethodWithBody

func (api *BaseAPIEngine) PrepareMethodWithBody(method string, url1 url.URL, arg APIArg) (*http.Request, error)

type BaseServiceType

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

func (*BaseServiceType) BaseCheckProofForURL

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

func (*BaseServiceType) BaseCheckProofTextFull

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

func (*BaseServiceType) BaseCheckProofTextShort

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

func (*BaseServiceType) BaseGetProofType

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

func (*BaseServiceType) BaseRecheckProofPosting

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

func (*BaseServiceType) BaseToServiceJSON

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

func (*BaseServiceType) CanMakeNewProofs

func (t *BaseServiceType) CanMakeNewProofs(mctx MetaContext) bool

func (*BaseServiceType) CanMakeNewProofsSkipFeatureFlag

func (t *BaseServiceType) CanMakeNewProofsSkipFeatureFlag(mctx MetaContext) bool

func (*BaseServiceType) DisplayGroup

func (t *BaseServiceType) DisplayGroup() string

func (*BaseServiceType) DisplayPriority

func (t *BaseServiceType) DisplayPriority() int

func (*BaseServiceType) FormatProofText

func (t *BaseServiceType) FormatProofText(m MetaContext, ppr *PostProofRes,
	kbUsername, remoteUsername string, sigID keybase1.SigID) (string, error)

func (*BaseServiceType) GetAPIArgKey

func (t *BaseServiceType) GetAPIArgKey() string

func (*BaseServiceType) GetLogoKey

func (t *BaseServiceType) GetLogoKey() string

func (*BaseServiceType) IsDevelOnly

func (t *BaseServiceType) IsDevelOnly() bool

func (*BaseServiceType) IsNew

func (t *BaseServiceType) IsNew(mctx MetaContext) bool

func (*BaseServiceType) LastWriterWins

func (t *BaseServiceType) LastWriterWins() bool

func (*BaseServiceType) PreProofCheck

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

func (*BaseServiceType) PreProofWarning

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

func (*BaseServiceType) SetDisplayConfig

func (t *BaseServiceType) SetDisplayConfig(displayConf *keybase1.ServiceDisplayConfig)

type BaseSigChain

type BaseSigChain interface {
	VerifyChain(m MetaContext) (err error)
	GetComputedKeyInfos() (cki *ComputedKeyInfos)
}

type BaseSigChainLoader

type BaseSigChainLoader interface {
	Load() (ret *BaseSigChain, err error)
	LoadFromServer() (err error)
	VerifySigsAndComputeKeys() (err error)
}

type BaseXEncoder

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

func NewBaseX

func NewBaseX(alphabet string) *BaseXEncoder

func (*BaseXEncoder) DecodeString

func (b *BaseXEncoder) DecodeString(inp string) (outp []byte, err error)

func (*BaseXEncoder) EncodeToString

func (b *BaseXEncoder) EncodeToString(input []byte) string

type BgTicker

type BgTicker struct {
	C <-chan time.Time
	// contains filtered or unexported fields
}

func NewBgTicker

func NewBgTicker(duration time.Duration) *BgTicker

NewBgTicker will panic if wait > duration as time.Ticker does with a negative duration.

func NewBgTickerWithWait

func NewBgTickerWithWait(duration time.Duration, wait time.Duration) *BgTicker

func (*BgTicker) Stop

func (t *BgTicker) Stop()

type BtcOpts

type BtcOpts struct{}

type BucketDict

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

func NewBuckDict

func NewBuckDict() *BucketDict

func (*BucketDict) Add

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

func (BucketDict) Get

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

func (BucketDict) Get0Or1

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

type BufferCloser

type BufferCloser struct {
	*bytes.Buffer
}

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

func NewBufferCloser

func NewBufferCloser() *BufferCloser

func (*BufferCloser) Close

func (b *BufferCloser) Close() error

type BufferWriter

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

BufferWriter has a bufio Writer that will Flush before Close.

func NewBufferWriter

func NewBufferWriter(wc io.WriteCloser) *BufferWriter

func (*BufferWriter) Close

func (b *BufferWriter) Close() error

func (*BufferWriter) Write

func (b *BufferWriter) Write(p []byte) (n int, err error)

type BurstCache

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

BurstCachce is an LRU+SingleFlighter useful for absorbing short-lived bursts of lookups. If multiple goroutines are fetching resource A, they all will block on the first fetch, and can (if the fetch returns without error) share the answer of the first request.

func NewBurstCache

func NewBurstCache(g *GlobalContext, cacheSize int, cacheLife time.Duration, cacheName string) *BurstCache

NewBurstCache makes a new burst cache with the given size and cacheLife. The cache will be at most cacheSize items long, and items will live in there for at most cacheLife duration. For debug logging purposes, this cache will be known as cacheName.

func (*BurstCache) Load

func (b *BurstCache) Load(ctx context.Context, key BurstCacheKey, loader BurstCacheLoader) (ret interface{}, err error)

Load item key from the burst cache. On a cache miss, load with the given loader function. Return the object as an interface{}, so the caller needs to cast out of this burst cache.

type BurstCacheKey

type BurstCacheKey interface {
	String() string
}

BurstCacheKey is a key for a burst cache resource. Needs to implement the one method --- String() --- used for turning the key into an LRU and LockTab key.

type BurstCacheLoader

type BurstCacheLoader func() (obj interface{}, err error)

BurstCacherLoader is a function that loads an item (from network or whatnot). On success, its result will be cached into the burst cache. Maps a key to an object as an interface{}. The caller to Load() should wrap into the closure all parameters needed to actually fetch the object. They called Load(), so they likely have them handy.

type CachedFullSelf

type CachedFullSelf struct {
	Contextified
	sync.Mutex

	TestDeadlocker func()
	// contains filtered or unexported fields
}

CachedFullSelf caches a full-on *User for the "me" or "self" user. Because it's a full-on *User, it contains many pointers and can't reasonably be deep-copied. So we're going to insist that access to the cached user is protected inside a lock.

func NewCachedFullSelf

func NewCachedFullSelf(g *GlobalContext) *CachedFullSelf

NewCachedFullSelf makes a new full self cacher in the given GlobalContext

func (*CachedFullSelf) HandleUserChanged

func (m *CachedFullSelf) HandleUserChanged(u keybase1.UID) error

HandleUserChanged clears the cached self user if it's the UID of the self user.

func (*CachedFullSelf) New

func (m *CachedFullSelf) New() FullSelfer

func (*CachedFullSelf) OnLogin

func (m *CachedFullSelf) OnLogin(mctx MetaContext) error

OnLogin clears the cached self user if it differs from what's already cached.

func (*CachedFullSelf) Update

func (m *CachedFullSelf) Update(ctx context.Context, u *User) (err error)

Update updates the CachedFullSelf with a User loaded from someplace else -- let's say the UPAK loader. We throw away objects for other users or that aren't newer than the one we have.

CALLER BEWARE! You must only provide this function with a user you know to be "self". This function will not do any checking along those lines (see comment below).

func (*CachedFullSelf) WithSelf

func (m *CachedFullSelf) WithSelf(ctx context.Context, f func(u *User) error) error

WithSelf loads only the self user, and maybe hits the cache. It takes a closure, in which the user object is locked and accessible, but we should be sure the user never escapes this closure. If the user is fresh-loaded, then it is stored in memory.

func (*CachedFullSelf) WithSelfForcePoll

func (m *CachedFullSelf) WithSelfForcePoll(ctx context.Context, f func(u *User) error) error

WithSelfForcePoll is like WithSelf but forces a poll. I.e., it will always go to the server for a merkle check, regardless of when the existing self was cached.

func (*CachedFullSelf) WithUser

func (m *CachedFullSelf) WithUser(arg LoadUserArg, f func(u *User) error) (err error)

WithUser loads any old user. If it happens to be the self user, then it behaves as in WithSelf. Otherwise, it will just load the user, and throw it out when done. WithUser supports other so that code doesn't need to change if we're doing the operation for the user or someone else.

type CachedUPAKLoader

type CachedUPAKLoader struct {
	Contextified
	sync.Mutex

	Freshness time.Duration

	TestDeadlocker func()
	// contains filtered or unexported fields
}

CachedUPAKLoader is a UPAKLoader implementation that can cache results both in memory and on disk.

func NewCachedUPAKLoader

func NewCachedUPAKLoader(g *GlobalContext, f time.Duration) *CachedUPAKLoader

NewCachedUPAKLoader constructs a new CachedUPAKLoader

func (*CachedUPAKLoader) Batcher

func (u *CachedUPAKLoader) Batcher(ctx context.Context, getArg func(int) *LoadUserArg, processResult func(int, *keybase1.UserPlusKeysV2AllIncarnations) error, window int) (err error)

Batcher loads a batch of UPAKs with the given window width. It keeps calling getArg(i) with an increasing i, until that getArg return nil, in which case the production of UPAK loads is over. UPAKs will be loaded and fed into processResult() as they come in. Both getArg() and processResult() are called in the same mutex to simplify synchronization.

func (*CachedUPAKLoader) CheckDeviceForUIDAndUsername

func (u *CachedUPAKLoader) CheckDeviceForUIDAndUsername(ctx context.Context, uid keybase1.UID, did keybase1.DeviceID, n NormalizedUsername, suppressNetworkErrs bool) (err error)

func (*CachedUPAKLoader) CheckKIDForUID

func (u *CachedUPAKLoader) CheckKIDForUID(ctx context.Context, uid keybase1.UID, kid keybase1.KID) (found bool, revokedAt *keybase1.KeybaseTime, deleted bool, err error)

func (*CachedUPAKLoader) ClearMemory

func (u *CachedUPAKLoader) ClearMemory()

func (*CachedUPAKLoader) Disable

func (u *CachedUPAKLoader) Disable()

func (*CachedUPAKLoader) GetCurrentUID

func (u *CachedUPAKLoader) GetCurrentUID() keybase1.UID

func (*CachedUPAKLoader) Invalidate

func (u *CachedUPAKLoader) Invalidate(ctx context.Context, uid keybase1.UID)

func (*CachedUPAKLoader) Load

Load a UserPlusKeysV2AllIncarnations from the local cache, falls back to LoadUser, and cache the user. Can only perform lookups by UID. Will return a non-nil UserPlusKeysV2AllIncarnations, or a non-nil error, but never both non-nil, nor never both nil. If we had to do a full LoadUser as part of the request, it's returned too. Convert to UserPlusAllKeys on the way out, for backwards compatibility.

func (*CachedUPAKLoader) LoadDeviceKey

func (u *CachedUPAKLoader) LoadDeviceKey(ctx context.Context, uid keybase1.UID, deviceID keybase1.DeviceID) (upakv1 *keybase1.UserPlusAllKeys, deviceKey *keybase1.PublicKey, revoked *keybase1.RevokedKey, err error)

Load the PublicKey for a user's device from the local cache, falling back to LoadUser, and cache the user. If the user exists but the device doesn't, will force a load in case the device is very new.

func (*CachedUPAKLoader) LoadKeyV2

LoadKeyV2 looks through all incarnations for the user and returns the incarnation with the given KID, as well as the Key data associated with that KID. It picks the latest such incarnation if there are multiple.

func (*CachedUPAKLoader) LoadLite

func (*CachedUPAKLoader) LoadUPAKWithDeviceID

func (u *CachedUPAKLoader) LoadUPAKWithDeviceID(ctx context.Context, uid keybase1.UID, deviceID keybase1.DeviceID) (*keybase1.UserPlusKeysV2AllIncarnations, error)

If the user exists but the device doesn't, will force a load in case the device is very new.

func (*CachedUPAKLoader) LoadUserPlusKeys

func (u *CachedUPAKLoader) LoadUserPlusKeys(ctx context.Context, uid keybase1.UID, pollForKID keybase1.KID) (keybase1.UserPlusKeys, error)

func (*CachedUPAKLoader) LoadV2

Load a UserPlusKeysV2AllIncarnations from the local cache, falls back to LoadUser, and cache the user. Can only perform lookups by UID. Will return a non-nil UserPlusKeysV2AllIncarnations, or a non-nil error, but never both non-nil, nor never both nil. If we had to do a full LoadUser as part of the request, it's returned too.

func (*CachedUPAKLoader) LoadV2WithKID

func (*CachedUPAKLoader) LoginAs

func (u *CachedUPAKLoader) LoginAs(uid keybase1.UID) (err error)

func (*CachedUPAKLoader) LookupUID

LookupUID is a verified map of username -> UID. IT calls into the resolver, which gives un untrusted UID, but verifies with the UPAK loader that the mapping UID -> username is correct.

func (*CachedUPAKLoader) LookupUsername

func (u *CachedUPAKLoader) LookupUsername(ctx context.Context, uid keybase1.UID) (NormalizedUsername, error)

LookupUsername uses the UIDMapper to find a username for uid.

func (*CachedUPAKLoader) LookupUsernameAndDevice

func (u *CachedUPAKLoader) LookupUsernameAndDevice(ctx context.Context, uid keybase1.UID, did keybase1.DeviceID) (username NormalizedUsername, deviceName string, deviceType keybase1.DeviceTypeV2, err error)

func (*CachedUPAKLoader) LookupUsernameUPAK

func (u *CachedUPAKLoader) LookupUsernameUPAK(ctx context.Context, uid keybase1.UID) (NormalizedUsername, error)

LookupUsernameUPAK uses the upak loader to find a username for uid.

func (*CachedUPAKLoader) OnLogout

func (u *CachedUPAKLoader) OnLogout() (err error)

func (*CachedUPAKLoader) PutUserToCache

func (u *CachedUPAKLoader) PutUserToCache(ctx context.Context, user *User) error

type CachedUserLoadInfo

type CachedUserLoadInfo struct {
	InCache      bool
	InDiskCache  bool
	TimedOut     bool
	StaleVersion bool
	LoadedLeaf   bool
	LoadedUser   bool
}

type CancelTimer

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

func (*CancelTimer) Reset

func (c *CancelTimer) Reset()

func (*CancelTimer) SetNow

func (c *CancelTimer) SetNow(m MetaContext)

func (*CancelTimer) WasRecentlyCanceled

func (c *CancelTimer) WasRecentlyCanceled(m MetaContext) bool

type CanceledError

type CanceledError struct {
	M string
}

func NewCanceledError

func NewCanceledError(m string) CanceledError

func (CanceledError) Error

func (c CanceledError) Error() string

func (CanceledError) ToStatus

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

func ImportLinkFromServer

func ImportLinkFromServer(m MetaContext, parent *SigChain, data []byte, selfUID keybase1.UID) (ret *ChainLink, err error)

func ImportLinkFromStorage

func ImportLinkFromStorage(m MetaContext, id LinkID, selfUID keybase1.UID) (*ChainLink, error)
func NewChainLink(g *GlobalContext, parent *SigChain, id LinkID) *ChainLink

func (ChainLink) AllowStubbing

func (c ChainLink) AllowStubbing() bool

func (*ChainLink) CheckNameAndID

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

func (*ChainLink) Copy

func (c *ChainLink) Copy() ChainLink

func (ChainLink) ExpectedNextHighSkip

func (c ChainLink) ExpectedNextHighSkip(mctx MetaContext, uid keybase1.UID) (HighSkip, error)

ExpectedNextHighSkip returns the expected highSkip of the immediately subsequent link in the chain (which may not exist yet). This function can only be called after VerifyChain has processed the chainLink, and set c.computedHighSkip.

func (*ChainLink) GetCTime

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

func (*ChainLink) GetETime

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

func (*ChainLink) GetFirstAppearedMerkleSeqnoUnverified

func (c *ChainLink) GetFirstAppearedMerkleSeqnoUnverified() keybase1.Seqno

func (*ChainLink) GetHighSkip

func (c *ChainLink) GetHighSkip() *HighSkip

func (*ChainLink) GetIgnoreIfSupported

func (c *ChainLink) GetIgnoreIfSupported() SigIgnoreIfUnsupported

func (*ChainLink) GetKID

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

func (*ChainLink) GetMerkleHashMeta

func (c *ChainLink) GetMerkleHashMeta() (keybase1.HashMeta, error)

func (*ChainLink) GetMerkleSeqno

func (c *ChainLink) GetMerkleSeqno() keybase1.Seqno

func (*ChainLink) GetPGPFingerprint

func (c *ChainLink) GetPGPFingerprint() *PGPFingerprint

func (*ChainLink) GetPrev

func (c *ChainLink) GetPrev() LinkID

func (*ChainLink) GetRevocations

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

func (*ChainLink) GetRevokeKids

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

func (*ChainLink) GetSeqno

func (c *ChainLink) GetSeqno() keybase1.Seqno

func (*ChainLink) GetSigCheckCache

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

func (*ChainLink) GetSigID

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

func (*ChainLink) GetSigchainV2Type

func (c *ChainLink) GetSigchainV2Type() (SigchainV2Type, error)

GetSigchainV2Type is a helper function for getting a ChainLink's type. If it is a v2 link (that may or may not be stubbed), return the type from the outer link, otherwise from the inner link.

func (*ChainLink) GetSigchainV2TypeFromInner

func (c *ChainLink) GetSigchainV2TypeFromInner(ignoreIfUnsupported SigIgnoreIfUnsupported) (SigchainV2Type, error)

func (*ChainLink) GetSigchainV2TypeFromV2Shell

func (c *ChainLink) GetSigchainV2TypeFromV2Shell() (SigchainV2Type, error)

func (*ChainLink) GetUID

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

func (*ChainLink) HasRevocations

func (c *ChainLink) HasRevocations() bool

func (*ChainLink) IsBad

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

func (*ChainLink) IsEldest

func (c *ChainLink) IsEldest() bool
func (c ChainLink) IsHighUserLink(mctx MetaContext, uid keybase1.UID) (bool, error)

IsHighUserLink determines whether a chainlink counts as "high" in a user's chain, which is defined as an Eldest link, a link with seqno=1, a link that is Sibkey, PGPUpdate, Revoke, or any link that is revoking.

func (*ChainLink) IsInCurrentFamily

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

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

func (*ChainLink) IsStubbed

func (c *ChainLink) IsStubbed() bool

func (ChainLink) LinkID

func (c ChainLink) LinkID() LinkID

func (*ChainLink) MatchFingerprint

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

func (*ChainLink) Pack

func (c *ChainLink) Pack() (*jsonw.Wrapper, error)

func (*ChainLink) Parent

func (c *ChainLink) Parent() *SigChain

func (*ChainLink) PutSigCheckCache

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

func (*ChainLink) SetParent

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

func (*ChainLink) Store

func (c *ChainLink) Store(m MetaContext) (didStore bool, err error)

func (*ChainLink) ToEldestKID

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

func (ChainLink) ToMerkleTriple

func (c ChainLink) ToMerkleTriple() *MerkleTriple

ToLinkSummary converts a ChainLink into a MerkleTriple object.

func (*ChainLink) ToSigChainLocation

func (c *ChainLink) ToSigChainLocation() keybase1.SigChainLocation

func (*ChainLink) Typed

func (c *ChainLink) Typed() TypedChainLink

func (*ChainLink) UnmarshalPayloadJSON

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

func (*ChainLink) UnpackComputedKeyInfos

func (c *ChainLink) UnpackComputedKeyInfos(data []byte) error

func (*ChainLink) UnpackLocal

func (c *ChainLink) UnpackLocal(payload []byte) (err error)
func (c *ChainLink) VerifyLink() error

func (*ChainLink) VerifySigWithKeyFamily

func (c *ChainLink) VerifySigWithKeyFamily(ckf ComputedKeyFamily) (err error)

type ChainLinkBadUnstubError

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

func (ChainLinkBadUnstubError) Error

func (c ChainLinkBadUnstubError) Error() string

type ChainLinkError

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

func (ChainLinkError) Error

func (c ChainLinkError) Error() string

type ChainLinkFingerprintMismatchError

type ChainLinkFingerprintMismatchError struct {
	Msg string
}

func (ChainLinkFingerprintMismatchError) Error

type ChainLinkHighSkipHashMismatchError

type ChainLinkHighSkipHashMismatchError struct {
	Msg string
}

func (ChainLinkHighSkipHashMismatchError) Error

type ChainLinkKIDMismatchError

type ChainLinkKIDMismatchError struct {
	Msg string
}

func (ChainLinkKIDMismatchError) Error

type ChainLinkPrevHashMismatchError

type ChainLinkPrevHashMismatchError struct {
	Msg string
}

func (ChainLinkPrevHashMismatchError) Error

type ChainLinkStubbedUnsupportedError

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

func (ChainLinkStubbedUnsupportedError) Error

type ChainLinkUnpacked

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

func (*ChainLinkUnpacked) HasRevocations

func (tmp *ChainLinkUnpacked) HasRevocations(payload []byte) bool

func (*ChainLinkUnpacked) Payload

func (tmp *ChainLinkUnpacked) Payload() ([]byte, error)

type ChainLinkWrongHighSkipSeqnoError

type ChainLinkWrongHighSkipSeqnoError struct {
	Msg string
}

func (ChainLinkWrongHighSkipSeqnoError) Error

type ChainLinkWrongSeqnoError

type ChainLinkWrongSeqnoError struct {
	Msg string
}

func (ChainLinkWrongSeqnoError) Error

func (e ChainLinkWrongSeqnoError) Error() string
type ChainLinks []*ChainLink

func (ChainLinks) EldestSeqno

func (c ChainLinks) EldestSeqno() keybase1.Seqno

func (ChainLinks) GetComputedKeyInfos

func (c ChainLinks) GetComputedKeyInfos() (cki *ComputedKeyInfos)

type ChainType

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

type ChatAlreadyDeletedError

type ChatAlreadyDeletedError struct {
	Msg string
}

func (ChatAlreadyDeletedError) Error

func (e ChatAlreadyDeletedError) Error() string

func (ChatAlreadyDeletedError) IsImmediateFail

func (e ChatAlreadyDeletedError) IsImmediateFail() (chat1.OutboxErrorType, bool)

func (ChatAlreadyDeletedError) ToStatus

type ChatAlreadySupersededError

type ChatAlreadySupersededError struct {
	Msg string
}

func (ChatAlreadySupersededError) Error

func (ChatAlreadySupersededError) IsImmediateFail

func (e ChatAlreadySupersededError) IsImmediateFail() (chat1.OutboxErrorType, bool)

func (ChatAlreadySupersededError) ToStatus

type ChatBadConversationError

type ChatBadConversationError struct {
	Msg string
}

func (ChatBadConversationError) Error

func (e ChatBadConversationError) Error() string

func (ChatBadConversationError) IsImmediateFail

func (e ChatBadConversationError) IsImmediateFail() (chat1.OutboxErrorType, bool)

func (ChatBadConversationError) ToStatus

type ChatBadMsgError

type ChatBadMsgError struct {
	Msg string
}

func (ChatBadMsgError) Error

func (e ChatBadMsgError) Error() string

func (ChatBadMsgError) IsImmediateFail

func (e ChatBadMsgError) IsImmediateFail() (chat1.OutboxErrorType, bool)

func (ChatBadMsgError) ToStatus

func (e ChatBadMsgError) ToStatus() keybase1.Status

type ChatBroadcastError

type ChatBroadcastError struct {
	Msg string
}

func (ChatBroadcastError) Error

func (e ChatBroadcastError) Error() string

func (ChatBroadcastError) ToStatus

func (e ChatBroadcastError) ToStatus() keybase1.Status

type ChatClientError

type ChatClientError struct {
	Msg string
}

func (ChatClientError) Error

func (e ChatClientError) Error() string

func (ChatClientError) IsImmediateFail

func (e ChatClientError) IsImmediateFail() (chat1.OutboxErrorType, bool)

func (ChatClientError) ToStatus

func (e ChatClientError) ToStatus() keybase1.Status

type ChatCollisionError

type ChatCollisionError struct {
}

func (ChatCollisionError) Error

func (e ChatCollisionError) Error() string

func (ChatCollisionError) ToStatus

func (e ChatCollisionError) ToStatus() keybase1.Status

type ChatConvExistsError

type ChatConvExistsError struct {
	ConvID chat1.ConversationID
}

func (ChatConvExistsError) Error

func (e ChatConvExistsError) Error() string

func (ChatConvExistsError) ToStatus

func (e ChatConvExistsError) ToStatus() keybase1.Status

type ChatDuplicateMessageError

type ChatDuplicateMessageError struct {
	OutboxID chat1.OutboxID
}

func (ChatDuplicateMessageError) Error

func (ChatDuplicateMessageError) IsImmediateFail

func (e ChatDuplicateMessageError) IsImmediateFail() (chat1.OutboxErrorType, bool)

func (ChatDuplicateMessageError) ToStatus

type ChatEphemeralRetentionPolicyViolatedError

type ChatEphemeralRetentionPolicyViolatedError struct {
	MaxAge gregor1.DurationSec
}

func (ChatEphemeralRetentionPolicyViolatedError) Error

func (ChatEphemeralRetentionPolicyViolatedError) ToStatus

type ChatHelper

type ChatHelper interface {
	NewConversation(ctx context.Context, uid gregor1.UID, tlfName string,
		topicName *string, topicType chat1.TopicType, membersType chat1.ConversationMembersType,
		vis keybase1.TLFVisibility) (chat1.ConversationLocal, bool, error)
	NewConversationSkipFindExisting(ctx context.Context, uid gregor1.UID, tlfName string,
		topicName *string, topicType chat1.TopicType, membersType chat1.ConversationMembersType,
		vis keybase1.TLFVisibility) (chat1.ConversationLocal, bool, error)
	NewConversationWithMemberSourceConv(ctx context.Context, uid gregor1.UID, tlfName string,
		topicName *string, topicType chat1.TopicType, membersType chat1.ConversationMembersType,
		vis keybase1.TLFVisibility, retentionPolicy *chat1.RetentionPolicy,
		memberSourceConv *chat1.ConversationID) (chat1.ConversationLocal, bool, error)
	SendTextByID(ctx context.Context, convID chat1.ConversationID,
		tlfName string, text string, vis keybase1.TLFVisibility) error
	SendMsgByID(ctx context.Context, convID chat1.ConversationID,
		tlfName string, body chat1.MessageBody, msgType chat1.MessageType, vis keybase1.TLFVisibility) error
	SendTextByIDNonblock(ctx context.Context, convID chat1.ConversationID,
		tlfName string, text string, outboxID *chat1.OutboxID, replyTo *chat1.MessageID) (chat1.OutboxID, error)
	SendMsgByIDNonblock(ctx context.Context, convID chat1.ConversationID,
		tlfName string, body chat1.MessageBody, msgType chat1.MessageType, outboxID *chat1.OutboxID,
		replyTo *chat1.MessageID) (chat1.OutboxID, error)
	SendTextByName(ctx context.Context, name string, topicName *string,
		membersType chat1.ConversationMembersType, ident keybase1.TLFIdentifyBehavior, text string) error
	SendMsgByName(ctx context.Context, name string, topicName *string,
		membersType chat1.ConversationMembersType, ident keybase1.TLFIdentifyBehavior, body chat1.MessageBody,
		msgType chat1.MessageType) error
	SendTextByNameNonblock(ctx context.Context, name string, topicName *string,
		membersType chat1.ConversationMembersType, ident keybase1.TLFIdentifyBehavior, text string,
		outboxID *chat1.OutboxID) (chat1.OutboxID, error)
	SendMsgByNameNonblock(ctx context.Context, name string, topicName *string,
		membersType chat1.ConversationMembersType, ident keybase1.TLFIdentifyBehavior, body chat1.MessageBody,
		msgType chat1.MessageType, outboxID *chat1.OutboxID) (chat1.OutboxID, error)
	DeleteMsg(ctx context.Context, convID chat1.ConversationID, tlfName string,
		msgID chat1.MessageID) error
	DeleteMsgNonblock(ctx context.Context, convID chat1.ConversationID, tlfName string,
		msgID chat1.MessageID) error
	FindConversations(ctx context.Context, name string,
		topicName *string, topicType chat1.TopicType, membersType chat1.ConversationMembersType,
		vis keybase1.TLFVisibility) ([]chat1.ConversationLocal, error)
	FindConversationsByID(ctx context.Context, convIDs []chat1.ConversationID) ([]chat1.ConversationLocal, error)
	JoinConversationByID(ctx context.Context, uid gregor1.UID, convID chat1.ConversationID) error
	JoinConversationByName(ctx context.Context, uid gregor1.UID, tlfName, topicName string,
		topicType chat1.TopicType, vid keybase1.TLFVisibility) error
	LeaveConversation(ctx context.Context, uid gregor1.UID, convID chat1.ConversationID) error
	GetChannelTopicName(context.Context, keybase1.TeamID, chat1.TopicType, chat1.ConversationID) (string, error)
	GetMessages(ctx context.Context, uid gregor1.UID, convID chat1.ConversationID,
		msgIDs []chat1.MessageID, resolveSupersedes bool, reason *chat1.GetThreadReason) ([]chat1.MessageUnboxed, error)
	GetMessage(ctx context.Context, uid gregor1.UID, convID chat1.ConversationID,
		msgID chat1.MessageID, resolveSupersedes bool, reason *chat1.GetThreadReason) (chat1.MessageUnboxed, error)
	UpgradeKBFSToImpteam(ctx context.Context, tlfName string, tlfID chat1.TLFID, public bool) error
	UserReacjis(ctx context.Context, uid gregor1.UID) keybase1.UserReacjis
	JourneycardTimeTravel(context.Context, gregor1.UID, time.Duration) (int, int, error)
	JourneycardResetAllConvs(context.Context, gregor1.UID) error
	JourneycardDebugState(context.Context, gregor1.UID, keybase1.TeamID) (string, error)
	// InTeam gives a best effort to answer team membership based on the current state of the inbox cache
	InTeam(context.Context, gregor1.UID, keybase1.TeamID) (bool, error)
	BulkAddToConv(context.Context, gregor1.UID, chat1.ConversationID, []string) error
}

type ChatInternalError

type ChatInternalError struct{}

func (ChatInternalError) Error

func (e ChatInternalError) Error() string

func (ChatInternalError) ToStatus

func (e ChatInternalError) ToStatus() keybase1.Status

type ChatMessageCollisionError

type ChatMessageCollisionError struct {
	HeaderHash string
}

func (ChatMessageCollisionError) Error

func (ChatMessageCollisionError) ToStatus

type ChatNotInConvError

type ChatNotInConvError struct {
	UID    gregor.UID
	ConvID chat1.ConversationID
}

func (ChatNotInConvError) Error

func (e ChatNotInConvError) Error() string

func (ChatNotInConvError) IsImmediateFail

func (e ChatNotInConvError) IsImmediateFail() (chat1.OutboxErrorType, bool)

func (ChatNotInConvError) ToStatus

func (e ChatNotInConvError) ToStatus() keybase1.Status

type ChatNotInTeamError

type ChatNotInTeamError struct {
	UID   gregor.UID
	TlfID chat1.TLFID
}

func (ChatNotInTeamError) Error

func (e ChatNotInTeamError) Error() string

func (ChatNotInTeamError) IsImmediateFail

func (e ChatNotInTeamError) IsImmediateFail() (chat1.OutboxErrorType, bool)

func (ChatNotInTeamError) ToStatus

func (e ChatNotInTeamError) ToStatus() keybase1.Status

type ChatRateLimitError

type ChatRateLimitError struct {
	Msg       string
	RateLimit chat1.RateLimit
}

func (ChatRateLimitError) Error

func (e ChatRateLimitError) Error() string

func (ChatRateLimitError) ToStatus

func (e ChatRateLimitError) ToStatus() keybase1.Status

type ChatStalePreviousStateError

type ChatStalePreviousStateError struct{}

func (ChatStalePreviousStateError) Error

func (ChatStalePreviousStateError) ToStatus

type ChatTLFFinalizedError

type ChatTLFFinalizedError struct {
	TlfID chat1.TLFID
}

=============================================================================

func (ChatTLFFinalizedError) Error

func (e ChatTLFFinalizedError) Error() string

func (ChatTLFFinalizedError) ToStatus

func (e ChatTLFFinalizedError) ToStatus() keybase1.Status

type ChatUI

type ChatUI interface {
	ChatInboxUnverified(context.Context, chat1.ChatInboxUnverifiedArg) error
	ChatInboxConversation(context.Context, chat1.ChatInboxConversationArg) error
	ChatInboxFailed(context.Context, chat1.ChatInboxFailedArg) error
	ChatInboxLayout(context.Context, string) error
	ChatThreadCached(context.Context, *string) error
	ChatThreadFull(context.Context, string) error
	ChatThreadStatus(context.Context, chat1.UIChatThreadStatus) error
	ChatConfirmChannelDelete(context.Context, chat1.ChatConfirmChannelDeleteArg) (bool, error)
	ChatSearchHit(context.Context, chat1.ChatSearchHitArg) error
	ChatSearchDone(context.Context, chat1.ChatSearchDoneArg) error
	ChatSearchInboxHit(context.Context, chat1.ChatSearchInboxHitArg) error
	ChatSearchInboxStart(context.Context) error
	ChatSearchInboxDone(context.Context, chat1.ChatSearchInboxDoneArg) error
	ChatSearchIndexStatus(context.Context, chat1.ChatSearchIndexStatusArg) error
	ChatSearchConvHits(context.Context, chat1.UIChatSearchConvHits) error
	ChatSearchTeamHits(context.Context, chat1.UIChatSearchTeamHits) error
	ChatSearchBotHits(context.Context, chat1.UIChatSearchBotHits) error
	ChatStellarShowConfirm(context.Context) error
	ChatStellarDataConfirm(context.Context, chat1.UIChatPaymentSummary) (bool, error)
	ChatStellarDataError(context.Context, keybase1.Status) (bool, error)
	ChatStellarDone(context.Context, bool) error
	ChatGiphySearchResults(ctx context.Context, convID chat1.ConversationID,
		results chat1.GiphySearchResults) error
	ChatGiphyToggleResultWindow(ctx context.Context, convID chat1.ConversationID, show, clearInput bool) error
	ChatShowManageChannels(context.Context, string) error
	ChatCoinFlipStatus(context.Context, []chat1.UICoinFlipStatus) error
	ChatCommandMarkdown(context.Context, chat1.ConversationID, *chat1.UICommandMarkdown) error
	ChatMaybeMentionUpdate(context.Context, string, string, chat1.UIMaybeMentionInfo) error
	ChatLoadGalleryHit(context.Context, chat1.UIMessage) error
	ChatWatchPosition(context.Context, chat1.ConversationID, chat1.UIWatchPositionPerm) (chat1.LocationWatchID, error)
	ChatClearWatch(context.Context, chat1.LocationWatchID) error
	ChatCommandStatus(context.Context, chat1.ConversationID, string, chat1.UICommandStatusDisplayTyp,
		[]chat1.UICommandStatusActionTyp) error
	ChatBotCommandsUpdateStatus(context.Context, chat1.ConversationID, chat1.UIBotCommandsUpdateStatus) error
	TriggerContactSync(context.Context) error
}

type ChatUnknownTLFIDError

type ChatUnknownTLFIDError struct {
	TlfID chat1.TLFID
}

func (ChatUnknownTLFIDError) Error

func (e ChatUnknownTLFIDError) Error() string

func (ChatUnknownTLFIDError) ToStatus

func (e ChatUnknownTLFIDError) ToStatus() keybase1.Status

type ChatUsersAlreadyInConversationError

type ChatUsersAlreadyInConversationError struct {
	Uids []keybase1.UID
}

func (ChatUsersAlreadyInConversationError) Error

func (ChatUsersAlreadyInConversationError) ToStatus

type CheckCompletedListener

type CheckCompletedListener interface {
	CCLCheckCompleted(lcr *LinkCheckResult)
}

type CheckMember

type CheckMember struct {
	Set []string
}

func (CheckMember) Checker

func (c CheckMember) Checker() Checker

type CheckResult

type CheckResult struct {
	Contextified
	Status       ProofError // Or nil if it was a success
	VerifiedHint *SigHint   // client provided verified hint if any
	Time         time.Time  // When the last check was
	PvlHash      string     // Added after other fields. Some entries may not have this packed.
}

func NewCheckResult

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

func NewNowCheckResult

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

func (CheckResult) Export

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

func (CheckResult) Freshness

func (cr CheckResult) Freshness() keybase1.CheckResultFreshness

func (CheckResult) Pack

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

type Checker

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

func MakeCheckKex2SecretPhrase

func MakeCheckKex2SecretPhrase(g *GlobalContext) Checker

type CheckerWrapper

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

CheckerWrapper wraps a Checker type to make it conform to the PassphraseChecker interface.

func (*CheckerWrapper) Automutate

func (w *CheckerWrapper) Automutate(m MetaContext, s string) (string, error)

func (*CheckerWrapper) Check

func (w *CheckerWrapper) Check(m MetaContext, s string) error

Check s using checker, respond with checker.Hint if check fails.

type Client

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

func NewClient

func NewClient(g *GlobalContext, config *ClientConfig, needCookie bool) (*Client, error)

type ClientConfig

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

type Clock

type Clock interface {
	Now() time.Time
}

type ClockContext

type ClockContext interface {
	GetClock() clockwork.Clock
}

type ClosingRoundTripper

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

func NewClosingRoundTripper

func NewClosingRoundTripper(rt http.RoundTripper) *ClosingRoundTripper

func (ClosingRoundTripper) RoundTrip

func (t ClosingRoundTripper) RoundTrip(req *http.Request) (*http.Response, error)

type Command

type Command interface {
	GetUsage() Usage
}

type CommandLine

type CommandLine interface {
	GetAPIDump() (bool, bool)
	GetPGPFingerprint() *PGPFingerprint
	GetNoAutoFork() (bool, bool)

	// Lower-level functions
	GetGString(string) string
	GetString(string) string
	GetBool(string, bool) (bool, bool)
	// contains filtered or unexported methods
}

type ComputedKeyFamily

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

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

func (*ComputedKeyFamily) ClearActivePGPHash

func (ckf *ComputedKeyFamily) ClearActivePGPHash(kid keybase1.KID)

ClearActivePGPHash clears authoritative hash of PGP key, after a revoke.

func (*ComputedKeyFamily) Delegate

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

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

func (*ComputedKeyFamily) DelegatePerUserKey

func (ckf *ComputedKeyFamily) DelegatePerUserKey(perUserKey keybase1.PerUserKey) (err error)

func (ComputedKeyFamily) Export

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

Export is used by IDRes. It includes PGP keys.

func (ComputedKeyFamily) ExportAllPGPKeys

func (ckf ComputedKeyFamily) ExportAllPGPKeys() (keys []keybase1.PublicKey)

ExportAllPGPKeys exports all pgp keys.

func (ComputedKeyFamily) ExportDeletedDeviceKeys

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

ExportDeletedDeviceKeys is used by ExportToUserPlusKeys. The key list only contains deleted device keys.

func (ComputedKeyFamily) ExportDeviceKeys

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

ExportDeviceKeys is used by ExportToUserPlusKeys. The key list only contains device keys. It also returns the number of PGP keys in the key family.

func (ComputedKeyFamily) ExportPerUserKeys

func (ckf ComputedKeyFamily) ExportPerUserKeys() (ret []keybase1.PerUserKey)

ExportPerUserKeys exports the per-user public KIDs.

func (ComputedKeyFamily) ExportRevokedDeviceKeys

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

func (ComputedKeyFamily) FindActiveEncryptionSubkey

func (ckf ComputedKeyFamily) FindActiveEncryptionSubkey(kid keybase1.KID) (ret GenericKey, cki ComputedKeyInfo, err error)

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

func (ComputedKeyFamily) FindActiveSibkey

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

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

func (ComputedKeyFamily) FindActiveSibkeyAtTime

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

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

func (ComputedKeyFamily) FindKIDFromFingerprint

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

func (ComputedKeyFamily) FindKeyWithKIDUnsafe

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

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

func (ComputedKeyFamily) FindKeybaseName

func (ckf ComputedKeyFamily) FindKeybaseName(s string) bool

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

func (ComputedKeyFamily) GetActivePGPKeys

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

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

func (*ComputedKeyFamily) GetAllActiveDevices

func (ckf *ComputedKeyFamily) GetAllActiveDevices() []DeviceWithDeviceNumber

func (ComputedKeyFamily) GetAllActiveKeysForDevice

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

func (ComputedKeyFamily) GetAllActiveKeysWithRoleAtTime

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

GetAllActiveSibkeys gets all active Sibkeys from given ComputedKeyFamily.

func (ComputedKeyFamily) GetAllActiveSibkeys

func (ckf ComputedKeyFamily) GetAllActiveSibkeys() []GenericKey

GetAllActiveSibkeys gets all active Sibkeys from given ComputedKeyFamily.

func (ComputedKeyFamily) GetAllActiveSibkeysAtTime

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

GetAllActiveSibkeys gets all active Sibkeys from given ComputedKeyFamily.

func (ComputedKeyFamily) GetAllActiveSubkeys

func (ckf ComputedKeyFamily) GetAllActiveSubkeys() []GenericKey

func (ComputedKeyFamily) GetAllActiveSubkeysAtTime

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

func (*ComputedKeyFamily) GetAllDevices

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

func (ComputedKeyFamily) GetAllSibkeysUnchecked

func (ckf ComputedKeyFamily) GetAllSibkeysUnchecked() (ret []GenericKey)

GetAllSibkeysUnchecked gets all sibkeys, dead or otherwise, that were at one point associated with this key family.

func (ComputedKeyFamily) GetAllSubkeysUnchecked

func (ckf ComputedKeyFamily) GetAllSubkeysUnchecked() (ret []GenericKey)

GetAllSubkeysUnchecked gets all sibkeys, dead or otherwise, that were at one point associated with this key family.

func (*ComputedKeyFamily) GetCurrentDevice

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

GetCurrentDevice returns the current device.

func (ComputedKeyFamily) GetDeletedKeys

func (ckf ComputedKeyFamily) GetDeletedKeys() []GenericKey

func (*ComputedKeyFamily) GetDeviceForKID

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

func (*ComputedKeyFamily) GetDeviceForKey

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

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

func (*ComputedKeyFamily) GetEncryptionSubkeyForDevice

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

GetEncryptionSubkeyForDevice gets the current encryption subkey for the given device.

func (ComputedKeyFamily) GetKeyRole

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

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

func (ComputedKeyFamily) GetKeyRoleAtTime

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

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

func (*ComputedKeyFamily) GetLatestPerUserKey

func (ckf *ComputedKeyFamily) GetLatestPerUserKey() *keybase1.PerUserKey

If there aren't any per-user-keys for the user, return nil.

func (ComputedKeyFamily) GetRevokedKeys

func (ckf ComputedKeyFamily) GetRevokedKeys() []RevokedKey

func (ComputedKeyFamily) GetSaltpackSenderTypeIfInactive

func (ckf ComputedKeyFamily) GetSaltpackSenderTypeIfInactive(kid keybase1.KID) (*keybase1.SaltpackSenderType, error)

Returns (&senderType, err). A non-nil error indicates some unexpected condition (like the key doesn't exist at all), which should be propagated. If the sender type is nil, the key is active, and the caller should proceed with an identify. Otherwise the key is no longer active, and the sender type indicates why.

func (*ComputedKeyFamily) GetSibkeyForDevice

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

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

func (*ComputedKeyFamily) HasActiveDevice

func (ckf *ComputedKeyFamily) HasActiveDevice() bool

func (*ComputedKeyFamily) HasActiveEncryptionSubkey

func (ckf *ComputedKeyFamily) HasActiveEncryptionSubkey() bool

func (ComputedKeyFamily) HasActiveKey

func (ckf ComputedKeyFamily) HasActiveKey() bool

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

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

func (*ComputedKeyFamily) Revoke

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

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

func (*ComputedKeyFamily) RevokeKid

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

func (*ComputedKeyFamily) RevokeSig

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

func (*ComputedKeyFamily) SetActivePGPHash

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

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

func (ComputedKeyFamily) ShallowCopy

func (ckf ComputedKeyFamily) ShallowCopy() *ComputedKeyFamily

func (*ComputedKeyFamily) UpdateDevices

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

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

type ComputedKeyInfo

type ComputedKeyInfo struct {
	Contextified

	// Repeat the KID inside, for lookups if we get here via the
	// `Sigs` map in ComputedKeyInfos
	KID keybase1.KID

	Status KeyStatus
	Eldest bool
	Sibkey bool

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

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

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

	// Map of SigID -> KID
	Delegations map[keybase1.SigIDMapKey]keybase1.KID

	// List of the same delegations as above, in a way that preserves ordering.
	// NOTE: This is not populated in older cached CKI's.
	DelegationsList []Delegation

	// Merkle Timestamps and Friends for delegation. Suboptimal grouping of concerns
	// due to backwards compatibility and sensitivity to preexisting ondisk representations.
	DelegatedAt                 *KeybaseTime              // The Seqno/Ctime signed into the link, so jus before the actual delegation!
	DelegatedAtHashMeta         keybase1.HashMeta         // The HashMeta at the time of the delegation
	FirstAppearedUnverified     keybase1.Seqno            // What the server claims was the first merkle appearance of this seqno
	DelegatedAtSigChainLocation keybase1.SigChainLocation // Where the delegation was in our sigchain

	// Merkle Timestamps and Friends for revocation.
	RevokedAt                     *KeybaseTime // The Seqno/Ctime signed into the signature
	RevokedBy                     keybase1.KID
	RevokedAtHashMeta             keybase1.HashMeta          // The hash_meta signed in at the time of the revocation
	RevokeFirstAppearedUnverified keybase1.Seqno             // What the server claims was the first merkle appearance of this revoke
	RevokedAtSigChainLocation     *keybase1.SigChainLocation // Where the revocation was in our sigchain

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

refers to exactly one ServerKeyInfo.

func NewComputedKeyInfo

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

func (ComputedKeyInfo) GetCTime

func (cki ComputedKeyInfo) GetCTime() time.Time

func (ComputedKeyInfo) GetETime

func (cki ComputedKeyInfo) GetETime() time.Time

type ComputedKeyInfos

type ComputedKeyInfos struct {
	Contextified

	// Now set to 1. Everything before that is thrown away on sigchain load.
	Version ComputedKeyInfosVersion

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

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

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

	// Map of KID -> DeviceID
	KIDToDeviceID map[keybase1.KID]keybase1.DeviceID

	// For each generation, the public KIDs that correspond to the
	// per-user-key for a given generation.
	// Starts at gen=1.
	PerUserKeys map[keybase1.PerUserKeyGeneration]keybase1.PerUserKey
	// contains filtered or unexported fields
}

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

func NewComputedKeyInfos

func NewComputedKeyInfos(g *GlobalContext) *ComputedKeyInfos

func (*ComputedKeyInfos) Delegate

func (cki *ComputedKeyInfos) Delegate(kid keybase1.KID, tm *KeybaseTime, sigid keybase1.SigID, signingKid, parentKID keybase1.KID,
	pgpHash string, isSibkey bool, ctime, etime time.Time,
	merkleHashMeta keybase1.HashMeta, fau keybase1.Seqno,
	dascl keybase1.SigChainLocation) (err error)

Delegate marks the given ComputedKeyInfos object that the given kid is now delegated, as of time tm, in sigid, as signed by signingKid, etc. fau = "FirstAppearedUnverified", a hint from the server that we're going to persist. dascl = "DelegatedAtSigChainLocation"

func (*ComputedKeyInfos) DelegatePerUserKey

func (cki *ComputedKeyInfos) DelegatePerUserKey(perUserKey keybase1.PerUserKey) (err error)

DelegatePerUserKey inserts the new per-user key into the list of known per-user keys.

func (*ComputedKeyInfos) Insert

func (cki *ComputedKeyInfos) Insert(i *ComputedKeyInfo)

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

func (ComputedKeyInfos) InsertLocalEldestKey

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

func (ComputedKeyInfos) InsertServerEldestKey

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

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

func (*ComputedKeyInfos) IsStaleVersion

func (cki *ComputedKeyInfos) IsStaleVersion() bool

func (*ComputedKeyInfos) PaperDevices

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

PaperDevices returns a list of all the paperkey devices.

func (ComputedKeyInfos) ShallowCopy

func (cki ComputedKeyInfos) ShallowCopy() *ComputedKeyInfos

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

type ComputedKeyInfosVersion

type ComputedKeyInfosVersion int
const (
	ComputedKeyInfosV1             ComputedKeyInfosVersion = ComputedKeyInfosVersion(1)
	ComputedKeyInfosV2             ComputedKeyInfosVersion = ComputedKeyInfosVersion(2)
	ComputedKeyInfosV3             ComputedKeyInfosVersion = ComputedKeyInfosVersion(3)
	ComputedKeyInfosV4             ComputedKeyInfosVersion = ComputedKeyInfosVersion(4)
	ComputedKeyInfosVersionCurrent                         = ComputedKeyInfosV4
)

type ConfigError

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

func (ConfigError) Error

func (c ConfigError) Error() string

type ConfigGetter

type ConfigGetter func() string

type ConfigReader

type ConfigReader interface {
	JSONReader

	GetUserConfig() (*UserConfig, error)
	GetUserConfigForUsername(s NormalizedUsername) (*UserConfig, error)
	GetBundledCA(host string) string
	GetProofCacheLongDur() (time.Duration, bool)
	GetProofCacheMediumDur() (time.Duration, bool)
	GetProofCacheShortDur() (time.Duration, bool)
	GetLinkCacheCleanDur() (time.Duration, bool)
	GetNoPinentry() (bool, bool)
	GetDeviceID() keybase1.DeviceID
	GetDeviceIDForUsername(nu NormalizedUsername) keybase1.DeviceID
	GetPassphraseState() *keybase1.PassphraseState
	GetPassphraseStateForUsername(nu NormalizedUsername) *keybase1.PassphraseState
	GetDeviceIDForUID(u keybase1.UID) keybase1.DeviceID
	GetUsernameForUID(u keybase1.UID) NormalizedUsername
	GetUIDForUsername(n NormalizedUsername) keybase1.UID
	GetUsername() NormalizedUsername
	GetAllUsernames() (current NormalizedUsername, others []NormalizedUsername, err error)
	GetAllUserConfigs() (current *UserConfig, others []UserConfig, err error)
	GetUID() keybase1.UID
	GetProxyCACerts() ([]string, error)
	GetSecurityAccessGroupOverride() (bool, bool)
	GetBug3964RepairTime(NormalizedUsername) (time.Time, error)
	GetStayLoggedOut() (bool, bool)

	GetUpdatePreferenceAuto() (bool, bool)
	GetUpdatePreferenceSkip() string
	GetUpdatePreferenceSnoozeUntil() keybase1.Time
	GetUpdateLastChecked() keybase1.Time
	GetUpdateURL() string
	GetUpdateDisabled() (bool, bool)

	GetAndroidInstallReferrerChecked() bool
	// contains filtered or unexported methods
}

type ConfigWriter

type ConfigWriter interface {
	JSONWriter
	SetUserConfig(cfg *UserConfig, overwrite bool) error
	SwitchUser(un NormalizedUsername) error
	NukeUser(un NormalizedUsername) error
	SetDeviceID(keybase1.DeviceID) error
	SetUpdatePreferenceAuto(bool) error
	SetUpdatePreferenceSkip(string) error
	SetUpdatePreferenceSnoozeUntil(keybase1.Time) error
	SetUpdateLastChecked(keybase1.Time) error
	SetBug3964RepairTime(NormalizedUsername, time.Time) error
	SetRememberPassphrase(NormalizedUsername, bool) error
	SetPassphraseState(keybase1.PassphraseState) error
	SetStayLoggedOut(bool) error
	Reset()
	BeginTransaction() (ConfigWriterTransacter, error)

	SetAndroidInstallReferrerChecked(b bool) error
}

type ConfigWriterTransacter

type ConfigWriterTransacter interface {
	Commit() error
	Rollback() error
	Abort() error
}

type ConnectionID

type ConnectionID int

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

type ConnectionManager

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

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

func NewConnectionManager

func NewConnectionManager() *ConnectionManager

NewConnectionManager makes a new ConnectionManager.

func (*ConnectionManager) AddConnection

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

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

func (*ConnectionManager) ApplyAll

func (c *ConnectionManager) ApplyAll(f ApplyFn)

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

func (*ConnectionManager) ApplyAllDetails

func (c *ConnectionManager) ApplyAllDetails(f ApplyDetailsFn)

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

func (*ConnectionManager) Label

func (*ConnectionManager) ListAllLabeledConnections

func (c *ConnectionManager) ListAllLabeledConnections() (ret []keybase1.ClientStatus)

func (*ConnectionManager) LookupByClientType

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

func (*ConnectionManager) LookupConnection

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

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

func (*ConnectionManager) RegisterLabelCallback

func (c *ConnectionManager) RegisterLabelCallback(f LabelCb)

func (*ConnectionManager) Shutdown

func (c *ConnectionManager) Shutdown()

func (*ConnectionManager) WaitForClientType

func (c *ConnectionManager) WaitForClientType(clientType keybase1.ClientType, timeout time.Duration) bool

WaitForClientType returns true if client type is connected, or waits until timeout for the connection

type ConnectivityMonitor

type ConnectivityMonitor interface {
	IsConnected(ctx context.Context) ConnectivityMonitorResult
	CheckReachability(ctx context.Context) error
}

type ConnectivityMonitorResult

type ConnectivityMonitorResult int
const (
	ConnectivityMonitorYes ConnectivityMonitorResult = iota
	ConnectivityMonitorNo
	ConnectivityMonitorUnknown
)

type Contextified

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

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

func NewContextified

func NewContextified(gc *GlobalContext) Contextified

func (Contextified) G

func (c Contextified) G() *GlobalContext

func (Contextified) GStrict

func (c Contextified) GStrict() *GlobalContext

func (Contextified) MetaContext

func (c Contextified) MetaContext(ctx context.Context) MetaContext

func (*Contextified) SetGlobalContext

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

type Contextifier

type Contextifier interface {
	G() *GlobalContext
}

type CryptoMessageFormat

type CryptoMessageFormat string

CryptoMessageFormat is one of the known crypto message formats that we admit

const (
	// CryptoMessageFormatPGP is for PGP
	CryptoMessageFormatPGP CryptoMessageFormat = "pgp"
	// CryptoMessageFormatKeybaseV0 is for the zeroth version of Keybase signatures, which
	// will eventually be deprecated.
	CryptoMessageFormatKeybaseV0 CryptoMessageFormat = "kbv0"
	// CryptoMessageFormatSaltpack is the Saltpack messaging format for encrypted and signed
	// messages
	CryptoMessageFormatSaltpack CryptoMessageFormat = "saltpack"
)

type CryptoMessageType

type CryptoMessageType int

CryptoMessageType says what type of crypto message it is, regardless of Format

const (
	// CryptoMessageTypeEncryption is for an encrypted message
	CryptoMessageTypeEncryption CryptoMessageType = 0
	// CryptoMessageTypeAttachedSignature is for an attached signature
	CryptoMessageTypeAttachedSignature CryptoMessageType = 1
	// CryptoMessageTypeDetachedSignature is for a detached signature
	CryptoMessageTypeDetachedSignature CryptoMessageType = 2
	// CryptoMessageTypeClearSignature is for PGP clearsigning
	CryptoMessageTypeClearSignature CryptoMessageType = 3
	// CryptoMessageTypeAmbiguous is for an ambiguous message based on the stream prefix
	CryptoMessageTypeAmbiguous CryptoMessageType = 4
	// CryptoMessageTypeSignature is for a sig that can be either attached or detached
	CryptoMessageTypeSignature CryptoMessageType = 5
)
type CryptocurrencyChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseCryptocurrencyChainLink(b GenericChainLink) (
	cl *CryptocurrencyChainLink, err error)

func (CryptocurrencyChainLink) Display

func (CryptocurrencyChainLink) Export

func (CryptocurrencyChainLink) GetAddress

func (c CryptocurrencyChainLink) GetAddress() string

func (*CryptocurrencyChainLink) ToDisplayString

func (c *CryptocurrencyChainLink) ToDisplayString() string

func (*CryptocurrencyChainLink) Type

func (c *CryptocurrencyChainLink) Type() string

type CryptocurrencyFamily

type CryptocurrencyFamily string
const (
	CryptocurrencyFamilyNone    CryptocurrencyFamily = ""
	CryptocurrencyFamilyBitcoin CryptocurrencyFamily = "bitcoin"
	CryptocurrencyFamilyZCash   CryptocurrencyFamily = "zcash"
)

type CryptocurrencyPrefix

type CryptocurrencyPrefix struct {
	Type   CryptocurrencyType
	Prefix []byte
	Len    int
}

type CryptocurrencyType

type CryptocurrencyType int
const (
	CryptocurrencyTypeNone                  CryptocurrencyType = -1
	CryptocurrencyTypeBTC                   CryptocurrencyType = 0      // 0x0
	CryptocurrencyTypeBTCMultiSig           CryptocurrencyType = 5      // 0x5
	CryptocurrencyTypeBTCSegwit             CryptocurrencyType = 0x6263 // "bc"
	CryptocurrencyTypeZCashShielded         CryptocurrencyType = 5786   // 0x169a
	CryptocurrencyTypeZCashTransparentP2PKH CryptocurrencyType = 7352   // 0x1cb8
	CryptocurrencyTypeZCashTransparentP2SH  CryptocurrencyType = 7357   // 0x1cbd
	CryptocurrencyTypeZCashSapling          CryptocurrencyType = 0x7a73 // "zs"
)

func CryptocurrencyParseAndCheck

func CryptocurrencyParseAndCheck(s string) (CryptocurrencyType, []byte, error)

func (CryptocurrencyType) String

func (p CryptocurrencyType) String() string

func (CryptocurrencyType) ToCryptocurrencyFamily

func (p CryptocurrencyType) ToCryptocurrencyFamily() CryptocurrencyFamily

type CtimeMismatchError

type CtimeMismatchError struct {
	Msg string
}

func (CtimeMismatchError) Error

func (e CtimeMismatchError) Error() string

type DBError

type DBError struct {
	Msg string
}

func NewDBError

func NewDBError(s string) DBError

func (DBError) Error

func (e DBError) Error() string

type DBKeySet

type DBKeySet map[DbKey]struct{}

type DNSContext

type DNSContext interface {
	GetDNSNameServerFetcher() DNSNameServerFetcher
}

type DNSNameServerFetcher

type DNSNameServerFetcher interface {
	GetServers() []string
}

type Darwin

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

func (Darwin) CacheDir

func (d Darwin) CacheDir() string

func (Darwin) ConfigDir

func (d Darwin) ConfigDir() string

func (Darwin) DataDir

func (d Darwin) DataDir() string

func (Darwin) DownloadsDir

func (d Darwin) DownloadsDir() string

func (Darwin) Home

func (d Darwin) Home(emptyOk bool) string

func (Darwin) InfoDir

func (d Darwin) InfoDir() string

func (Darwin) LogDir

func (d Darwin) LogDir() string

func (Darwin) MobileSharedHome

func (d Darwin) MobileSharedHome(emptyOk bool) string

func (Darwin) Normalize

func (d Darwin) Normalize(s string) string

func (Darwin) RuntimeDir

func (d Darwin) RuntimeDir() string

func (Darwin) SandboxCacheDir

func (d Darwin) SandboxCacheDir() string

func (Darwin) ServiceSpawnDir

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

func (Darwin) SharedCacheDir

func (d Darwin) SharedCacheDir() string

func (Darwin) SharedDataDir

func (d Darwin) SharedDataDir() string

type DbCleanerConfig

type DbCleanerConfig struct {
	// start cleaning if above this size
	MaxSize uint64
	// stop cleaning when below this size
	HaltSize uint64
	// attempt a clean with this frequency
	CleanInterval time.Duration
	// number of keys to keep cached
	CacheCapacity int
	// number of keys cached to run a clean
	MinCacheSize int
	// duration cleaner sleeps when cleaning
	SleepInterval time.Duration
}

func (DbCleanerConfig) String

func (c DbCleanerConfig) String() string

type DbKey

type DbKey struct {
	Typ ObjType
	Key string
}

func DbKeyNotificationDismiss

func DbKeyNotificationDismiss(prefix string, username NormalizedUsername) DbKey

func DbKeyParse

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

func DbKeyUID

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

func ImportDbKey

func ImportDbKey(k keybase1.DbKey) DbKey

func LocalTrackDBKey

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

func (DbKey) ToBytes

func (k DbKey) ToBytes() []byte

func (DbKey) ToBytesLookup

func (k DbKey) ToBytesLookup() []byte

type DbNukeHook

type DbNukeHook interface {
	OnDbNuke(mctx MetaContext) error
}

type DecryptBadNonceError

type DecryptBadNonceError struct{}

func (DecryptBadNonceError) Error

func (d DecryptBadNonceError) Error() string

type DecryptBadPacketTypeError

type DecryptBadPacketTypeError struct{}

func (DecryptBadPacketTypeError) Error

type DecryptBadSenderError

type DecryptBadSenderError struct{}

func (DecryptBadSenderError) Error

func (d DecryptBadSenderError) Error() string

type DecryptOpenError

type DecryptOpenError struct {
	What string
}

func NewDecryptOpenError

func NewDecryptOpenError(what string) DecryptOpenError

func (DecryptOpenError) Error

func (d DecryptOpenError) Error() string

type DecryptWrongReceiverError

type DecryptWrongReceiverError struct{}

func (DecryptWrongReceiverError) Error

type DecryptionError

type DecryptionError struct {
	Cause ErrorCause
}

DecryptionError is the default decryption error

func (DecryptionError) Error

func (e DecryptionError) Error() string

func (DecryptionError) ToStatus

func (e DecryptionError) ToStatus() keybase1.Status

type Delegation

type Delegation struct {
	KID   keybase1.KID
	SigID keybase1.SigID
}

Struct for the DelegationsList

type DelegationType

type DelegationType LinkType

type Delegator

type Delegator struct {
	Contextified

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

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

func (*Delegator) CheckArgs

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

func (Delegator) GetMerkleTriple

func (d Delegator) GetMerkleTriple() MerkleTriple

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

func (Delegator) GetSigningKey

func (d Delegator) GetSigningKey() GenericKey

func (Delegator) IsEldest

func (d Delegator) IsEldest() bool

func (Delegator) IsSibkeyOrEldest

func (d Delegator) IsSibkeyOrEldest() bool

func (*Delegator) LoadSigningKey

func (d *Delegator) LoadSigningKey(m MetaContext, ui SecretUI) (err error)

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

func (*Delegator) Run

func (d *Delegator) Run(m MetaContext) (err error)

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

func (*Delegator) SignAndPost

func (d *Delegator) SignAndPost(m MetaContext, proof *ProofMetadataRes) (err error)

type DeriveReason

type DeriveReason string
const (
	DeriveReasonPUKSigning    DeriveReason = "Derived-User-NaCl-EdDSA-1"
	DeriveReasonPUKEncryption DeriveReason = "Derived-User-NaCl-DH-1"
	// Context used for chaining generations of PerUserKeys.
	DeriveReasonPUKPrev              DeriveReason = "Derived-User-NaCl-SecretBox-1"
	DeriveReasonPUKStellarBundle     DeriveReason = "Derived-User-NaCl-SecretBox-StellarBundle-1"
	DeriveReasonPUKStellarNoteSelf   DeriveReason = "Derived-User-NaCl-SecretBox-StellarSelfNote-1"
	DeriveReasonPUKStellarAcctBundle DeriveReason = "Derived-User-NaCl-SecretBox-StellarAcctBundle-1"

	DeriveReasonDeviceEKEncryption   DeriveReason = "Derived-Ephemeral-Device-NaCl-DH-1"
	DeriveReasonUserEKEncryption     DeriveReason = "Derived-Ephemeral-User-NaCl-DH-1"
	DeriveReasonTeamEKEncryption     DeriveReason = "Derived-Ephemeral-Team-NaCl-DH-1"
	DeriveReasonTeamEKExplodingChat  DeriveReason = "Derived-Ephemeral-Team-NaCl-SecretBox-ExplodingChat-1"
	DeriveReasonTeambotEKEncryption  DeriveReason = "Derived-Ephemeral-Teambot-NaCl-DH-1"
	DeriveReasonTeambotKeyEncryption DeriveReason = "Derived-Teambot-Key-NaCl-DH-1"

	DeriveReasonChatPairwiseMAC DeriveReason = "Derived-Chat-Pairwise-HMAC-SHA256-1"

	DeriveReasonLinuxRevokableKeyring DeriveReason = "Keybase-Derived-LKS-SecretBox-1"
)

type DesktopAppState

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

func NewDesktopAppState

func NewDesktopAppState(g *GlobalContext) *DesktopAppState

func (*DesktopAppState) AwakeAndUnlocked

func (a *DesktopAppState) AwakeAndUnlocked(mctx MetaContext) bool

func (*DesktopAppState) Disconnected

func (a *DesktopAppState) Disconnected(provider rpc.Transporter)

func (*DesktopAppState) NextSuspendUpdate

func (a *DesktopAppState) NextSuspendUpdate(lastState *bool) chan bool

func (*DesktopAppState) Update

func (a *DesktopAppState) Update(mctx MetaContext, event string, provider rpc.Transporter)

event from power monitor https://electronjs.org/docs/api/power-monitor

type Device

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

func NewPaperDevice

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

NewPaperDevice creates a new paper backup key device

func ParseDevice

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

func (*Device) Export

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

func (*Device) IsActive

func (d *Device) IsActive() bool

func (*Device) Merge

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

func (*Device) ProtExport

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

func (*Device) StatusString

func (d *Device) StatusString() string

type DeviceAlreadyProvisionedError

type DeviceAlreadyProvisionedError struct{}

func (DeviceAlreadyProvisionedError) Error

func (DeviceAlreadyProvisionedError) ToStatus

type DeviceBadNameError

type DeviceBadNameError struct{}

func (DeviceBadNameError) Error

func (e DeviceBadNameError) Error() string
type DeviceChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseDeviceChainLink(b GenericChainLink) (ret *DeviceChainLink, err error)

func (*DeviceChainLink) GetDevice

func (s *DeviceChainLink) GetDevice() *Device

type DeviceCloneState

type DeviceCloneState struct {
	Prior  string
	Stage  string
	Clones int
}

func GetDeviceCloneState

func GetDeviceCloneState(m MetaContext) (state DeviceCloneState, err error)

func (DeviceCloneState) IsClone

func (d DeviceCloneState) IsClone() bool

type DeviceCloneStateJSONFile

type DeviceCloneStateJSONFile struct {
	*JSONFile
}

type DeviceEKStorage

type DeviceEKStorage interface {
	Put(mctx MetaContext, generation keybase1.EkGeneration, deviceEK keybase1.DeviceEk) error
	Get(mctx MetaContext, generation keybase1.EkGeneration) (keybase1.DeviceEk, error)
	GetAllActive(mctx MetaContext, merkleRoot MerkleRoot) ([]keybase1.DeviceEkMetadata, error)
	MaxGeneration(mctx MetaContext, includeErrs bool) (keybase1.EkGeneration, error)
	DeleteExpired(mctx MetaContext, merkleRoot MerkleRoot) ([]keybase1.EkGeneration, error)
	ClearCache()
	// Dangerous! Only for deprovisioning or shutdown/logout when in oneshot mode.
	ForceDeleteAll(mctx MetaContext, username NormalizedUsername) error
	// For keybase log send
	ListAllForUser(mctx MetaContext) ([]string, error)
	// Called on login/logout hooks to set the logged in username in the EK log
	SetLogPrefix(mctx MetaContext)
}

type DeviceKey

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

func (DeviceKey) Display

func (d DeviceKey) Display() string

func (DeviceKey) ToLKSec

func (d DeviceKey) ToLKSec() (LKSecServerHalf, error)

type DeviceKeyMap

type DeviceKeyMap map[keybase1.DeviceID]DeviceKey

type DeviceNameInUseError

type DeviceNameInUseError struct{}

func (DeviceNameInUseError) Error

func (e DeviceNameInUseError) Error() string

func (DeviceNameInUseError) ToStatus

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

type DeviceNotFoundError

type DeviceNotFoundError struct {
	Where  string
	ID     keybase1.DeviceID
	Loaded bool
}

func (DeviceNotFoundError) Error

func (e DeviceNotFoundError) Error() string

type DeviceRequiredError

type DeviceRequiredError struct{}

func (DeviceRequiredError) Error

func (e DeviceRequiredError) Error() string

func (DeviceRequiredError) ToStatus

func (e DeviceRequiredError) ToStatus() keybase1.Status

type DeviceStatus

type DeviceStatus struct {
	Provisioned  bool
	Keyed        bool
	KeyAvailable bool
}

type DeviceTypeSet

type DeviceTypeSet map[keybase1.DeviceTypeV2]bool

type DeviceWithDeviceNumber

type DeviceWithDeviceNumber struct {
	*Device
	DeviceNumberOfType int
}

func (DeviceWithDeviceNumber) ProtExportWithDeviceNum

func (d DeviceWithDeviceNumber) ProtExportWithDeviceNum() *keybase1.Device

type DeviceWithKeys

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

func NewDeviceWithKeys

func NewDeviceWithKeys(signingKey, encryptionKey GenericKey, deviceID keybase1.DeviceID, deviceName string, keychainMode KeychainMode) *DeviceWithKeys

func NewDeviceWithKeysOnly

func NewDeviceWithKeysOnly(signingKey, encryptionKey GenericKey, keychainMode KeychainMode) *DeviceWithKeys

func (DeviceWithKeys) DeviceCtime

func (d DeviceWithKeys) DeviceCtime() keybase1.Time

func (DeviceWithKeys) DeviceID

func (d DeviceWithKeys) DeviceID() keybase1.DeviceID

func (DeviceWithKeys) DeviceName

func (d DeviceWithKeys) DeviceName() string

func (DeviceWithKeys) EncryptionKey

func (d DeviceWithKeys) EncryptionKey() GenericKey

func (DeviceWithKeys) HasBothKeys

func (d DeviceWithKeys) HasBothKeys() bool

func (*DeviceWithKeys) Populate

func (d *DeviceWithKeys) Populate(m MetaContext) (uid keybase1.UID, err error)

func (*DeviceWithKeys) SetDeviceInfo

func (d *DeviceWithKeys) SetDeviceInfo(i keybase1.DeviceID, n string)

func (DeviceWithKeys) SigningKey

func (d DeviceWithKeys) SigningKey() GenericKey

func (*DeviceWithKeys) ToProvisioningKeyActiveDevice

func (d *DeviceWithKeys) ToProvisioningKeyActiveDevice(m MetaContext, uv keybase1.UserVersion) *ActiveDevice

type DirExecError

type DirExecError struct {
	Path string
}

func (DirExecError) Error

func (e DirExecError) Error() string

type DiskInstrumentationStorage

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

func (*DiskInstrumentationStorage) Flush

func (s *DiskInstrumentationStorage) Flush(ctx context.Context) (err error)

func (*DiskInstrumentationStorage) GetAll

func (*DiskInstrumentationStorage) Put

func (*DiskInstrumentationStorage) Start

func (*DiskInstrumentationStorage) Stats

func (*DiskInstrumentationStorage) Stop

func (s *DiskInstrumentationStorage) Stop(ctx context.Context) chan struct{}

type DumbOutputUI

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

type DummyRuntimeStats

type DummyRuntimeStats struct{}

func NewDummyRuntimeStats

func NewDummyRuntimeStats() *DummyRuntimeStats

func (*DummyRuntimeStats) PushPerfEvent

func (d *DummyRuntimeStats) PushPerfEvent(keybase1.PerfEvent)

func (*DummyRuntimeStats) Start

func (d *DummyRuntimeStats) Start(context.Context)

func (*DummyRuntimeStats) Stop

func (d *DummyRuntimeStats) Stop(context.Context) chan struct{}

type EKLib

type EKLib interface {
	KeygenIfNeeded(mctx MetaContext) error
	// Team ephemeral keys
	GetOrCreateLatestTeamEK(mctx MetaContext, teamID keybase1.TeamID) (keybase1.TeamEphemeralKey, bool, error)
	GetTeamEK(mctx MetaContext, teamID keybase1.TeamID, generation keybase1.EkGeneration, contentCtime *gregor1.Time) (keybase1.TeamEphemeralKey, error)
	PurgeTeamEKCachesForTeamIDAndGeneration(mctx MetaContext, teamID keybase1.TeamID, generation keybase1.EkGeneration)
	PurgeTeamEKCachesForTeamID(mctx MetaContext, teamID keybase1.TeamID)

	// Teambot ephemeral keys
	GetOrCreateLatestTeambotEK(mctx MetaContext, teamID keybase1.TeamID, botUID gregor1.UID) (keybase1.TeamEphemeralKey, bool, error)
	GetTeambotEK(mctx MetaContext, teamID keybase1.TeamID, botUID gregor1.UID, generation keybase1.EkGeneration,
		contentCtime *gregor1.Time) (keybase1.TeamEphemeralKey, error)
	ForceCreateTeambotEK(mctx MetaContext, teamID keybase1.TeamID, botUID gregor1.UID,
		generation keybase1.EkGeneration) (keybase1.TeamEphemeralKey, bool, error)
	PurgeTeambotEKCachesForTeamIDAndGeneration(mctx MetaContext, teamID keybase1.TeamID, generation keybase1.EkGeneration)
	PurgeTeambotEKCachesForTeamID(mctx MetaContext, teamID keybase1.TeamID)
	PurgeAllTeambotMetadataCaches(mctx MetaContext)
	PurgeTeambotMetadataCache(mctx MetaContext, teamID keybase1.TeamID, botUID keybase1.UID, generation keybase1.EkGeneration)

	NewEphemeralSeed() (keybase1.Bytes32, error)
	DeriveDeviceDHKey(seed keybase1.Bytes32) *NaclDHKeyPair
	SignedDeviceEKStatementFromSeed(mctx MetaContext, generation keybase1.EkGeneration, seed keybase1.Bytes32, signingKey GenericKey) (keybase1.DeviceEkStatement, string, error)
	BoxLatestUserEK(mctx MetaContext, receiverKey NaclDHKeyPair, deviceEKGeneration keybase1.EkGeneration) (*keybase1.UserEkBoxed, error)
	PrepareNewUserEK(mctx MetaContext, merkleRoot MerkleRoot, pukSeed PerUserKeySeed) (string, []keybase1.UserEkBoxMetadata, keybase1.UserEkMetadata, *keybase1.UserEkBoxed, error)
	BoxLatestTeamEK(mctx MetaContext, teamID keybase1.TeamID, uids []keybase1.UID) (*[]keybase1.TeamEkBoxMetadata, error)
	PrepareNewTeamEK(mctx MetaContext, teamID keybase1.TeamID, signingKey NaclSigningKeyPair, uids []keybase1.UID) (string, *[]keybase1.TeamEkBoxMetadata, keybase1.TeamEkMetadata, *keybase1.TeamEkBoxed, error)
	ClearCaches(mctx MetaContext)
	// For testing
	NewTeamEKNeeded(mctx MetaContext, teamID keybase1.TeamID) (bool, error)
}
type EldestChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseEldestChainLink(b GenericChainLink) (ret *EldestChainLink, err error)

func (*EldestChainLink) GetDelegatedKid

func (s *EldestChainLink) GetDelegatedKid() keybase1.KID

func (*EldestChainLink) GetDevice

func (s *EldestChainLink) GetDevice() *Device

func (*EldestChainLink) GetPGPFullHash

func (s *EldestChainLink) GetPGPFullHash() string

func (*EldestChainLink) GetRole

func (s *EldestChainLink) GetRole() KeyRole

func (*EldestChainLink) ToDisplayString

func (s *EldestChainLink) ToDisplayString() string

func (*EldestChainLink) Type

func (s *EldestChainLink) Type() string

type EldestSeqnoMissingError

type EldestSeqnoMissingError struct{}

func (EldestSeqnoMissingError) Error

func (e EldestSeqnoMissingError) Error() string

type EmptyKeyRing

type EmptyKeyRing struct{}

func (EmptyKeyRing) DecryptionKeys

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

func (EmptyKeyRing) KeysById

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

func (EmptyKeyRing) KeysByIdUsage

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

type EncryptionReason

type EncryptionReason string
const (
	EncryptionReasonChatLocalStorage        EncryptionReason = "Keybase-Chat-Local-Storage-1"
	EncryptionReasonChatMessage             EncryptionReason = "Keybase-Chat-Message-1"
	EncryptionReasonChatIndexerTokenKey     EncryptionReason = "Keybase-Chat-IndexerTokenKey-1"
	EncryptionReasonChatIndexerAliasKey     EncryptionReason = "Keybase-Chat-IndexerAliasKey-1"
	EncryptionReasonTeamsLocalStorage       EncryptionReason = "Keybase-Teams-Local-Storage-1"
	EncryptionReasonTeamsFTLLocalStorage    EncryptionReason = "Keybase-Teams-FTL-Local-Storage-1"
	EncryptionReasonTeamsHiddenLocalStorage EncryptionReason = "Keybase-Teams-Hidden-Local-Storage-1"
	EncryptionReasonErasableKVLocalStorage  EncryptionReason = "Keybase-Erasable-KV-Local-Storage-1"
	EncryptionReasonTeambotEphemeralKey     EncryptionReason = "Keybase-Teambot-Ephemeral-Key-1"
	EncryptionReasonTeambotKey              EncryptionReason = "Keybase-Teambot-Key-1"
	EncryptionReasonContactsLocalStorage    EncryptionReason = "Keybase-Contacts-Local-Storage-1"
	EncryptionReasonContactsResolvedServer  EncryptionReason = "Keybase-Contacts-Resolved-Server-1"
	EncryptionReasonTeambotKeyLocalStorage  EncryptionReason = "Keybase-Teambot-Key-Local-Storage-1"
	EncryptionReasonKBFSFavorites           EncryptionReason = "kbfs.favorites" // legacy const for kbfs favorites
)

func (EncryptionReason) Bytes

func (r EncryptionReason) Bytes() []byte

type Engine2

type Engine2 interface {
	Run(MetaContext) error
	Prereqs() EnginePrereqs
	UIConsumer
}

type EnginePrereqs

type EnginePrereqs struct {
	TemporarySession bool
	Device           bool
}

type Env

type Env struct {
	sync.RWMutex

	HomeFinder HomeFinder

	Test *TestParameters
	// contains filtered or unexported fields
}

func NewEnv

func NewEnv(cmd CommandLine, config ConfigReader, getLog LogGetter) *Env

func (*Env) AllowPTrace

func (e *Env) AllowPTrace() bool

func (*Env) ForceSecretStoreFile

func (e *Env) ForceSecretStoreFile() bool

func (*Env) GetAPIDump

func (e *Env) GetAPIDump() bool

func (*Env) GetAPITimeout

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

func (*Env) GetAllowRoot

func (e *Env) GetAllowRoot() bool

func (*Env) GetAppType

func (e *Env) GetAppType() AppType

func (*Env) GetAttachmentDisableMulti

func (e *Env) GetAttachmentDisableMulti() bool

func (*Env) GetAttachmentHTTPStartPort

func (e *Env) GetAttachmentHTTPStartPort() int

func (*Env) GetAutoFork

func (e *Env) GetAutoFork() bool

func (*Env) GetAvatarSource

func (e *Env) GetAvatarSource() string

func (*Env) GetBGIdentifierDisabled

func (e *Env) GetBGIdentifierDisabled() bool

func (*Env) GetBool

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

func (*Env) GetBundledCA

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

func (*Env) GetCacheDir

func (e *Env) GetCacheDir() string

func (*Env) GetChatDbFilename

func (e *Env) GetChatDbFilename() string

func (*Env) GetChatDelivererInterval

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

func (*Env) GetChatInboxSourceLocalizeThreads

func (e *Env) GetChatInboxSourceLocalizeThreads() int

func (*Env) GetChatMemberType

func (e *Env) GetChatMemberType() string

GetChatMemberType returns the default member type for new conversations.

func (*Env) GetCodeSigningKIDs

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

func (*Env) GetCommandLine

func (e *Env) GetCommandLine() CommandLine

func (*Env) GetConfig

func (e *Env) GetConfig() ConfigReader

func (*Env) GetConfigDir

func (e *Env) GetConfigDir() string

func (*Env) GetConfigFilename

func (e *Env) GetConfigFilename() string

func (*Env) GetConfigWriter

func (e *Env) GetConfigWriter() ConfigWriter

func (*Env) GetConvSourceType

func (e *Env) GetConvSourceType() string

func (*Env) GetDataDir

func (e *Env) GetDataDir() string

func (*Env) GetDbFilename

func (e *Env) GetDbFilename() string

func (*Env) GetDebug

func (e *Env) GetDebug() bool

func (*Env) GetDebugJourneycard

func (e *Env) GetDebugJourneycard() bool

GetDebugJourneycard enables experimental chat journey cards.

func (*Env) GetDefaultLogFile

func (e *Env) GetDefaultLogFile() string

func (*Env) GetDeviceCloneStateFilename

func (e *Env) GetDeviceCloneStateFilename() string

func (*Env) GetDeviceID

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

func (*Env) GetDeviceIDForUID

func (e *Env) GetDeviceIDForUID(u keybase1.UID) keybase1.DeviceID

func (*Env) GetDeviceIDForUsername

func (e *Env) GetDeviceIDForUsername(u NormalizedUsername) keybase1.DeviceID

func (*Env) GetDisableBgConvLoader

func (e *Env) GetDisableBgConvLoader() bool

func (*Env) GetDisableEKBackgroundKeygen

func (e *Env) GetDisableEKBackgroundKeygen() bool

func (*Env) GetDisableMerkleAuditor

func (e *Env) GetDisableMerkleAuditor() bool

func (*Env) GetDisableSearchIndexer

func (e *Env) GetDisableSearchIndexer() bool

func (*Env) GetDisableTeamAuditor

func (e *Env) GetDisableTeamAuditor() bool

func (*Env) GetDisableTeamBoxAuditor

func (e *Env) GetDisableTeamBoxAuditor() bool

func (*Env) GetDisplayRawUntrustedOutput

func (e *Env) GetDisplayRawUntrustedOutput() bool

func (*Env) GetDoLogForward

func (e *Env) GetDoLogForward() bool

func (*Env) GetDownloadsDir

func (e *Env) GetDownloadsDir() string

func (*Env) GetDuration

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

func (*Env) GetEKLogFile

func (e *Env) GetEKLogFile() string

func (*Env) GetEffectiveLogFile

func (e *Env) GetEffectiveLogFile() (filename string, ok bool)

func (*Env) GetEmail

func (e *Env) GetEmail() string

func (*Env) GetEmailOrUsername

func (e *Env) GetEmailOrUsername() string

func (*Env) GetEnableBotLiteMode

func (e *Env) GetEnableBotLiteMode() bool

func (*Env) GetEnvFileDir

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

func (*Env) GetEnvfileName

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

func (*Env) GetExternalURLKitFilename

func (e *Env) GetExternalURLKitFilename() string

GetExternalURLKitFilename gets the path to param proof kit file. Its value is usually "" which means to use the server.

func (*Env) GetExtraNetLogging

func (e *Env) GetExtraNetLogging() bool

func (*Env) GetFeatureFlags

func (e *Env) GetFeatureFlags() FeatureFlags

func (*Env) GetForceLinuxKeyring

func (e *Env) GetForceLinuxKeyring() bool

func (*Env) GetGUIConfig

func (e *Env) GetGUIConfig() *JSONFile

func (*Env) GetGUIConfigFilename

func (e *Env) GetGUIConfigFilename() string

func (*Env) GetGUILogFile

func (e *Env) GetGUILogFile() string

func (*Env) GetGpg

func (e *Env) GetGpg() string

func (*Env) GetGpgHome

func (e *Env) GetGpgHome() string

func (*Env) GetGpgOptions

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

func (*Env) GetGregorDisabled

func (e *Env) GetGregorDisabled() bool

func (*Env) GetGregorPingInterval

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

func (*Env) GetGregorPingTimeout

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

func (*Env) GetGregorSaveInterval

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

func (*Env) GetGregorURI

func (e *Env) GetGregorURI() string

func (*Env) GetHome

func (e *Env) GetHome() string

func (*Env) GetInboxSourceType

func (e *Env) GetInboxSourceType() string

func (*Env) GetInfoDir

func (e *Env) GetInfoDir() string

func (*Env) GetInstallID

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

func (*Env) GetInt

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

func (*Env) GetKBFSInfoPath

func (e *Env) GetKBFSInfoPath() string

GetKBFSInfoPath returns path to info file written by the KBFS service after startup

func (*Env) GetLabel

func (e *Env) GetLabel() string

func (*Env) GetLevelDBNumFiles

func (e *Env) GetLevelDBNumFiles() int

func (*Env) GetLevelDBWriteBufferMB

func (e *Env) GetLevelDBWriteBufferMB() int

func (*Env) GetLinkCacheCleanDur

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

func (*Env) GetLinkCacheSize

func (e *Env) GetLinkCacheSize() int

func (*Env) GetLocalRPCDebug

func (e *Env) GetLocalRPCDebug() string

func (*Env) GetLocalTrackMaxAge

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

func (*Env) GetLogDir

func (e *Env) GetLogDir() string

func (*Env) GetLogFile

func (e *Env) GetLogFile() string

func (*Env) GetLogFileConfig

func (e *Env) GetLogFileConfig(filename string) *logger.LogFileConfig

func (*Env) GetLogFormat

func (e *Env) GetLogFormat() string

func (*Env) GetLogPrefix

func (e *Env) GetLogPrefix() string

func (*Env) GetMerkleKIDs

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

func (*Env) GetMobileSharedHome

func (e *Env) GetMobileSharedHome() string

func (*Env) GetMountDir

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

func (*Env) GetMountDirDefault

func (e *Env) GetMountDirDefault() string

func (*Env) GetNegBool

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

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

func (*Env) GetNoPinentry

func (e *Env) GetNoPinentry() bool

func (*Env) GetOldMountDirDefault

func (e *Env) GetOldMountDirDefault() string

func (*Env) GetOverrideEnvfileName

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

func (*Env) GetParamProofKitFilename

func (e *Env) GetParamProofKitFilename() string

GetParamProofKitFilename gets the path to param proof kit file. Its value is usually "" which means to use the server.

func (*Env) GetPayloadCacheSize

func (e *Env) GetPayloadCacheSize() int

func (*Env) GetPerfLogFile

func (e *Env) GetPerfLogFile() string

func (*Env) GetPidFile

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

func (*Env) GetPinentry

func (e *Env) GetPinentry() string

func (*Env) GetProofCacheLongDur

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

func (*Env) GetProofCacheMediumDur

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

func (*Env) GetProofCacheShortDur

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

func (*Env) GetProofCacheSize

func (e *Env) GetProofCacheSize() int

func (*Env) GetProveBypass

func (e *Env) GetProveBypass() bool

GetProveBypass ignores creation_disabled so that the client will let the user try to make a proof for any known service.

func (*Env) GetProxy

func (e *Env) GetProxy() string

Get the address (optionally including a port) of the currently configured proxy. Returns an empty string if no proxy is configured.

func (*Env) GetProxyType

func (e *Env) GetProxyType() ProxyType

Get the ProxyType based off of the configured proxy and tor settings

func (*Env) GetPvlKitFilename

func (e *Env) GetPvlKitFilename() string

GetPvlKitFilename gets the path to pvl kit file. Its value is usually "" which means to use the server.

func (*Env) GetReadDeletedSigChain

func (e *Env) GetReadDeletedSigChain() bool

func (*Env) GetRememberPassphrase

func (e *Env) GetRememberPassphrase(username NormalizedUsername) bool

func (*Env) GetRootConfigDirectory

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

func (*Env) GetRootConfigFilename

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

func (*Env) GetRootRedirectorMount

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

func (*Env) GetRunMode

func (e *Env) GetRunMode() RunMode

func (*Env) GetRunModeAsString

func (e *Env) GetRunModeAsString() string

func (*Env) GetRuntimeDir

func (e *Env) GetRuntimeDir() string

func (*Env) GetRuntimeStatsEnabled

func (e *Env) GetRuntimeStatsEnabled() bool

func (*Env) GetSandboxCacheDir

func (e *Env) GetSandboxCacheDir() string

func (*Env) GetScraperTimeout

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

func (*Env) GetSecretKeyringTemplate

func (e *Env) GetSecretKeyringTemplate() string

func (*Env) GetSecretStorePrimingDisabled

func (e *Env) GetSecretStorePrimingDisabled() bool

func (*Env) GetServerURI

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

func (*Env) GetServiceInfoPath

func (e *Env) GetServiceInfoPath() string

GetServiceInfoPath returns path to info file written by the Keybase service after startup

func (*Env) GetServiceSpawnDir

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

func (*Env) GetServiceType

func (e *Env) GetServiceType() string

func (*Env) GetSessionFilename

func (e *Env) GetSessionFilename() string

func (*Env) GetSharedCacheDir

func (e *Env) GetSharedCacheDir() string

func (*Env) GetSharedDataDir

func (e *Env) GetSharedDataDir() string

func (*Env) GetSkipLogoutIfRevokedCheck

func (e *Env) GetSkipLogoutIfRevokedCheck() bool

If true, do not logout after user.key_change notification handler decides that current device has been revoked.

func (*Env) GetSlowGregorConn

func (e *Env) GetSlowGregorConn() bool

func (*Env) GetSocketBindFile

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

func (*Env) GetSocketDialFiles

func (e *Env) GetSocketDialFiles() ([]string, error)

func (*Env) GetStandalone

func (e *Env) GetStandalone() bool

func (*Env) GetStayLoggedOut

func (e *Env) GetStayLoggedOut() bool

func (*Env) GetStoredSecretAccessGroup

func (e *Env) GetStoredSecretAccessGroup() string

func (*Env) GetStoredSecretServiceBaseName

func (e *Env) GetStoredSecretServiceBaseName() string

func (*Env) GetStoredSecretServiceName

func (e *Env) GetStoredSecretServiceName() string

func (*Env) GetString

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

func (*Env) GetStringList

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

func (*Env) GetTimers

func (e *Env) GetTimers() string

func (*Env) GetTorHiddenAddress

func (e *Env) GetTorHiddenAddress() string

func (*Env) GetTorMode

func (e *Env) GetTorMode() TorMode

func (*Env) GetTorProxy

func (e *Env) GetTorProxy() string

func (*Env) GetUID

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

func (*Env) GetUIDMapFullNameCacheSize

func (e *Env) GetUIDMapFullNameCacheSize() int

func (*Env) GetUPAKCacheSize

func (e *Env) GetUPAKCacheSize() int

func (*Env) GetUpdateDefaultInstructions

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

func (*Env) GetUpdateDisabled

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

func (*Env) GetUpdateLastChecked

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

func (*Env) GetUpdatePreferenceAuto

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

func (*Env) GetUpdatePreferenceSkip

func (e *Env) GetUpdatePreferenceSkip() string

func (*Env) GetUpdatePreferenceSnoozeUntil

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

func (*Env) GetUpdateURL

func (e *Env) GetUpdateURL() string

func (*Env) GetUpdaterConfig

func (e *Env) GetUpdaterConfig() UpdaterConfigReader

func (*Env) GetUpdaterConfigFilename

func (e *Env) GetUpdaterConfigFilename() string

func (*Env) GetUpgradePerUserKey

func (e *Env) GetUpgradePerUserKey() bool

Upgrade sigchains to contain per-user-keys.

func (*Env) GetUseDefaultLogFile

func (e *Env) GetUseDefaultLogFile() bool

func (*Env) GetUseRootConfigFile

func (e *Env) GetUseRootConfigFile() bool

func (*Env) GetUserCacheMaxAge

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

func (*Env) GetUsername

func (e *Env) GetUsername() NormalizedUsername

func (*Env) GetUsernameForUID

func (e *Env) GetUsernameForUID(u keybase1.UID) NormalizedUsername

func (*Env) GetVDebugSetting

func (e *Env) GetVDebugSetting() string

func (*Env) IsCertPinningEnabled

func (e *Env) IsCertPinningEnabled() bool

func (*Env) IsMobileExtension

func (e *Env) IsMobileExtension() bool

func (*Env) ModelessWantsSystemd

func (e *Env) ModelessWantsSystemd() bool

func (*Env) RunningInCI

func (e *Env) RunningInCI() bool

func (*Env) SendSystemChatMessages

func (e *Env) SendSystemChatMessages() bool

func (*Env) SetCommandLine

func (e *Env) SetCommandLine(cmd CommandLine)

func (*Env) SetConfig

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

func (*Env) SetGUIConfig

func (e *Env) SetGUIConfig(j *JSONFile)

func (*Env) SetUpdateLastChecked

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

func (*Env) SetUpdatePreferenceAuto

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

func (*Env) SetUpdatePreferenceSkip

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

func (*Env) SetUpdatePreferenceSnoozeUntil

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

func (*Env) SetUpdaterConfig

func (e *Env) SetUpdaterConfig(r UpdaterConfigReader)

func (*Env) UseTimeClockForNISTs

func (e *Env) UseTimeClockForNISTs() bool

func (*Env) WantsSystemd

func (e *Env) WantsSystemd() bool

type EnvGetter

type EnvGetter func(s string) string

type EphemeralPairwiseMACsMissingUIDsError

type EphemeralPairwiseMACsMissingUIDsError struct{ UIDs []keybase1.UID }

func NewEphemeralPairwiseMACsMissingUIDsError

func NewEphemeralPairwiseMACsMissingUIDsError(uids []keybase1.UID) EphemeralPairwiseMACsMissingUIDsError

func (EphemeralPairwiseMACsMissingUIDsError) Error

func (EphemeralPairwiseMACsMissingUIDsError) ToStatus

type ErasableKVStore

type ErasableKVStore interface {
	Put(mctx MetaContext, key string, val interface{}) error
	Get(mctx MetaContext, key string, val interface{}) error
	Erase(mctx MetaContext, key string) error
	AllKeys(mctx MetaContext, keySuffix string) ([]string, error)
}

type ErrorCause

type ErrorCause struct {
	Err        error
	StatusCode int
}

type ErrorMockAPI

type ErrorMockAPI struct{}

func (*ErrorMockAPI) Delete

func (n *ErrorMockAPI) Delete(MetaContext, APIArg) (*APIRes, error)

func (*ErrorMockAPI) Get

func (*ErrorMockAPI) GetDecode

func (*ErrorMockAPI) GetDecodeCtx

func (*ErrorMockAPI) GetResp

func (n *ErrorMockAPI) GetResp(MetaContext, APIArg) (*http.Response, func(), error)

func (*ErrorMockAPI) Post

func (n *ErrorMockAPI) Post(MetaContext, APIArg) (*APIRes, error)

func (*ErrorMockAPI) PostDecode

func (*ErrorMockAPI) PostDecodeCtx

func (*ErrorMockAPI) PostJSON

func (n *ErrorMockAPI) PostJSON(MetaContext, APIArg) (*APIRes, error)

func (*ErrorMockAPI) PostRaw

type ErrorUnwrapper

type ErrorUnwrapper struct {
	Contextified
}

func NewContextifiedErrorUnwrapper

func NewContextifiedErrorUnwrapper(g *GlobalContext) ErrorUnwrapper

func (ErrorUnwrapper) MakeArg

func (c ErrorUnwrapper) MakeArg() interface{}

func (ErrorUnwrapper) UnwrapError

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

type ExistsError

type ExistsError struct {
	Msg string
}

func (ExistsError) Error

func (e ExistsError) Error() string

func (ExistsError) ToStatus

func (e ExistsError) ToStatus() keybase1.Status

type ExportableError

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

type ExportedStream

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

func (*ExportedStream) Export

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

type ExportedStreams

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

func NewExportedStreams

func NewExportedStreams() *ExportedStreams

func (*ExportedStreams) Close

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

func (*ExportedStreams) ExportReader

func (s *ExportedStreams) ExportReader(r ReadCloseSeeker) keybase1.Stream

func (*ExportedStreams) ExportWriter

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

func (*ExportedStreams) GetReader

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

func (*ExportedStreams) GetWriter

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

func (*ExportedStreams) Read

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

func (*ExportedStreams) Reset

func (*ExportedStreams) Write

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

type ExternalAPIEngine

type ExternalAPIEngine struct {
	BaseAPIEngine
}

func (*ExternalAPIEngine) DoRequest

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

func (*ExternalAPIEngine) Get

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

func (*ExternalAPIEngine) GetHTML

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

func (*ExternalAPIEngine) GetText

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

func (*ExternalAPIEngine) Post

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

func (*ExternalAPIEngine) PostHTML

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

type ExternalAPIRes

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

type ExternalHTMLRes

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

type ExternalServicesCollector

type ExternalServicesCollector interface {
	GetServiceType(context.Context, string) ServiceType
	ListProofCheckers(MetaContext) []string
	ListServicesThatAcceptNewProofs(MetaContext) []string
	ListDisplayConfigs(MetaContext) (res []keybase1.ServiceDisplayConfig)
	SuggestionFoldPriority(MetaContext) int
	Shutdown()
}

type ExternalTextRes

type ExternalTextRes struct {
	HTTPStatus int
	Body       string
}

type FailedAssertionError

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

func (FailedAssertionError) Error

func (u FailedAssertionError) Error() string

type FakeGregorState

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

func (*FakeGregorState) DismissCategory

func (f *FakeGregorState) DismissCategory(ctx context.Context, cat gregor1.Category) error

func (*FakeGregorState) DismissItem

func (*FakeGregorState) InjectItem

func (f *FakeGregorState) InjectItem(ctx context.Context, cat string, body []byte, dtime gregor1.TimeOrOffset) (gregor1.MsgID, error)

func (*FakeGregorState) LocalDismissItem

func (f *FakeGregorState) LocalDismissItem(ctx context.Context, id gregor.MsgID) error

func (*FakeGregorState) PeekDismissedIDs

func (f *FakeGregorState) PeekDismissedIDs() []gregor.MsgID

func (*FakeGregorState) State

func (*FakeGregorState) UpdateCategory

func (f *FakeGregorState) UpdateCategory(ctx context.Context, cat string, body []byte,
	dtime gregor1.TimeOrOffset) (gregor1.MsgID, error)

type FastTeamLoader

type FastTeamLoader interface {
	Load(MetaContext, keybase1.FastTeamLoadArg) (keybase1.FastTeamLoadRes, error)
	// Untrusted hint of what a team's latest seqno is
	HintLatestSeqno(m MetaContext, id keybase1.TeamID, seqno keybase1.Seqno) error
	VerifyTeamName(m MetaContext, id keybase1.TeamID, name keybase1.TeamName, forceRefresh bool) error
	ForceRepollUntil(m MetaContext, t gregor.TimeOrOffset) error
	// See comment in TeamLoader#Freeze.
	Freeze(MetaContext, keybase1.TeamID) error
	// See comment in TeamLoader#Tombstone.
	Tombstone(MetaContext, keybase1.TeamID) error
}

type Feature

type Feature string

type FeatureFlagError

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

func (FeatureFlagError) Error

func (f FeatureFlagError) Error() string

func (FeatureFlagError) Feature

func (f FeatureFlagError) Feature() Feature

func (FeatureFlagError) ToStatus

func (e FeatureFlagError) ToStatus() (ret keybase1.Status)

type FeatureFlagGate

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

FeatureFlagGate allows the server to disable certain features by replying with a FEATURE_FLAG API status code, which is then translated into a FeatureFlagError. We cache these errors for a given amount of time, so we're not spamming the same attempt over and over again.

func NewFeatureFlagGate

func NewFeatureFlagGate(f Feature, d time.Duration) *FeatureFlagGate

NewFeatureFlagGate makes a gate for the given feature that will cache for the given duration.

func (*FeatureFlagGate) Clear

func (f *FeatureFlagGate) Clear()

func (*FeatureFlagGate) DigestError

func (f *FeatureFlagGate) DigestError(m MetaContext, err error)

DigestError should be called on the result of an API call. It will allow this gate to digest the error and maybe set up its internal caching for when to retry this feature.

func (*FeatureFlagGate) ErrorIfFlagged

func (f *FeatureFlagGate) ErrorIfFlagged(m MetaContext) (err error)

ErrorIfFlagged should be called to avoid a feature if it's recently been feature-flagged "off" by the server. In that case, it will return the error that was originally returned by the server.

type FeatureFlagSet

type FeatureFlagSet struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

FeatureFlagSet is a set of feature flags for a given user. It will keep track of whether a feature is on or off, and how long until we should check to update

func NewFeatureFlagSet

func NewFeatureFlagSet() *FeatureFlagSet

NewFeatureFlagSet makes a new set of feature flags.

func (*FeatureFlagSet) Clear

func (s *FeatureFlagSet) Clear()

Clear clears out the cached feature flags, for instance if the user is going to logout.

func (*FeatureFlagSet) Enabled

func (s *FeatureFlagSet) Enabled(m MetaContext, f Feature) (on bool)

Enabled returns if the feature flag is enabled. It ignore errors and just acts as if the feature is off.

func (*FeatureFlagSet) EnabledWithError

func (s *FeatureFlagSet) EnabledWithError(m MetaContext, f Feature) (on bool, err error)

EnabledWithError returns if the given feature is enabled, it will return true if it's enabled, and an error if one occurred.

func (*FeatureFlagSet) InvalidateCache

func (s *FeatureFlagSet) InvalidateCache(m MetaContext, f Feature)

type FeatureFlags

type FeatureFlags []Feature

func StringToFeatureFlags

func StringToFeatureFlags(s string) (ret FeatureFlags)

StringToFeatureFlags returns a set of feature flags

func (FeatureFlags) Admin

func (set FeatureFlags) Admin(uid keybase1.UID) bool

Admin returns true if the admin feature set is on or the user is a keybase admin.

func (FeatureFlags) Empty

func (set FeatureFlags) Empty() bool

func (FeatureFlags) HasFeature

func (set FeatureFlags) HasFeature(feature Feature) bool

type FetchWotVouchesArg

type FetchWotVouchesArg struct {
	Vouchee string
	Voucher string
}

type File

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

File defines a default SafeWriter implementation

func NewFile

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

NewFile returns a File

func (File) GetFilename

func (f File) GetFilename() string

GetFilename is for SafeWriter

func (File) Save

func (f File) Save(g SafeWriteLogger) error

Save file

func (File) WriteTo

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

WriteTo is for SafeWriter

type FileErasableKVStore

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

File based erasable kv store. Thread safe. We encrypt all data stored here with a mix of the device long term key and a large random noise file. We use the random noise file to make it more difficult to recover the encrypted data once the noise file is wiped from the filesystem as is done for the secret_store_file.

func NewFileErasableKVStore

func NewFileErasableKVStore(mctx MetaContext, subDir string, keygen keygenFunc) *FileErasableKVStore

func (*FileErasableKVStore) AllKeys

func (s *FileErasableKVStore) AllKeys(mctx MetaContext, keySuffix string) (keys []string, err error)

func (*FileErasableKVStore) Erase

func (s *FileErasableKVStore) Erase(mctx MetaContext, key string) (err error)

func (*FileErasableKVStore) Get

func (s *FileErasableKVStore) Get(mctx MetaContext, key string, val interface{}) (err error)

func (*FileErasableKVStore) Put

func (s *FileErasableKVStore) Put(mctx MetaContext, key string, val interface{}) (err error)

type FileExecError

type FileExecError struct {
	Path string
}

func (FileExecError) Error

func (e FileExecError) Error() string

type FirstErrorPicker

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

func (*FirstErrorPicker) Count

func (p *FirstErrorPicker) Count() int

func (*FirstErrorPicker) Error

func (p *FirstErrorPicker) Error() error

func (*FirstErrorPicker) Push

func (p *FirstErrorPicker) Push(e error)

type FollowDirection

type FollowDirection int
const (
	FollowDirectionFollowing FollowDirection = 0
	FollowDirectionFollowers FollowDirection = 1
)

type FullSelfer

type FullSelfer interface {
	WithSelf(ctx context.Context, f func(u *User) error) error
	WithSelfForcePoll(ctx context.Context, f func(u *User) error) error
	WithUser(arg LoadUserArg, f func(u *User) error) (err error)
	HandleUserChanged(u keybase1.UID) error
	Update(ctx context.Context, u *User) error
	New() FullSelfer
	OnLogin(mctx MetaContext) error
}

type GPGKey

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

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

func NewGPGKey

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

func (*GPGKey) CanDecrypt

func (g *GPGKey) CanDecrypt() bool

func (*GPGKey) CanEncrypt

func (g *GPGKey) CanEncrypt() bool

func (*GPGKey) CanSign

func (g *GPGKey) CanSign() bool

func (*GPGKey) CheckSecretKey

func (g *GPGKey) CheckSecretKey() error

func (*GPGKey) DecryptFromString

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

func (*GPGKey) Encode

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

func (*GPGKey) EncryptToString

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

func (*GPGKey) ExportPublicAndPrivate

func (g *GPGKey) ExportPublicAndPrivate() (RawPublicKey, RawPrivateKey, error)

func (*GPGKey) GetAlgoType

func (g *GPGKey) GetAlgoType() kbcrypto.AlgoType

func (*GPGKey) GetBinaryKID

func (g *GPGKey) GetBinaryKID() keybase1.BinaryKID

func (*GPGKey) GetFingerprintP

func (g *GPGKey) GetFingerprintP() *PGPFingerprint

func (*GPGKey) GetKID

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

func (*GPGKey) HasSecretKey

func (g *GPGKey) HasSecretKey() bool

func (*GPGKey) SecretSymmetricKey

func (g *GPGKey) SecretSymmetricKey(reason EncryptionReason) (NaclSecretBoxKey, error)

func (*GPGKey) SignToString

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

func (*GPGKey) SignToStringMctx

func (g *GPGKey) SignToStringMctx(mctx MetaContext, msg []byte) (sig string, id keybase1.SigIDBase, err error)

func (*GPGKey) VerboseDescription

func (g *GPGKey) VerboseDescription() string

func (*GPGKey) VerifyString

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

func (*GPGKey) VerifyStringAndExtract

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

type GPGUI

type GPGUI interface {
	keybase1.GpgUiInterface
}

type GPGUnavailableError

type GPGUnavailableError struct{}

func (GPGUnavailableError) Error

func (g GPGUnavailableError) Error() string

func (GPGUnavailableError) ToStatus

func (e GPGUnavailableError) ToStatus() keybase1.Status
type GenericChainLink struct {
	*ChainLink
}

func (*GenericChainLink) BaseToTrackingStatement

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

func (*GenericChainLink) DoOwnNewLinkFromServerNotifications

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

func (*GenericChainLink) GetArmoredSig

func (g *GenericChainLink) GetArmoredSig() string

func (*GenericChainLink) GetDelegatedKid

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

func (*GenericChainLink) GetDevice

func (g *GenericChainLink) GetDevice() *Device

func (*GenericChainLink) GetPGPFingerprint

func (g *GenericChainLink) GetPGPFingerprint() *PGPFingerprint

func (*GenericChainLink) GetPGPFullHash

func (g *GenericChainLink) GetPGPFullHash() string

func (*GenericChainLink) GetParentKid

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

func (*GenericChainLink) GetRole

func (g *GenericChainLink) GetRole() KeyRole

func (*GenericChainLink) GetSeqno

func (g *GenericChainLink) GetSeqno() keybase1.Seqno

func (*GenericChainLink) GetSigID

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

func (*GenericChainLink) GetUID

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

func (*GenericChainLink) GetUsername

func (g *GenericChainLink) GetUsername() string

func (*GenericChainLink) IsDirectlyRevoked

func (g *GenericChainLink) IsDirectlyRevoked() bool

func (*GenericChainLink) IsRevocationIsh

func (g *GenericChainLink) IsRevocationIsh() bool

func (*GenericChainLink) IsRevoked

func (g *GenericChainLink) IsRevoked() bool

func (*GenericChainLink) ToDebugString

func (g *GenericChainLink) ToDebugString() string

func (*GenericChainLink) ToDisplayString

func (g *GenericChainLink) ToDisplayString() string

func (*GenericChainLink) ToSigChainLocation

func (g *GenericChainLink) ToSigChainLocation() keybase1.SigChainLocation

func (*GenericChainLink) Type

func (g *GenericChainLink) Type() string

func (*GenericChainLink) VerifyReverseSig

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

type GenericKey

type GenericKey interface {
	GetKID() keybase1.KID
	GetBinaryKID() keybase1.BinaryKID
	GetAlgoType() kbcrypto.AlgoType

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

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

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

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

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

	// Derive a secret key from a DH secret key
	SecretSymmetricKey(reason EncryptionReason) (NaclSecretBoxKey, error)

	VerboseDescription() string
	CheckSecretKey() error
	CanSign() bool
	CanEncrypt() bool
	CanDecrypt() bool
	HasSecretKey() bool
	Encode() (string, error) // encode public key to string

	// ExportPublicAndPrivate to special-purpose types so there is no way we can
	// accidentally reverse them.
	ExportPublicAndPrivate() (public RawPublicKey, private RawPrivateKey, err error)
}

func ImportKeypairFromKID

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

type GetCacheDurationFunc

type GetCacheDurationFunc func(keybase1.Identify2ResUPK2) time.Duration

type GetCheckTimeFunc

type GetCheckTimeFunc func(keybase1.Identify2ResUPK2) keybase1.Time

type GetContactSettingsResponse

type GetContactSettingsResponse struct {
	AppStatusEmbed
	Settings keybase1.ContactSettings `json:"settings"`
}

type GetTlfPseudonymEither

type GetTlfPseudonymEither struct {
	// Exactly one of these 2 fields is nil.
	Err  error
	Info *TlfPseudonymServerInfo
}

func GetTlfPseudonyms

func GetTlfPseudonyms(ctx context.Context, g *GlobalContext, pnyms []TlfPseudonym) ([]GetTlfPseudonymEither, error)

GetTlfPseudonyms fetches info for a list of pseudonyms. The output structs are returned in the order corresponding to the inputs. The top-level error is filled if the entire request fails. The each-struct errors may be filled for per-pseudonym errors.

type GlobalContext

type GlobalContext struct {
	Log          logger.Logger         // Handles all logging
	PerfLog      logger.Logger         // Handles all performance event logging
	VDL          *VDebugLog            // verbose debug log
	GUILogFile   *logger.LogFileWriter // GUI logs
	Env          *Env                  // Env variables, cmdline args & config
	SKBKeyringMu *sync.Mutex           // Protects all attempts to mutate the SKBKeyringFile
	Keyrings     *Keyrings             // Gpg Keychains holding keys

	API                              API                         // How to make a REST call to the server
	Resolver                         Resolver                    // cache of resolve results
	LocalNetworkInstrumenterStorage  *DiskInstrumentationStorage // Instrument Local RPC calls
	RemoteNetworkInstrumenterStorage *DiskInstrumentationStorage // Instrument Remote API/RPC calls
	LocalDb                          *JSONLocalDb                // Local DB for cache
	LocalChatDb                      *JSONLocalDb                // Local DB for cache
	MerkleClient                     MerkleClientInterface       // client for querying server's merkle sig tree
	XAPI                             ExternalAPI                 // for contacting Twitter, Github, etc.
	DNSNSFetcher                     DNSNameServerFetcher        // The mobile apps potentially pass an implementor of this interface which is used to grab currently configured DNS name servers
	MobileNetState                   *MobileNetState             // The kind of network connection for the currently running instance of the app
	MobileAppState                   *MobileAppState             // The state of focus for the currently running instance of the app
	DesktopAppState                  *DesktopAppState            // The state of focus for the currently running instance of the app
	ChatHelper                       ChatHelper                  // conveniently send chat messages
	RPCCanceler                      *RPCCanceler                // register live RPCs so they can be cancelleed en masse
	IdentifyDispatch                 *IdentifyDispatch           // get notified of identify successes
	Identify3State                   *Identify3State             // keep track of Identify3 sessions

	RuntimeStats RuntimeStats // performance runtime stats

	ProofCache *ProofCache // where to cache proof results

	TeamRoleMapManager TeamRoleMapManager
	IDLocktab          *LockTable

	PayloadCache *PayloadCache // cache of ChainLink payload json wrappers

	Pegboard *Pegboard

	GpgClient     *GpgCLI        // A standard GPG-client (optional)
	ShutdownHooks []ShutdownHook // on shutdown, fire these...
	SocketInfo    Socket         // which socket to bind/connect to

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

	ConnectionManager *ConnectionManager // keep tabs on all active client connections
	NotifyRouter      *NotifyRouter      // How to route notifications
	// How to route UIs. Nil if we're in standalone mode or in
	// tests, and non-nil in service mode.
	UIRouter UIRouter // How to route UIs

	UIDMapper     UIDMapper            // maps from UID to Usernames
	ServiceMapper ServiceSummaryMapper // handles and caches batch requests for service summaries
	ExitCode      keybase1.ExitCode    // Value to return to OS on Exit()
	RateLimits    *RateLimits          // tracks the last time certain actions were taken

	GregorState    GregorState    // for dismissing gregor items that we've handled
	GregorListener GregorListener // for alerting about clients connecting and registering UI protocols

	UserChangedHandlers []UserChangedHandler // a list of handlers that deal generically with userchanged events
	ConnectivityMonitor ConnectivityMonitor  // Detect whether we're connected or not.

	FeatureFlags *FeatureFlagSet // user's feature flag set

	StandaloneChatConnector StandaloneChatConnector

	// Can be overloaded by tests to get an improvement in performance
	NewTriplesec func(pw []byte, salt []byte) (Triplesec, error)

	// Options specified for testing only
	TestOptions GlobalTestOptions

	ActiveDevice *ActiveDevice

	// OS Version passed from mobile native code. iOS and Android only.
	// See go/bind/keybase.go
	MobileOsVersion string
	IsIPad          bool

	SyncedContactList SyncedContactListProvider

	GUIConfig *JSONFile

	TeamMemberCountCache *TeamMemberCountCache
	// contains filtered or unexported fields
}

func MakeThinGlobalContextForTesting

func MakeThinGlobalContextForTesting(t TestingTB) *GlobalContext

func NewGlobalContext

func NewGlobalContext() *GlobalContext

Note: all these sync.Mutex fields are pointers so that the Clone funcs work.

func NewGlobalContextInit

func NewGlobalContextInit() *GlobalContext

func (*GlobalContext) AddDbNukeHook

func (g *GlobalContext) AddDbNukeHook(hook DbNukeHook, name string)

func (*GlobalContext) AddLoginHook

func (g *GlobalContext) AddLoginHook(hook LoginHook)

func (*GlobalContext) AddLogoutHook

func (g *GlobalContext) AddLogoutHook(hook LogoutHook, name string)

func (*GlobalContext) AddUserChangedHandler

func (g *GlobalContext) AddUserChangedHandler(h UserChangedHandler)

func (*GlobalContext) BindToSocket

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

func (*GlobalContext) BustLocalUserCache

func (g *GlobalContext) BustLocalUserCache(ctx context.Context, u keybase1.UID)

func (*GlobalContext) CPerfTrace

func (g *GlobalContext) CPerfTrace(ctx context.Context, msg string, err *error) func()

func (*GlobalContext) CTimeBuckets

func (*GlobalContext) CTimeTracer

func (g *GlobalContext) CTimeTracer(ctx context.Context, label string, enabled bool) profiling.TimeTracer

func (*GlobalContext) CTrace

func (g *GlobalContext) CTrace(ctx context.Context, msg string, err *error) func()

func (*GlobalContext) CVTrace

func (g *GlobalContext) CVTrace(ctx context.Context, lev VDebugLevel, msg string, err *error) func()

func (*GlobalContext) CallDbNukeHooks

func (g *GlobalContext) CallDbNukeHooks(mctx MetaContext)

func (*GlobalContext) CallLoginHooks

func (g *GlobalContext) CallLoginHooks(mctx MetaContext)

func (*GlobalContext) CallLogoutHooks

func (g *GlobalContext) CallLogoutHooks(mctx MetaContext)

func (*GlobalContext) CardCache

func (g *GlobalContext) CardCache() *UserCardCache

func (*GlobalContext) ClearPerUserKeyring

func (g *GlobalContext) ClearPerUserKeyring()

func (*GlobalContext) Clock

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

func (*GlobalContext) ConfigReload

func (g *GlobalContext) ConfigReload() error

func (*GlobalContext) Configure

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

func (*GlobalContext) ConfigureAPI

func (g *GlobalContext) ConfigureAPI() error

func (*GlobalContext) ConfigureCaches

func (g *GlobalContext) ConfigureCaches() error

func (*GlobalContext) ConfigureCommand

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

func (*GlobalContext) ConfigureConfig

func (g *GlobalContext) ConfigureConfig() error

func (*GlobalContext) ConfigureExportedStreams

func (g *GlobalContext) ConfigureExportedStreams() error

func (*GlobalContext) ConfigureGUIConfig

func (g *GlobalContext) ConfigureGUIConfig() error

func (*GlobalContext) ConfigureKeyring

func (g *GlobalContext) ConfigureKeyring() error

func (*GlobalContext) ConfigureLogging

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

ConfigureLogging should be given non-nil Usage if called by the main service.

func (*GlobalContext) ConfigureMerkleClient

func (g *GlobalContext) ConfigureMerkleClient() error

func (*GlobalContext) ConfigureSocketInfo

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

func (*GlobalContext) ConfigureTimers

func (g *GlobalContext) ConfigureTimers() error

func (*GlobalContext) ConfigureUpdaterConfig

func (g *GlobalContext) ConfigureUpdaterConfig() error

func (*GlobalContext) ConfigureUsage

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

func (*GlobalContext) FlushCaches

func (g *GlobalContext) FlushCaches()

func (*GlobalContext) GetAPI

func (g *GlobalContext) GetAPI() API

func (*GlobalContext) GetAllUserNames

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

func (*GlobalContext) GetAppType

func (g *GlobalContext) GetAppType() AppType

to implement ProofContext

func (*GlobalContext) GetAvatarLoader

func (g *GlobalContext) GetAvatarLoader() AvatarLoaderSource

func (*GlobalContext) GetCacheDir

func (g *GlobalContext) GetCacheDir() string

func (*GlobalContext) GetClock

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

func (*GlobalContext) GetConfigDir

func (g *GlobalContext) GetConfigDir() string

func (*GlobalContext) GetConfiguredAccounts

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

func (*GlobalContext) GetDNSNameServerFetcher

func (g *GlobalContext) GetDNSNameServerFetcher() DNSNameServerFetcher

func (*GlobalContext) GetDataDir

func (g *GlobalContext) GetDataDir() string

func (*GlobalContext) GetDeviceEKStorage

func (g *GlobalContext) GetDeviceEKStorage() DeviceEKStorage

func (*GlobalContext) GetEKLib

func (g *GlobalContext) GetEKLib() EKLib

func (*GlobalContext) GetEnv

func (g *GlobalContext) GetEnv() *Env

func (*GlobalContext) GetExternalAPI

func (g *GlobalContext) GetExternalAPI() ExternalAPI

func (*GlobalContext) GetExternalURLStore

func (g *GlobalContext) GetExternalURLStore() MerkleStore

func (*GlobalContext) GetFastTeamLoader

func (g *GlobalContext) GetFastTeamLoader() FastTeamLoader

func (*GlobalContext) GetFullSelfer

func (g *GlobalContext) GetFullSelfer() FullSelfer

func (*GlobalContext) GetGUILogWriter

func (g *GlobalContext) GetGUILogWriter() io.Writer

func (*GlobalContext) GetGpgClient

func (g *GlobalContext) GetGpgClient() *GpgCLI

func (*GlobalContext) GetHiddenTeamChainManager

func (g *GlobalContext) GetHiddenTeamChainManager() HiddenTeamChainManager

func (*GlobalContext) GetImplicitTeamCacher

func (g *GlobalContext) GetImplicitTeamCacher() MemLRUer

func (*GlobalContext) GetImplicitTeamConflictInfoCacher

func (g *GlobalContext) GetImplicitTeamConflictInfoCacher() LRUer

func (*GlobalContext) GetKBFSInfoPath

func (g *GlobalContext) GetKBFSInfoPath() string

GetKBFSInfoPath returns path to info file written by the KBFS service after startup

func (*GlobalContext) GetKVRevisionCache

func (g *GlobalContext) GetKVRevisionCache() KVRevisionCacher

func (*GlobalContext) GetKVStore

func (g *GlobalContext) GetKVStore() KVStorer

func (*GlobalContext) GetLog

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

func (*GlobalContext) GetLogDir

func (g *GlobalContext) GetLogDir() string

func (*GlobalContext) GetLogf

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

GetLogf returns a logger with a minimal formatter style interface

func (*GlobalContext) GetMeUV

func (g *GlobalContext) GetMeUV(ctx context.Context) (res keybase1.UserVersion, err error)

func (*GlobalContext) GetMerkleClient

func (g *GlobalContext) GetMerkleClient() MerkleClientInterface

func (*GlobalContext) GetMountDir

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

func (*GlobalContext) GetMyClientDetails

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

func (*GlobalContext) GetMyUID

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

func (*GlobalContext) GetOutOfDateInfo

func (g *GlobalContext) GetOutOfDateInfo() keybase1.OutOfDateInfo

func (*GlobalContext) GetParamProofStore

func (g *GlobalContext) GetParamProofStore() MerkleStore

func (*GlobalContext) GetPerUserKeyring

func (g *GlobalContext) GetPerUserKeyring(ctx context.Context) (ret *PerUserKeyring, err error)

GetPerUserKeyring recreates PerUserKeyring if the uid changes or this is none installed.

func (*GlobalContext) GetPerfLog

func (g *GlobalContext) GetPerfLog() logger.Logger

func (*GlobalContext) GetProofServices

func (g *GlobalContext) GetProofServices() ExternalServicesCollector

func (*GlobalContext) GetPvlSource

func (g *GlobalContext) GetPvlSource() MerkleStore

to implement ProofContext

func (*GlobalContext) GetRandom

func (g *GlobalContext) GetRandom() Random

func (*GlobalContext) GetRunMode

func (g *GlobalContext) GetRunMode() RunMode

func (*GlobalContext) GetRuntimeDir

func (g *GlobalContext) GetRuntimeDir() string

func (*GlobalContext) GetServerURI

func (g *GlobalContext) GetServerURI() (string, error)

func (*GlobalContext) GetServiceInfoPath

func (g *GlobalContext) GetServiceInfoPath() string

GetServiceInfoPath returns path to info file written by the Keybase service after startup

func (*GlobalContext) GetSharedCacheDir

func (g *GlobalContext) GetSharedCacheDir() string

func (*GlobalContext) GetSocket

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

func (*GlobalContext) GetStellar

func (g *GlobalContext) GetStellar() Stellar

func (*GlobalContext) GetStoredSecretAccessGroup

func (g *GlobalContext) GetStoredSecretAccessGroup() string

func (*GlobalContext) GetStoredSecretServiceName

func (g *GlobalContext) GetStoredSecretServiceName() string

func (*GlobalContext) GetTeamAuditor

func (g *GlobalContext) GetTeamAuditor() TeamAuditor

func (*GlobalContext) GetTeamBoxAuditor

func (g *GlobalContext) GetTeamBoxAuditor() TeamBoxAuditor

func (*GlobalContext) GetTeamEKBoxStorage

func (g *GlobalContext) GetTeamEKBoxStorage() TeamEKBoxStorage

func (*GlobalContext) GetTeamLoader

func (g *GlobalContext) GetTeamLoader() TeamLoader

func (*GlobalContext) GetTeamRoleMapManager

func (g *GlobalContext) GetTeamRoleMapManager() TeamRoleMapManager

func (*GlobalContext) GetTeambotBotKeyer

func (g *GlobalContext) GetTeambotBotKeyer() TeambotBotKeyer

func (*GlobalContext) GetTeambotEKBoxStorage

func (g *GlobalContext) GetTeambotEKBoxStorage() TeamEKBoxStorage

func (*GlobalContext) GetTeambotMemberKeyer

func (g *GlobalContext) GetTeambotMemberKeyer() TeambotMemberKeyer

func (*GlobalContext) GetUPAKLoader

func (g *GlobalContext) GetUPAKLoader() UPAKLoader

func (*GlobalContext) GetUnforwardedLogger

func (g *GlobalContext) GetUnforwardedLogger() (log UnforwardedLoggerWithLegacyInterface)

func (*GlobalContext) GetUserEKBoxStorage

func (g *GlobalContext) GetUserEKBoxStorage() UserEKBoxStorage

func (*GlobalContext) GetUsersWithStoredSecrets

func (g *GlobalContext) GetUsersWithStoredSecrets(ctx context.Context) ([]string, error)

func (*GlobalContext) GetVDebugLog

func (g *GlobalContext) GetVDebugLog() *VDebugLog

func (*GlobalContext) HonorPGPExpireTime

func (g *GlobalContext) HonorPGPExpireTime(t int64) int64

HonorPGPExpireTime determines whether expiration time on PGP sigs should be honored during sigchain playback. For now, we don't see any reason not to, but we might find a situation in the future that makes PGP expiration times hard to work around. Return the expiration time (in seconds after the UTC Epoch) to "honor" it, and "0" to ignore it. So honor it.

func (*GlobalContext) HonorSigchainExpireTime

func (g *GlobalContext) HonorSigchainExpireTime(t int64) int64

HonorSigchainExpireTime determines whether expiration time on sigchain links should be honored or ignored. When keybase first started in 2014, there were some links that were intended to expire in 5 years. With the benefit of 5 years of expirience, we can now see little security rationale for this expiration, but tons of churn if we decided to force key rotations. So return "0" to mean we no longer will expire these keys automatically. They can of course be explicitly revoked. If you fork this client, feel free to return "t" meaning yes, honor the expiration time advertised in the sigchain. -- MK 2018.04.03

func (*GlobalContext) Identify2Cache

func (g *GlobalContext) Identify2Cache() Identify2Cacher

func (*GlobalContext) Init

func (g *GlobalContext) Init() *GlobalContext

func (*GlobalContext) IsMobileAppType

func (g *GlobalContext) IsMobileAppType() bool

func (*GlobalContext) IsOneshot

func (g *GlobalContext) IsOneshot(ctx context.Context) (bool, error)

func (*GlobalContext) KeyfamilyChanged

func (g *GlobalContext) KeyfamilyChanged(ctx context.Context, u keybase1.UID)

func (*GlobalContext) LinkCache

func (g *GlobalContext) LinkCache() *LinkCache

func (*GlobalContext) LoadUserByUID

func (g *GlobalContext) LoadUserByUID(uid keybase1.UID) (*User, error)

func (*GlobalContext) LocalSigchainGuard

func (g *GlobalContext) LocalSigchainGuard() *LocalSigchainGuard

func (*GlobalContext) MakeAssertionContext

func (g *GlobalContext) MakeAssertionContext(mctx MetaContext) AssertionContext

func (*GlobalContext) MakeLoopbackServer

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

func (*GlobalContext) NewRPCLogFactory

func (g *GlobalContext) NewRPCLogFactory() *RPCLogFactory

func (*GlobalContext) OverrideUPAKLoader

func (g *GlobalContext) OverrideUPAKLoader(upak UPAKLoader)

func (*GlobalContext) PushShutdownHook

func (g *GlobalContext) PushShutdownHook(sh ShutdownHook)

func (*GlobalContext) ReplaceSecretStore

func (g *GlobalContext) ReplaceSecretStore(ctx context.Context) error

ReplaceSecretStore gets the existing secret out of the existing secret store, creates a new secret store (could be a new type of SecretStore based on a config change), and inserts the secret into the new secret store.

func (*GlobalContext) ResetSocket

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

ResetSocket clears and returns a new socket

func (*GlobalContext) SKBFilenameForUser

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

func (*GlobalContext) SecretStore

func (g *GlobalContext) SecretStore() *SecretStoreLocked

func (*GlobalContext) SetAvatarLoader

func (g *GlobalContext) SetAvatarLoader(a AvatarLoaderSource)

func (*GlobalContext) SetClock

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

func (*GlobalContext) SetCommandLine

func (g *GlobalContext) SetCommandLine(cmd CommandLine)

func (*GlobalContext) SetDNSNameServerFetcher

func (g *GlobalContext) SetDNSNameServerFetcher(d DNSNameServerFetcher)

func (*GlobalContext) SetDeviceEKStorage

func (g *GlobalContext) SetDeviceEKStorage(s DeviceEKStorage)

func (*GlobalContext) SetEKLib

func (g *GlobalContext) SetEKLib(ekLib EKLib)

func (*GlobalContext) SetExternalURLStore

func (g *GlobalContext) SetExternalURLStore(s MerkleStore)

func (*GlobalContext) SetFastTeamLoader

func (g *GlobalContext) SetFastTeamLoader(l FastTeamLoader)

func (*GlobalContext) SetHiddenTeamChainManager

func (g *GlobalContext) SetHiddenTeamChainManager(h HiddenTeamChainManager)

func (*GlobalContext) SetImplicitTeamCacher

func (g *GlobalContext) SetImplicitTeamCacher(l MemLRUer)

func (*GlobalContext) SetImplicitTeamConflictInfoCacher

func (g *GlobalContext) SetImplicitTeamConflictInfoCacher(l LRUer)

func (*GlobalContext) SetKVRevisionCache

func (g *GlobalContext) SetKVRevisionCache(kvr KVRevisionCacher)

func (*GlobalContext) SetMerkleClient

func (g *GlobalContext) SetMerkleClient(m MerkleClientInterface)

func (*GlobalContext) SetParamProofStore

func (g *GlobalContext) SetParamProofStore(s MerkleStore)

func (*GlobalContext) SetProofServices

func (g *GlobalContext) SetProofServices(s ExternalServicesCollector)

func (*GlobalContext) SetPvlSource

func (g *GlobalContext) SetPvlSource(s MerkleStore)

func (*GlobalContext) SetRandom

func (g *GlobalContext) SetRandom(r Random)

func (*GlobalContext) SetService

func (g *GlobalContext) SetService()

func (*GlobalContext) SetServiceSummaryMapper

func (g *GlobalContext) SetServiceSummaryMapper(u ServiceSummaryMapper)

func (*GlobalContext) SetStellar

func (g *GlobalContext) SetStellar(s Stellar)

func (*GlobalContext) SetTeamAuditor

func (g *GlobalContext) SetTeamAuditor(a TeamAuditor)

func (*GlobalContext) SetTeamBoxAuditor

func (g *GlobalContext) SetTeamBoxAuditor(a TeamBoxAuditor)

func (*GlobalContext) SetTeamEKBoxStorage

func (g *GlobalContext) SetTeamEKBoxStorage(s TeamEKBoxStorage)

func (*GlobalContext) SetTeamLoader

func (g *GlobalContext) SetTeamLoader(l TeamLoader)

func (*GlobalContext) SetTeamRoleMapManager

func (g *GlobalContext) SetTeamRoleMapManager(r TeamRoleMapManager)

func (*GlobalContext) SetTeambotBotKeyer

func (g *GlobalContext) SetTeambotBotKeyer(keyer TeambotBotKeyer)

func (*GlobalContext) SetTeambotEKBoxStorage

func (g *GlobalContext) SetTeambotEKBoxStorage(s TeamEKBoxStorage)

func (*GlobalContext) SetTeambotMemberKeyer

func (g *GlobalContext) SetTeambotMemberKeyer(keyer TeambotMemberKeyer)

func (*GlobalContext) SetUI

func (g *GlobalContext) SetUI(u UI)

func (*GlobalContext) SetUIDMapper

func (g *GlobalContext) SetUIDMapper(u UIDMapper)

func (*GlobalContext) SetUIRouter

func (g *GlobalContext) SetUIRouter(u UIRouter)

func (*GlobalContext) SetUPAKLoader

func (g *GlobalContext) SetUPAKLoader(u UPAKLoader)

func (*GlobalContext) SetUserEKBoxStorage

func (g *GlobalContext) SetUserEKBoxStorage(s UserEKBoxStorage)

func (*GlobalContext) Shutdown

func (g *GlobalContext) Shutdown(mctx MetaContext) error

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

func (*GlobalContext) StartStandaloneChat

func (g *GlobalContext) StartStandaloneChat()

func (*GlobalContext) StartupMessage

func (g *GlobalContext) StartupMessage()

func (*GlobalContext) Trace

func (g *GlobalContext) Trace(msg string, err *error) func()

func (*GlobalContext) TrackCache

func (g *GlobalContext) TrackCache() *TrackCache

func (*GlobalContext) UserChanged

func (g *GlobalContext) UserChanged(ctx context.Context, u keybase1.UID)

type GlobalTestOptions

type GlobalTestOptions struct {
	NoBug3964Repair             bool
	NoAutorotateOnBoxAuditRetry bool
}

type GpgBaseKey

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

func (GpgBaseKey) AlgoString

func (k GpgBaseKey) AlgoString() string

func (GpgBaseKey) CreatedString

func (k GpgBaseKey) CreatedString() string

func (GpgBaseKey) ExpirationString

func (k GpgBaseKey) ExpirationString() string

func (*GpgBaseKey) ParseBase

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

func (*GpgBaseKey) SetFingerprint

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

type GpgCLI

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

func NewGpgCLI

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

func (*GpgCLI) CanExec

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

CanExec returns true if a gpg executable exists.

func (*GpgCLI) Configure

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

func (*GpgCLI) ExportKey

func (g *GpgCLI) ExportKey(mctx MetaContext, k PGPKeyBundle, private bool, batch bool) (err error)

func (*GpgCLI) ExportKeyArmored

func (g *GpgCLI) ExportKeyArmored(mctx MetaContext, s string) (err error)

func (*GpgCLI) ImportKey

func (g *GpgCLI) ImportKey(mctx MetaContext, secret bool, fp PGPFingerprint, tty string) (*PGPKeyBundle, error)

func (*GpgCLI) ImportKeyArmored

func (g *GpgCLI) ImportKeyArmored(mctx MetaContext, secret bool, fp PGPFingerprint, tty string) (string, error)

func (*GpgCLI) Index

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

func (*GpgCLI) MakeCmd

func (g *GpgCLI) MakeCmd(mctx MetaContext, args []string, tty string) *exec.Cmd

func (*GpgCLI) Path

func (g *GpgCLI) Path(mctx MetaContext) string

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

func (*GpgCLI) Run2

func (g *GpgCLI) Run2(mctx MetaContext, arg RunGpg2Arg) (res RunGpg2Res)

func (*GpgCLI) SemanticVersion

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

func (*GpgCLI) SetTTY

func (g *GpgCLI) SetTTY(t string)

func (*GpgCLI) Sign

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

func (*GpgCLI) Version

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

func (*GpgCLI) VersionAtLeast

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

type GpgError

type GpgError struct {
	M string
}

func ErrorToGpgError

func ErrorToGpgError(e error) GpgError

func (GpgError) Error

func (e GpgError) Error() string

type GpgFingerprinter

type GpgFingerprinter interface {
	SetFingerprint(pgp *PGPFingerprint)
}

type GpgIndexElement

type GpgIndexElement interface {
	ToKey() *GpgPrimaryKey
}

type GpgIndexError

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

func ErrorToGpgIndexError

func ErrorToGpgIndexError(l int, e error) GpgIndexError

func (GpgIndexError) Error

func (e GpgIndexError) Error() string

type GpgIndexLine

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

func ParseLine

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

func (GpgIndexLine) At

func (g GpgIndexLine) At(i int) string

func (GpgIndexLine) IsNewKey

func (g GpgIndexLine) IsNewKey() bool

func (GpgIndexLine) Len

func (g GpgIndexLine) Len() int

type GpgIndexParser

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

func NewGpgIndexParser

func NewGpgIndexParser(g *GlobalContext) *GpgIndexParser

func (*GpgIndexParser) GetLine

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

func (*GpgIndexParser) Parse

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

func (*GpgIndexParser) ParseElement

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

func (*GpgIndexParser) ParseKey

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

func (*GpgIndexParser) PutbackLine

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

func (*GpgIndexParser) Warn

func (p *GpgIndexParser) Warn(w Warning)

type GpgKeyIndex

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

func NewGpgKeyIndex

func NewGpgKeyIndex() *GpgKeyIndex

func (*GpgKeyIndex) AllFingerprints

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

func (*GpgKeyIndex) GetRowFunc

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

func (*GpgKeyIndex) IndexKey

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

func (*GpgKeyIndex) Len

func (ki *GpgKeyIndex) Len() int

func (*GpgKeyIndex) Less

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

func (*GpgKeyIndex) PushElement

func (ki *GpgKeyIndex) PushElement(mctx MetaContext, e GpgIndexElement)

func (*GpgKeyIndex) Sort

func (ki *GpgKeyIndex) Sort()

func (*GpgKeyIndex) Swap

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

type GpgPrimaryKey

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

func NewGpgPrimaryKey

func NewGpgPrimaryKey(g *GlobalContext) *GpgPrimaryKey

func ParseGpgPrimaryKey

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

func (*GpgPrimaryKey) AddFingerprint

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

func (*GpgPrimaryKey) AddLine

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

func (*GpgPrimaryKey) AddSubkey

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

func (*GpgPrimaryKey) AddUID

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

func (*GpgPrimaryKey) GetAllID64s

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

func (*GpgPrimaryKey) GetEmails

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

func (*GpgPrimaryKey) GetFingerprint

func (k *GpgPrimaryKey) GetFingerprint() *PGPFingerprint

func (*GpgPrimaryKey) GetPGPIdentities

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

func (*GpgPrimaryKey) IsValid

func (k *GpgPrimaryKey) IsValid(mctx MetaContext) bool

func (*GpgPrimaryKey) Parse

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

func (*GpgPrimaryKey) ToKey

func (k *GpgPrimaryKey) ToKey() *GpgPrimaryKey

func (*GpgPrimaryKey) ToRow

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

type GpgSubKey

type GpgSubKey struct {
	GpgBaseKey
}

func ParseGpgSubKey

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

type GregorFirehoseHandler

type GregorFirehoseHandler interface {
	IsAlive() bool
	PushState(gregor1.State, keybase1.PushReason)
	PushOutOfBandMessages([]gregor1.OutOfBandMessage)
}

type GregorInBandMessageHandler

type GregorInBandMessageHandler interface {
	IsAlive() bool
	Name() string
	Create(ctx context.Context, cli gregor1.IncomingInterface, category string, ibm gregor.Item) (bool, error)
	Dismiss(ctx context.Context, cli gregor1.IncomingInterface, category string, ibm gregor.Item) (bool, error)
}

type GregorListener

type GregorListener interface {
	PushHandler(handler GregorInBandMessageHandler)
	PushFirehoseHandler(handler GregorFirehoseHandler)
}

type GregorState

type GregorState interface {
	State(ctx context.Context) (gregor.State, error)
	UpdateCategory(ctx context.Context, cat string, body []byte,
		dtime gregor1.TimeOrOffset) (res gregor1.MsgID, err error)
	InjectItem(ctx context.Context, cat string, body []byte, dtime gregor1.TimeOrOffset) (gregor1.MsgID, error)
	DismissItem(ctx context.Context, cli gregor1.IncomingInterface, id gregor.MsgID) error
	DismissCategory(ctx context.Context, cat gregor1.Category) error
	LocalDismissItem(ctx context.Context, id gregor.MsgID) error
}

type HTTPArgs

type HTTPArgs map[string]HTTPValue

func HTTPArgsFromKeyValuePair

func HTTPArgsFromKeyValuePair(key string, val HTTPValue) HTTPArgs

func NewHTTPArgs

func NewHTTPArgs() HTTPArgs

func (*HTTPArgs) Add

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

func (HTTPArgs) EncodeToString

func (a HTTPArgs) EncodeToString() string

func (HTTPArgs) ToValues

func (a HTTPArgs) ToValues() url.Values

type HTTPRequest

type HTTPRequest interface {
	SetEnvironment(env Env)
}

type HTTPTime

type HTTPTime struct {
	Val keybase1.Time
}

func (HTTPTime) String

func (t HTTPTime) String() string

type HTTPValue

type HTTPValue interface {
	String() string
}

func UIDArg

func UIDArg(uid keybase1.UID) HTTPValue

type HashSecurityWarning

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

func (HashSecurityWarning) String

func (h HashSecurityWarning) String() string

type HashSecurityWarningType

type HashSecurityWarningType uint8
const (
	HashSecurityWarningUnknown HashSecurityWarningType = iota
	HashSecurityWarningSignatureHash
	HashSecurityWarningSignersIdentityHash
	HashSecurityWarningRecipientsIdentityHash
	HashSecurityWarningOurIdentityHash
)

type HashSecurityWarnings

type HashSecurityWarnings []HashSecurityWarning

func (HashSecurityWarnings) Strings

func (hs HashSecurityWarnings) Strings() (res []string)

type HashSummer

type HashSummer func() []byte

func ArmoredAttachedSign

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

type HashingWriteCloser

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

func (HashingWriteCloser) Close

func (h HashingWriteCloser) Close() error

func (HashingWriteCloser) Write

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

type HexWrongLengthError

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

func NewHexWrongLengthError

func NewHexWrongLengthError(msg string) HexWrongLengthError

func (HexWrongLengthError) Error

func (e HexWrongLengthError) Error() string

type HiddenChainDataMissingError

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

func NewHiddenChainDataMissingError

func NewHiddenChainDataMissingError(format string, args ...interface{}) HiddenChainDataMissingError

func (HiddenChainDataMissingError) Error

type HiddenMerkleError

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

func NewHiddenMerkleError

func NewHiddenMerkleError(t HiddenMerkleErrorType, format string, args ...interface{}) HiddenMerkleError

func (HiddenMerkleError) Error

func (e HiddenMerkleError) Error() string

func (HiddenMerkleError) ErrorType

type HiddenMerkleErrorType

type HiddenMerkleErrorType int
const (
	HiddenMerkleErrorNone HiddenMerkleErrorType = iota

	HiddenMerkleErrorInconsistentLeaf
	HiddenMerkleErrorInconsistentUncommittedSeqno
	HiddenMerkleErrorInvalidHiddenResponseType
	HiddenMerkleErrorInvalidLeafType
	HiddenMerkleErrorNoHiddenChainInLeaf
	HiddenMerkleErrorOldLinkNotYetCommitted
	HiddenMerkleErrorRollbackCommittedSeqno
	HiddenMerkleErrorRollbackUncommittedSeqno
	HiddenMerkleErrorServerWitholdingLinks
	HiddenMerkleErrorUnexpectedAbsenceProof
)

type HiddenTeamChainManager

type HiddenTeamChainManager interface {
	// We got gossip about what the latest chain-tail should be, so ratchet the
	// chain forward; the next call to Advance() has to match.
	Ratchet(MetaContext, keybase1.TeamID, keybase1.HiddenTeamChainRatchetSet) error
	// We got a bunch of new links downloaded via slow or fast loader, so add them
	// onto the HiddenTeamChain state. Ensure that the updated state is at least up to the
	// given ratchet value.
	Advance(mctx MetaContext, update keybase1.HiddenTeamChain, expectedPrev *keybase1.LinkTriple) error
	// Access the tail of the HiddenTeamChain, for embedding into gossip vectors.
	Tail(MetaContext, keybase1.TeamID) (*keybase1.LinkTriple, error)
	// Load the latest data for the given team ID, and just return it wholesale.
	Load(MetaContext, keybase1.TeamID) (dat *keybase1.HiddenTeamChain, err error)
	// See comment in TeamLoader#Freeze.
	Freeze(MetaContext, keybase1.TeamID) error
	// See comment in TeamLoader#Tombstone.
	Tombstone(MetaContext, keybase1.TeamID) error
	// Untrusted hint of what a team's latest seqno is
	HintLatestSeqno(m MetaContext, id keybase1.TeamID, seqno keybase1.Seqno) error
	Shutdown(m MetaContext)
	TeamSupportsHiddenChain(m MetaContext, id keybase1.TeamID) (state bool, err error)
	ClearSupportFlagIfFalse(m MetaContext, id keybase1.TeamID)
}

type HighSigChain

type HighSigChain struct {
	MetaContextified
	// contains filtered or unexported fields
}

func (HighSigChain) GetComputedKeyInfos

func (hsc HighSigChain) GetComputedKeyInfos() (cki *ComputedKeyInfos)

func (*HighSigChain) LoadFromServer

func (hsc *HighSigChain) LoadFromServer(m MetaContext, t *MerkleTriple, selfUID keybase1.UID) (dirtyTail *MerkleTriple, err error)

func (*HighSigChain) VerifyChain

func (hsc *HighSigChain) VerifyChain(m MetaContext) (err error)

func (*HighSigChain) VerifySigsAndComputeKeys

func (hsc *HighSigChain) VerifySigsAndComputeKeys(m MetaContext, eldest keybase1.KID, ckf *ComputedKeyFamily) (cached bool, err error)

type HighSigChainLoader

type HighSigChainLoader struct {
	MetaContextified
	// contains filtered or unexported fields
}

func NewHighSigChainLoader

func NewHighSigChainLoader(m MetaContext, user *User, leaf *MerkleUserLeaf) *HighSigChainLoader

func (*HighSigChainLoader) GetMerkleTriple

func (l *HighSigChainLoader) GetMerkleTriple() (ret *MerkleTriple)

func (*HighSigChainLoader) Load

func (l *HighSigChainLoader) Load() (ret *HighSigChain, err error)

func (*HighSigChainLoader) LoadFromServer

func (l *HighSigChainLoader) LoadFromServer() (err error)

func (*HighSigChainLoader) VerifySigsAndComputeKeys

func (l *HighSigChainLoader) VerifySigsAndComputeKeys() (err error)

type HighSkip

type HighSkip struct {
	Seqno keybase1.Seqno
	Hash  LinkID
}

func NewHighSkip

func NewHighSkip(highSkipSeqno keybase1.Seqno, highSkipHash LinkID) HighSkip

func NewInitialHighSkip

func NewInitialHighSkip() HighSkip

func (HighSkip) AssertEqualsExpected

func (h HighSkip) AssertEqualsExpected(expected HighSkip) error

type HomeFinder

type HomeFinder interface {
	CacheDir() string
	SharedCacheDir() string
	ConfigDir() string
	DownloadsDir() string
	Home(emptyOk bool) string
	MobileSharedHome(emptyOk bool) string
	DataDir() string
	SharedDataDir() string
	RuntimeDir() string
	Normalize(s string) string
	LogDir() string
	ServiceSpawnDir() (string, error)
	SandboxCacheDir() string // For macOS
	InfoDir() string
	IsNonstandardHome() (bool, error)
}

func NewHomeFinder

func NewHomeFinder(appName string, getHomeFromCmd ConfigGetter, getHomeFromConfig ConfigGetter, getMobileSharedHome ConfigGetter,
	osname string, getRunMode RunModeGetter, getLog LogGetter, getenv EnvGetter) HomeFinder

type HomeStateBody

type HomeStateBody struct {
	Version              int           `json:"version"`
	BadgeCountMap        HomeItemMap   `json:"badge_count_map"`
	LastViewedTime       keybase1.Time `json:"last_viewed_time"`
	AnnouncementsVersion int           `json:"announcements_version"`
}

func (*HomeStateBody) LessThan

func (a *HomeStateBody) LessThan(b HomeStateBody) bool

type HomeTodoMap

type HomeTodoMap map[keybase1.HomeScreenTodoType]int

type HumanErrorer

type HumanErrorer interface {
	HumanError() error
}

HumanErrorer is an interface that errors can implement if they want to expose what went wrong to humans, either via the CLI or via the electron interface. It sometimes happens that errors get wrapped inside of other errors up a stack, and it's hard to know what to show the user. This can help.

type I

type I struct {
	Val int
}

func (I) String

func (i I) String() string

type I64

type I64 struct {
	Val int64
}

func (I64) String

func (i I64) String() string

type IdentifiesFailedError

type IdentifiesFailedError struct {
}

func NewIdentifiesFailedError

func NewIdentifiesFailedError() IdentifiesFailedError

func (IdentifiesFailedError) Error

func (e IdentifiesFailedError) Error() string

func (IdentifiesFailedError) ToStatus

func (e IdentifiesFailedError) ToStatus() keybase1.Status

type Identify2Cache

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

Identify2Cache stores User objects in memory for a fixed amount of time.

func NewIdentify2Cache

func NewIdentify2Cache(maxAge time.Duration) *Identify2Cache

NewIdentify2Cache creates a Identify2Cache and sets the object max age to maxAge. Once a user is inserted, after maxAge duration passes, the user will be removed from the cache.

func (*Identify2Cache) Delete

func (c *Identify2Cache) Delete(uid keybase1.UID) error

func (*Identify2Cache) DidFullUserLoad

func (c *Identify2Cache) DidFullUserLoad(_ keybase1.UID)

DidFullUserLoad is a noop unless we're testing...

func (*Identify2Cache) Get

Get returns a user object. If none exists for uid, it will return nil.

func (*Identify2Cache) Insert

Insert adds a user to the cache, keyed on UID.

func (*Identify2Cache) Shutdown

func (c *Identify2Cache) Shutdown()

Shutdown stops any goroutines in the cache.

func (*Identify2Cache) UseDiskCache

func (c *Identify2Cache) UseDiskCache() bool

type Identify2Cacher

type Identify2Cacher interface {
	Get(keybase1.UID, GetCheckTimeFunc, GetCacheDurationFunc, bool) (*keybase1.Identify2ResUPK2, error)
	Insert(up *keybase1.Identify2ResUPK2) error
	DidFullUserLoad(keybase1.UID)
	Shutdown()
	Delete(uid keybase1.UID) error
	UseDiskCache() bool
}

type Identify3Session

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

Identify3Session corresponds to a single screen showing a user profile. It maps 1:1 with an Identify2GUIID, and is labeled as such. Here we'll keep track of whatever context we need to pass across calls, and also the TrackToken for the final result.

func NewIdentify3Session

func NewIdentify3Session(mctx MetaContext) (*Identify3Session, error)

func NewIdentify3SessionWithID

func NewIdentify3SessionWithID(mctx MetaContext, id keybase1.Identify3GUIID) *Identify3Session

func (*Identify3Session) ID

func (*Identify3Session) Outcome

func (s *Identify3Session) Outcome() *IdentifyOutcome

func (*Identify3Session) OutcomeLocked

func (s *Identify3Session) OutcomeLocked() *IdentifyOutcome

func (*Identify3Session) ResultType

func (*Identify3Session) SetNeedUpgrade

func (s *Identify3Session) SetNeedUpgrade()

func (*Identify3Session) SetOutcome

func (s *Identify3Session) SetOutcome(o *IdentifyOutcome)

func (*Identify3Session) SetTrackBroken

func (s *Identify3Session) SetTrackBroken()

type Identify3State

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

Identify3State keeps track of all active ID3 state across the whole app. It has a cache that's periodically cleaned up.

func NewIdentify3State

func NewIdentify3State(g *GlobalContext) *Identify3State

func NewIdentify3StateForTest

func NewIdentify3StateForTest(g *GlobalContext) (*Identify3State, <-chan time.Time)

func (*Identify3State) Get

get an identify3Session out of the cache, as keyed by a Identify3GUIID. Return (nil, nil) if not found. Return (nil, Error) if there was an expected error. Return (i, nil) if found, where i is the **unlocked** object.

func (*Identify3State) OnLogout

func (s *Identify3State) OnLogout()

func (*Identify3State) Put

func (s *Identify3State) Put(sess *Identify3Session) error

func (*Identify3State) Remove

func (s *Identify3State) Remove(key keybase1.Identify3GUIID)

func (*Identify3State) Shutdown

func (s *Identify3State) Shutdown() chan struct{}

type IdentifyDidNotCompleteError

type IdentifyDidNotCompleteError struct{}

func (IdentifyDidNotCompleteError) Error

func (IdentifyDidNotCompleteError) ToStatus

type IdentifyDispatch

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

func NewIdentifyDispatch

func NewIdentifyDispatch() *IdentifyDispatch

func (*IdentifyDispatch) NotifyTrackingSuccess

func (d *IdentifyDispatch) NotifyTrackingSuccess(mctx MetaContext, target keybase1.UID)

NotifyTrackingSuccess notifies listeners that a target user has been found to satisfy tracking. This could be through - An identify call that heeded the active user's tracking of the target. - A user tracked or untracked the target. When the active user is the target all bets are off.

func (*IdentifyDispatch) OnLogout

func (d *IdentifyDispatch) OnLogout()

OnLogout drops all subscriptions.

func (*IdentifyDispatch) Subscribe

func (d *IdentifyDispatch) Subscribe(mctx MetaContext) (unsubscribe func(), recvCh <-chan IdentifyDispatchMsg)

Subscribe to notifications. `unsubscribe` releases resources associated with the subscription and should be called asap.

type IdentifyDispatchMsg

type IdentifyDispatchMsg struct {
	Target keybase1.UID
}

type IdentifyFailedError

type IdentifyFailedError struct {
	Assertion string
	Reason    string
}

func (IdentifyFailedError) Error

func (e IdentifyFailedError) Error() string

func (IdentifyFailedError) ToStatus

func (e IdentifyFailedError) ToStatus() keybase1.Status

type IdentifyOutcome

type IdentifyOutcome struct {
	Contextified
	Username              NormalizedUsername
	UID                   keybase1.UID
	EldestSeqno           keybase1.Seqno
	Error                 error
	KeyDiffs              []TrackDiff
	Revoked               []TrackDiff
	RevokedDetails        []keybase1.RevokedProof
	ProofChecks           []*LinkCheckResult
	Warnings              []Warning
	TrackUsed             *TrackLookup
	TrackEqual            bool // Whether the track statement was equal to what we saw
	TrackOptions          keybase1.TrackOptions
	Reason                keybase1.IdentifyReason
	ResponsibleGregorItem gregor.Item
}

func NewIdentifyOutcome

func NewIdentifyOutcome(g *GlobalContext, username NormalizedUsername, uid keybase1.UID, eldestSeqno keybase1.Seqno) *IdentifyOutcome

func (*IdentifyOutcome) ActiveProofs

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

func (*IdentifyOutcome) AddProofsToSet

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

func (*IdentifyOutcome) Export

func (IdentifyOutcome) ExportToUncheckedIdentity

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

func (IdentifyOutcome) GetError

func (i IdentifyOutcome) GetError() error

func (IdentifyOutcome) GetErrorAndWarnings

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

func (IdentifyOutcome) GetErrorLax

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

func (*IdentifyOutcome) GetRemoteCheckResultFor

func (i *IdentifyOutcome) GetRemoteCheckResultFor(service string, username string) ProofError

func (IdentifyOutcome) IsOK

func (i IdentifyOutcome) IsOK() bool

func (IdentifyOutcome) NumProofFailures

func (i IdentifyOutcome) NumProofFailures() int

The number of proofs that failed.

func (IdentifyOutcome) NumProofSuccesses

func (i IdentifyOutcome) NumProofSuccesses() int

The number of proofs that actually worked

func (IdentifyOutcome) NumRevoked

func (i IdentifyOutcome) NumRevoked() int

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

func (IdentifyOutcome) NumTrackChanges

func (i IdentifyOutcome) NumTrackChanges() int

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

func (IdentifyOutcome) NumTrackFailures

func (i IdentifyOutcome) NumTrackFailures() int

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

func (*IdentifyOutcome) ProofChecksSorted

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

func (*IdentifyOutcome) TrackSet

func (i *IdentifyOutcome) TrackSet() *TrackSet

func (IdentifyOutcome) TrackStatus

func (i IdentifyOutcome) TrackStatus() keybase1.TrackStatus

func (IdentifyOutcome) TrackingStatement

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

type IdentifyState

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

func NewIdentifyStateWithGregorItem

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

func (IdentifyState) ExportToUncheckedIdentity

func (is IdentifyState) ExportToUncheckedIdentity(mctx MetaContext) *keybase1.Identity

func (*IdentifyState) HasPreviousTrack

func (s *IdentifyState) HasPreviousTrack() bool

func (*IdentifyState) Precompute

func (s *IdentifyState) Precompute(dhook func(keybase1.IdentifyKey) error, rhook func(TrackIDComponent, TrackDiff))

func (*IdentifyState) Result

func (s *IdentifyState) Result() *IdentifyOutcome

func (*IdentifyState) SetTmpTrackLookup

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

func (*IdentifyState) SetTrackLookup

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

func (*IdentifyState) TmpTrackLookup

func (s *IdentifyState) TmpTrackLookup() *TrackLookup

func (*IdentifyState) TrackLookup

func (s *IdentifyState) TrackLookup() *TrackLookup

type IdentifySummaryError

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

func NewIdentifySummaryError

func NewIdentifySummaryError(failure keybase1.TLFIdentifyFailure) IdentifySummaryError

func (IdentifySummaryError) Error

func (e IdentifySummaryError) Error() string

func (IdentifySummaryError) IsImmediateFail

func (e IdentifySummaryError) IsImmediateFail() (chat1.OutboxErrorType, bool)

func (IdentifySummaryError) Problems

func (e IdentifySummaryError) Problems() []string

func (IdentifySummaryError) ToStatus

func (e IdentifySummaryError) ToStatus() keybase1.Status

type IdentifyTableMode

type IdentifyTableMode int
const (
	IdentifyTableModePassive IdentifyTableMode = iota
	IdentifyTableModeActive  IdentifyTableMode = iota
)

type IdentifyTimeoutError

type IdentifyTimeoutError struct{}

func (IdentifyTimeoutError) Error

func (e IdentifyTimeoutError) Error() string

func (IdentifyTimeoutError) ToStatus

func (e IdentifyTimeoutError) ToStatus() keybase1.Status

type Identities

type Identities []Identity

func ImportPGPIdentities

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

func (Identities) Export

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

type Identity

type Identity struct {
	Username string
	Comment  string
	Email    string
}

func ImportPGPIdentity

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

func KeybaseIdentity

func KeybaseIdentity(g *GlobalContext, un NormalizedUsername) Identity

func ParseIdentity

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

func (Identity) Export

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

func (Identity) Format

func (i Identity) Format() string

func (Identity) String

func (i Identity) String() string

func (Identity) ToPGPUserID

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

type IdentityTable

type IdentityTable struct {
	Contextified

	Order []TypedChainLink
	// contains filtered or unexported fields
}

func NewIdentityTable

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

func (*IdentityTable) ActiveCryptocurrency

func (idt *IdentityTable) ActiveCryptocurrency(family CryptocurrencyFamily) *CryptocurrencyChainLink

func (*IdentityTable) AllActiveCryptocurrency

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

func (*IdentityTable) ComputeRemoteDiff

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

ComputeRemoteDiff takes as input three tracking results: the permanent track, the local temporary track, and the one it observed remotely. It favors the permanent track but will roll back to the temporary track if needs be.

func (*IdentityTable) GetActiveProofsFor

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

func (*IdentityTable) GetRevokedCryptocurrencyForTesting

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

func (*IdentityTable) GetTrackList

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

func (*IdentityTable) GetTrackMap

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

func (*IdentityTable) HasActiveCryptocurrencyFamily

func (idt *IdentityTable) HasActiveCryptocurrencyFamily(family CryptocurrencyFamily) bool

func (*IdentityTable) HasStubs

func (idt *IdentityTable) HasStubs() bool

func (*IdentityTable) Identify

func (idt *IdentityTable) Identify(m MetaContext, is IdentifyState, forceRemoteCheck bool, ui IdentifyUI, ccl CheckCompletedListener, itm IdentifyTableMode) error

func (*IdentityTable) Len

func (idt *IdentityTable) Len() int

func (*IdentityTable) MarkCheckResult

func (idt *IdentityTable) MarkCheckResult(err ProofError)

func (*IdentityTable) StellarAccountID

func (idt *IdentityTable) StellarAccountID() *stellar1.AccountID

Return the active stellar public address for a user. Returns nil if there is none or it has not been loaded.

func (*IdentityTable) TrackChainLinkFor

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

func (*IdentityTable) VerifySelfSig

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

type ImplicitTeamDisplayNameError

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

func NewImplicitTeamDisplayNameError

func NewImplicitTeamDisplayNameError(format string, args ...interface{}) ImplicitTeamDisplayNameError

func (ImplicitTeamDisplayNameError) Error

type InactiveKeyError

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

func (InactiveKeyError) Error

func (i InactiveKeyError) Error() string

type InconsistentCacheStateError

type InconsistentCacheStateError struct{}

func (InconsistentCacheStateError) Error

type InputCanceledError

type InputCanceledError struct{}

func (InputCanceledError) Error

func (e InputCanceledError) Error() string

func (InputCanceledError) ToStatus

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

type InstallID

type InstallID string

func (InstallID) Exists

func (i InstallID) Exists() bool

func (InstallID) String

func (i InstallID) String() string

type InstrumentedBody

type InstrumentedBody struct {
	MetaContextified
	// contains filtered or unexported fields
}

func NewInstrumentedBody

func NewInstrumentedBody(mctx MetaContext, record *rpc.NetworkInstrumenter, body io.ReadCloser, uncompressed bool,
	gzipGetter func(io.Writer) (*gzip.Writer, func())) *InstrumentedBody

func (*InstrumentedBody) Close

func (b *InstrumentedBody) Close() (err error)

func (*InstrumentedBody) Read

func (b *InstrumentedBody) Read(p []byte) (n int, err error)

type InstrumentedRoundTripper

type InstrumentedRoundTripper struct {
	Contextified
	RoundTripper http.RoundTripper
	// contains filtered or unexported fields
}

func NewInstrumentedRoundTripper

func NewInstrumentedRoundTripper(g *GlobalContext, tagger func(*http.Request) string, xprt http.RoundTripper) *InstrumentedRoundTripper

func (*InstrumentedRoundTripper) RoundTrip

func (i *InstrumentedRoundTripper) RoundTrip(req *http.Request) (resp *http.Response, err error)

type InsufficientKarmaError

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

func NewInsufficientKarmaError

func NewInsufficientKarmaError(un string) InsufficientKarmaError

func (InsufficientKarmaError) Error

func (e InsufficientKarmaError) Error() string

type InternalAPIEngine

type InternalAPIEngine struct {
	BaseAPIEngine
}

func NewInternalAPIEngine

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

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

func (*InternalAPIEngine) Delete

func (a *InternalAPIEngine) Delete(m MetaContext, arg APIArg) (*APIRes, error)

func (*InternalAPIEngine) DoRequest

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

func (*InternalAPIEngine) Get

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

func (*InternalAPIEngine) GetDecode

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

func (*InternalAPIEngine) GetDecodeCtx

func (a *InternalAPIEngine) GetDecodeCtx(ctx context.Context, arg APIArg, v APIResponseWrapper) error

func (*InternalAPIEngine) GetResp

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

GetResp performs a GET request and returns the http response. The finisher second arg should be called whenever we're done with the response (if it's non-nil).

func (*InternalAPIEngine) Post

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

func (*InternalAPIEngine) PostDecode

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

func (*InternalAPIEngine) PostDecodeCtx

func (a *InternalAPIEngine) PostDecodeCtx(ctx context.Context, arg APIArg, v APIResponseWrapper) error

func (*InternalAPIEngine) PostJSON

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

PostJSON does _not_ actually enforce the use of JSON. That is now determined by APIArg's fields.

func (*InternalAPIEngine) PostRaw

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

type InternalError

type InternalError struct {
	Msg string
}

func (InternalError) Error

func (e InternalError) Error() string

type InvalidAddressError

type InvalidAddressError struct {
	Msg string
}

func (InvalidAddressError) Error

func (e InvalidAddressError) Error() string

func (InvalidAddressError) ToStatus

func (e InvalidAddressError) ToStatus() keybase1.Status

type InvalidArgumentError

type InvalidArgumentError struct {
	Msg string
}

func (InvalidArgumentError) Error

func (e InvalidArgumentError) Error() string

type InvalidHostnameError

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

func NewInvalidHostnameError

func NewInvalidHostnameError(h string) InvalidHostnameError

func (InvalidHostnameError) Error

func (e InvalidHostnameError) Error() string

type InvalidKexPhraseError

type InvalidKexPhraseError struct{}

func (InvalidKexPhraseError) Error

func (e InvalidKexPhraseError) Error() string

func (InvalidKexPhraseError) ToStatus

func (e InvalidKexPhraseError) ToStatus() keybase1.Status

type InvalidRepoNameError

type InvalidRepoNameError struct {
	Name string
}

InvalidRepoNameError indicates that a repo name is invalid.

func (InvalidRepoNameError) Error

func (e InvalidRepoNameError) Error() string

func (InvalidRepoNameError) ToStatus

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

type InvalidStellarAccountIDError

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

func NewInvalidStellarAccountIDError

func NewInvalidStellarAccountIDError(details string) InvalidStellarAccountIDError

func (InvalidStellarAccountIDError) Error

func (InvalidStellarAccountIDError) Verbose

type InvalidWindowsNameError

type InvalidWindowsNameError struct{}

InvalidWindowsNameError is the error returned when an invalid path name is passed in.

func (InvalidWindowsNameError) Error

Error implements the error interface.

type Invitation

type Invitation struct {
	ID        string
	ShortCode string
	Throttled bool
}

func GenerateInvitationCode

func GenerateInvitationCode(mctx MetaContext, arg InviteArg) (*Invitation, error)

func GenerateInvitationCodeForAssertion

func GenerateInvitationCodeForAssertion(mctx MetaContext, assertion keybase1.SocialAssertion, arg InviteArg) (*Invitation, error)

func SendInvitation

func SendInvitation(mctx MetaContext, email string, arg InviteArg) (*Invitation, error)
func (i Invitation) Link() string

type InviteArg

type InviteArg struct {
	Message    string
	NoteToSelf string
}

InviteArg contains optional invitation arguments.

func (InviteArg) ToHTTPArgs

func (i InviteArg) ToHTTPArgs() HTTPArgs

type InviteRequestArg

type InviteRequestArg struct {
	Email    string
	Fullname string
	Notes    string
}

type JSONConfigFile

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

func NewJSONConfigFile

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

func (*JSONConfigFile) Check

func (f *JSONConfigFile) Check() error

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

func (*JSONConfigFile) GetAPITimeout

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

func (*JSONConfigFile) GetAllUserConfigs

func (f *JSONConfigFile) GetAllUserConfigs() (current *UserConfig, others []UserConfig, err error)

func (*JSONConfigFile) GetAllUsernames

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

func (*JSONConfigFile) GetAndroidInstallReferrerChecked

func (f *JSONConfigFile) GetAndroidInstallReferrerChecked() bool

func (*JSONConfigFile) GetAppType

func (f *JSONConfigFile) GetAppType() AppType

func (*JSONConfigFile) GetAttachmentDisableMulti

func (f *JSONConfigFile) GetAttachmentDisableMulti() (bool, bool)

func (*JSONConfigFile) GetAttachmentHTTPStartPort

func (f *JSONConfigFile) GetAttachmentHTTPStartPort() (int, bool)

func (*JSONConfigFile) GetAutoFork

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

func (*JSONConfigFile) GetBGIdentifierDisabled

func (f *JSONConfigFile) GetBGIdentifierDisabled() (bool, bool)

func (*JSONConfigFile) GetBug3964RepairTime

func (f *JSONConfigFile) GetBug3964RepairTime(un NormalizedUsername) (time.Time, error)

func (*JSONConfigFile) GetBundledCA

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

func (*JSONConfigFile) GetChatDbFilename

func (f *JSONConfigFile) GetChatDbFilename() string

func (*JSONConfigFile) GetChatDelivererInterval

func (f *JSONConfigFile) GetChatDelivererInterval() (time.Duration, bool)

func (*JSONConfigFile) GetChatInboxSourceLocalizeThreads

func (f *JSONConfigFile) GetChatInboxSourceLocalizeThreads() (int, bool)

func (*JSONConfigFile) GetCodeSigningKIDs

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

func (*JSONConfigFile) GetConfigFilename

func (f *JSONConfigFile) GetConfigFilename() string

func (*JSONConfigFile) GetDbFilename

func (f *JSONConfigFile) GetDbFilename() string

func (*JSONConfigFile) GetDebug

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

func (*JSONConfigFile) GetDebugJourneycard

func (f *JSONConfigFile) GetDebugJourneycard() (bool, bool)

func (*JSONConfigFile) GetDeviceCloneStateFilename

func (f *JSONConfigFile) GetDeviceCloneStateFilename() string

func (*JSONConfigFile) GetDeviceID

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

func (*JSONConfigFile) GetDeviceIDForUID

func (f *JSONConfigFile) GetDeviceIDForUID(u keybase1.UID) keybase1.DeviceID

func (*JSONConfigFile) GetDeviceIDForUsername

func (f *JSONConfigFile) GetDeviceIDForUsername(nu NormalizedUsername) keybase1.DeviceID

func (*JSONConfigFile) GetDisableBgConvLoader

func (f *JSONConfigFile) GetDisableBgConvLoader() (bool, bool)

func (*JSONConfigFile) GetDisableEKBackgroundKeygen

func (f *JSONConfigFile) GetDisableEKBackgroundKeygen() (bool, bool)

func (*JSONConfigFile) GetDisableMerkleAuditor

func (f *JSONConfigFile) GetDisableMerkleAuditor() (bool, bool)

func (*JSONConfigFile) GetDisableSearchIndexer

func (f *JSONConfigFile) GetDisableSearchIndexer() (bool, bool)

func (*JSONConfigFile) GetDisableTeamAuditor

func (f *JSONConfigFile) GetDisableTeamAuditor() (bool, bool)

func (*JSONConfigFile) GetDisableTeamBoxAuditor

func (f *JSONConfigFile) GetDisableTeamBoxAuditor() (bool, bool)

func (*JSONConfigFile) GetDisplayRawUntrustedOutput

func (f *JSONConfigFile) GetDisplayRawUntrustedOutput() (bool, bool)

func (*JSONConfigFile) GetDurationAtPath

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

func (*JSONConfigFile) GetEKLogFile

func (f *JSONConfigFile) GetEKLogFile() string

func (*JSONConfigFile) GetEnableBotLiteMode

func (f *JSONConfigFile) GetEnableBotLiteMode() (bool, bool)

func (*JSONConfigFile) GetExternalURLKitFilename

func (f *JSONConfigFile) GetExternalURLKitFilename() string

func (*JSONConfigFile) GetExtraNetLogging

func (f *JSONConfigFile) GetExtraNetLogging() (bool, bool)

func (*JSONConfigFile) GetFeatureFlags

func (f *JSONConfigFile) GetFeatureFlags() (ret FeatureFlags, err error)

func (*JSONConfigFile) GetForceLinuxKeyring

func (f *JSONConfigFile) GetForceLinuxKeyring() (bool, bool)

func (*JSONConfigFile) GetForceSecretStoreFile

func (f *JSONConfigFile) GetForceSecretStoreFile() (bool, bool)

func (*JSONConfigFile) GetGUIConfigFilename

func (f *JSONConfigFile) GetGUIConfigFilename() string

func (*JSONConfigFile) GetGUILogFile

func (f *JSONConfigFile) GetGUILogFile() string

func (*JSONConfigFile) GetGpg

func (f *JSONConfigFile) GetGpg() string

func (*JSONConfigFile) GetGpgHome

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

func (*JSONConfigFile) GetGpgOptions

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

func (*JSONConfigFile) GetGregorDisabled

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

func (*JSONConfigFile) GetGregorPingInterval

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

func (*JSONConfigFile) GetGregorPingTimeout

func (f *JSONConfigFile) GetGregorPingTimeout() (time.Duration, bool)

func (*JSONConfigFile) GetGregorSaveInterval

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

func (*JSONConfigFile) GetGregorURI

func (f *JSONConfigFile) GetGregorURI() string

func (*JSONConfigFile) GetHome

func (f *JSONConfigFile) GetHome() string

func (*JSONConfigFile) GetLevelDBNumFiles

func (f *JSONConfigFile) GetLevelDBNumFiles() (int, bool)

func (*JSONConfigFile) GetLevelDBWriteBufferMB

func (f *JSONConfigFile) GetLevelDBWriteBufferMB() (int, bool)

func (*JSONConfigFile) GetLinkCacheCleanDur

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

func (*JSONConfigFile) GetLinkCacheSize

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

func (*JSONConfigFile) GetLocalRPCDebug

func (f *JSONConfigFile) GetLocalRPCDebug() string

func (*JSONConfigFile) GetLocalTrackMaxAge

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

func (*JSONConfigFile) GetLogFile

func (f *JSONConfigFile) GetLogFile() string

func (*JSONConfigFile) GetLogFormat

func (f *JSONConfigFile) GetLogFormat() string

func (*JSONConfigFile) GetLogPrefix

func (f *JSONConfigFile) GetLogPrefix() string

func (*JSONConfigFile) GetMerkleKIDs

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

func (*JSONConfigFile) GetMobileSharedHome

func (f *JSONConfigFile) GetMobileSharedHome() string

func (*JSONConfigFile) GetMountDir

func (f *JSONConfigFile) GetMountDir() string

func (*JSONConfigFile) GetMountDirDefault

func (f *JSONConfigFile) GetMountDirDefault() string

func (*JSONConfigFile) GetNoPinentry

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

func (*JSONConfigFile) GetParamProofKitFilename

func (f *JSONConfigFile) GetParamProofKitFilename() string

func (*JSONConfigFile) GetPassphraseState

func (f *JSONConfigFile) GetPassphraseState() (ret *keybase1.PassphraseState)

func (*JSONConfigFile) GetPassphraseStateForUsername

func (f *JSONConfigFile) GetPassphraseStateForUsername(nu NormalizedUsername) (ret *keybase1.PassphraseState)

func (*JSONConfigFile) GetPayloadCacheSize

func (f *JSONConfigFile) GetPayloadCacheSize() (int, bool)

func (*JSONConfigFile) GetPerfLogFile

func (f *JSONConfigFile) GetPerfLogFile() string

func (*JSONConfigFile) GetPidFile

func (f *JSONConfigFile) GetPidFile() string

func (*JSONConfigFile) GetPinentry

func (f *JSONConfigFile) GetPinentry() string

func (*JSONConfigFile) GetProofCacheLongDur

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

func (*JSONConfigFile) GetProofCacheMediumDur

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

func (*JSONConfigFile) GetProofCacheShortDur

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

func (*JSONConfigFile) GetProofCacheSize

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

func (*JSONConfigFile) GetProveBypass

func (f *JSONConfigFile) GetProveBypass() (bool, bool)

func (*JSONConfigFile) GetProxy

func (f *JSONConfigFile) GetProxy() string

func (*JSONConfigFile) GetProxyCACerts

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

func (*JSONConfigFile) GetProxyType

func (f *JSONConfigFile) GetProxyType() string

func (*JSONConfigFile) GetPvlKitFilename

func (f *JSONConfigFile) GetPvlKitFilename() string

func (*JSONConfigFile) GetReadDeletedSigChain

func (f *JSONConfigFile) GetReadDeletedSigChain() (bool, bool)

func (*JSONConfigFile) GetRememberPassphrase

func (f *JSONConfigFile) GetRememberPassphrase(username NormalizedUsername) (bool, bool)

func (*JSONConfigFile) GetRunMode

func (f *JSONConfigFile) GetRunMode() (ret RunMode, err error)

func (*JSONConfigFile) GetRuntimeStatsEnabled

func (f *JSONConfigFile) GetRuntimeStatsEnabled() (bool, bool)

func (*JSONConfigFile) GetScraperTimeout

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

func (*JSONConfigFile) GetSecretKeyringTemplate

func (f *JSONConfigFile) GetSecretKeyringTemplate() string

func (*JSONConfigFile) GetSecretStorePrimingDisabled

func (f *JSONConfigFile) GetSecretStorePrimingDisabled() (bool, bool)

func (*JSONConfigFile) GetSecurityAccessGroupOverride

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

func (*JSONConfigFile) GetServerURI

func (f *JSONConfigFile) GetServerURI() (string, error)

func (*JSONConfigFile) GetSessionFilename

func (f *JSONConfigFile) GetSessionFilename() string

func (*JSONConfigFile) GetSlowGregorConn

func (f *JSONConfigFile) GetSlowGregorConn() (bool, bool)

func (*JSONConfigFile) GetSocketFile

func (f *JSONConfigFile) GetSocketFile() string

func (*JSONConfigFile) GetStandalone

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

func (*JSONConfigFile) GetStayLoggedOut

func (f *JSONConfigFile) GetStayLoggedOut() (bool, bool)

func (*JSONConfigFile) GetTimeAtPath

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

func (*JSONConfigFile) GetTimers

func (f *JSONConfigFile) GetTimers() string

func (*JSONConfigFile) GetTopLevelBool

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

func (*JSONConfigFile) GetTopLevelString

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

func (*JSONConfigFile) GetTorHiddenAddress

func (f *JSONConfigFile) GetTorHiddenAddress() string

func (*JSONConfigFile) GetTorMode

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

func (*JSONConfigFile) GetTorProxy

func (f *JSONConfigFile) GetTorProxy() string

func (*JSONConfigFile) GetUID

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

func (*JSONConfigFile) GetUIDForUsername

func (f *JSONConfigFile) GetUIDForUsername(n NormalizedUsername) keybase1.UID

func (*JSONConfigFile) GetUIDMapFullNameCacheSize

func (f *JSONConfigFile) GetUIDMapFullNameCacheSize() (int, bool)

func (*JSONConfigFile) GetUPAKCacheSize

func (f *JSONConfigFile) GetUPAKCacheSize() (int, bool)

func (*JSONConfigFile) GetUpdateDisabled

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

func (*JSONConfigFile) GetUpdateLastChecked

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

func (*JSONConfigFile) GetUpdatePreferenceAuto

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

func (*JSONConfigFile) GetUpdatePreferenceSkip

func (f *JSONConfigFile) GetUpdatePreferenceSkip() string

func (*JSONConfigFile) GetUpdatePreferenceSnoozeUntil

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

func (*JSONConfigFile) GetUpdateURL

func (f *JSONConfigFile) GetUpdateURL() string

func (*JSONConfigFile) GetUpdaterConfigFilename

func (f *JSONConfigFile) GetUpdaterConfigFilename() string

func (*JSONConfigFile) GetUseDefaultLogFile

func (f *JSONConfigFile) GetUseDefaultLogFile() (bool, bool)

func (*JSONConfigFile) GetUseRootConfigFile

func (f *JSONConfigFile) GetUseRootConfigFile() (bool, bool)

func (*JSONConfigFile) GetUserCacheMaxAge

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

func (*JSONConfigFile) GetUserConfig

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

func (*JSONConfigFile) GetUserConfigForUID

func (f *JSONConfigFile) GetUserConfigForUID(u keybase1.UID) (*UserConfig, error)

GetUserConfigForUID sees if there's a UserConfig object for the given UIDs previously stored.

func (*JSONConfigFile) GetUserConfigForUsername

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

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

func (*JSONConfigFile) GetUsername

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

func (*JSONConfigFile) GetUsernameForUID

func (f *JSONConfigFile) GetUsernameForUID(u keybase1.UID) NormalizedUsername

func (*JSONConfigFile) GetVDebugSetting

func (f *JSONConfigFile) GetVDebugSetting() string

func (*JSONConfigFile) IsCertPinningEnabled

func (f *JSONConfigFile) IsCertPinningEnabled() bool

func (*JSONConfigFile) IsMobileExtension

func (f *JSONConfigFile) IsMobileExtension() (bool, bool)

func (*JSONConfigFile) NukeUser

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

NukeUser deletes the given user from the config file, or if the given user is empty, deletes the current user from the config file.

func (*JSONConfigFile) Reset

func (f *JSONConfigFile) Reset()

func (*JSONConfigFile) SetAndroidInstallReferrerChecked

func (f *JSONConfigFile) SetAndroidInstallReferrerChecked(b bool) error

func (*JSONConfigFile) SetBug3964RepairTime

func (f *JSONConfigFile) SetBug3964RepairTime(un NormalizedUsername, t time.Time) (err error)

func (*JSONConfigFile) SetDeviceID

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

SetDeviceID sets the device field of the UserConfig object

func (*JSONConfigFile) SetPassphraseState

func (f *JSONConfigFile) SetPassphraseState(passphraseState keybase1.PassphraseState) (err error)

func (*JSONConfigFile) SetRememberPassphrase

func (f *JSONConfigFile) SetRememberPassphrase(username NormalizedUsername, remember bool) error

func (*JSONConfigFile) SetStayLoggedOut

func (f *JSONConfigFile) SetStayLoggedOut(stayLoggedOut bool) error

func (*JSONConfigFile) SetTimeAtPath

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

func (*JSONConfigFile) SetUpdateLastChecked

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

func (*JSONConfigFile) SetUpdatePreferenceAuto

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

func (*JSONConfigFile) SetUpdatePreferenceSkip

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

func (*JSONConfigFile) SetUpdatePreferenceSnoozeUntil

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

func (*JSONConfigFile) SetUserConfig

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

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

func (*JSONConfigFile) SwitchUser

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

type JSONFile

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

func NewJSONFile

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

func (*JSONFile) BeginTransaction

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

func (*JSONFile) DeleteAtPath

func (f *JSONFile) DeleteAtPath(p string)

func (*JSONFile) Exists

func (f *JSONFile) Exists() bool

func (*JSONFile) GetBoolAtPath

func (f *JSONFile) GetBoolAtPath(p string) (ret bool, isSet bool)

func (*JSONFile) GetFilename

func (f *JSONFile) GetFilename() string

func (*JSONFile) GetFloatAtPath

func (f *JSONFile) GetFloatAtPath(p string) (ret float64, isSet bool)

func (*JSONFile) GetIntAtPath

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

func (*JSONFile) GetInterfaceAtPath

func (f *JSONFile) GetInterfaceAtPath(p string) (i interface{}, err error)

func (*JSONFile) GetNullAtPath

func (f *JSONFile) GetNullAtPath(p string) (isSet bool)

func (*JSONFile) GetStringAtPath

func (f *JSONFile) GetStringAtPath(p string) (ret string, isSet bool)

func (*JSONFile) GetWrapper

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

func (*JSONFile) Load

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

func (*JSONFile) LoadCheckFound

func (f *JSONFile) LoadCheckFound() (found bool, err error)

func (*JSONFile) Nuke

func (f *JSONFile) Nuke() error

func (*JSONFile) Save

func (f *JSONFile) Save() error

func (*JSONFile) SetBoolAtPath

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

func (*JSONFile) SetFloatAtPath

func (f *JSONFile) SetFloatAtPath(p string, v float64) error

func (*JSONFile) SetInt64AtPath

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

func (*JSONFile) SetIntAtPath

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

func (*JSONFile) SetNullAtPath

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

func (*JSONFile) SetStringAtPath

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

func (*JSONFile) SetWrapperAtPath

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

type JSONLocalDb

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

func NewJSONLocalDb

func NewJSONLocalDb(e LocalDb) *JSONLocalDb

func (*JSONLocalDb) Clean

func (j *JSONLocalDb) Clean(force bool) error

func (*JSONLocalDb) Close

func (j *JSONLocalDb) Close() error

func (*JSONLocalDb) CompactionStats

func (j *JSONLocalDb) CompactionStats() (bool, bool, error)

func (*JSONLocalDb) Delete

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

func (*JSONLocalDb) ForceOpen

func (j *JSONLocalDb) ForceOpen() error

func (*JSONLocalDb) Get

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

func (*JSONLocalDb) GetEngine

func (j *JSONLocalDb) GetEngine() LocalDb

func (*JSONLocalDb) GetInto

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

func (*JSONLocalDb) GetIntoMsgpack

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

func (*JSONLocalDb) GetRaw

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

func (*JSONLocalDb) KeysWithPrefixes

func (j *JSONLocalDb) KeysWithPrefixes(prefixes ...[]byte) (DBKeySet, error)

func (*JSONLocalDb) Lookup

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

func (*JSONLocalDb) LookupIntoMsgpack

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

func (*JSONLocalDb) Nuke

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

func (*JSONLocalDb) Open

func (j *JSONLocalDb) Open() error

func (*JSONLocalDb) OpenTransaction

func (j *JSONLocalDb) OpenTransaction() (JSONLocalDbTransaction, error)

func (*JSONLocalDb) Put

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

func (*JSONLocalDb) PutObj

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

func (*JSONLocalDb) PutObjMsgpack

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

func (*JSONLocalDb) PutRaw

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

func (*JSONLocalDb) Stats

func (j *JSONLocalDb) Stats() string

type JSONLocalDbTransaction

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

func (JSONLocalDbTransaction) Commit

func (j JSONLocalDbTransaction) Commit() error

func (JSONLocalDbTransaction) Delete

func (j JSONLocalDbTransaction) Delete(id DbKey) error

func (JSONLocalDbTransaction) Discard

func (j JSONLocalDbTransaction) Discard()

func (JSONLocalDbTransaction) Get

func (JSONLocalDbTransaction) GetInto

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

func (JSONLocalDbTransaction) GetRaw

func (j JSONLocalDbTransaction) GetRaw(id DbKey) ([]byte, bool, error)

func (JSONLocalDbTransaction) Lookup

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

func (JSONLocalDbTransaction) Put

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

func (JSONLocalDbTransaction) PutObj

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

func (JSONLocalDbTransaction) PutRaw

func (j JSONLocalDbTransaction) PutRaw(id DbKey, b []byte) error

type JSONPayload

type JSONPayload map[string]interface{}

type JSONReader

type JSONReader interface {
	GetStringAtPath(string) (string, bool)
	GetInterfaceAtPath(string) (interface{}, error)
	GetBoolAtPath(string) (bool, bool)
	GetIntAtPath(string) (int, bool)
	GetFloatAtPath(string) (float64, bool)
	GetNullAtPath(string) bool
}

type JSONUpdaterConfigFile

type JSONUpdaterConfigFile struct {
	*JSONFile
}

func NewJSONUpdaterConfigFile

func NewJSONUpdaterConfigFile(g *GlobalContext) *JSONUpdaterConfigFile

func (*JSONUpdaterConfigFile) GetInstallID

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

type JSONWriter

type JSONWriter interface {
	SetStringAtPath(string, string) error
	SetBoolAtPath(string, bool) error
	SetIntAtPath(string, int) error
	SetFloatAtPath(string, float64) error
	SetNullAtPath(string) error
	SetWrapperAtPath(string, *jsonw.Wrapper) error
	DeleteAtPath(string)
}

type KBFSNotRunningError

type KBFSNotRunningError struct{}

func (KBFSNotRunningError) Error

func (e KBFSNotRunningError) Error() string

type KVRevisionCacher

type KVRevisionCacher interface {
	Check(mctx MetaContext, entryID keybase1.KVEntryID, ciphertext *string, teamKeyGen keybase1.PerTeamKeyGeneration, revision int) (err error)
	Put(mctx MetaContext, entryID keybase1.KVEntryID, ciphertext *string, teamKeyGen keybase1.PerTeamKeyGeneration, revision int) (err error)
	CheckForUpdate(mctx MetaContext, entryID keybase1.KVEntryID, revision int) (err error)
	MarkDeleted(mctx MetaContext, entryID keybase1.KVEntryID, revision int) (err error)
}

type KVStoreContext

type KVStoreContext interface {
	GetKVStore() KVStorer
}

type KVStorer

type KVStorer interface {
	GetInto(obj interface{}, id DbKey) (found bool, err error)
	PutObj(id DbKey, aliases []DbKey, obj interface{}) (err error)
	Delete(id DbKey) error
	KeysWithPrefixes(prefixes ...[]byte) (DBKeySet, error)
}

type Kex2Secret

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

func NewKex2SecretFromTypeAndUID

func NewKex2SecretFromTypeAndUID(typ Kex2SecretType, uid keybase1.UID) (*Kex2Secret, error)

func NewKex2SecretFromUIDAndPhrase

func NewKex2SecretFromUIDAndPhrase(uid keybase1.UID, phrase string) (*Kex2Secret, error)

func (*Kex2Secret) Phrase

func (s *Kex2Secret) Phrase() string

func (*Kex2Secret) Secret

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

type Kex2SecretType

type Kex2SecretType int
const (
	Kex2SecretTypeNone      Kex2SecretType = 0
	Kex2SecretTypeV1Desktop Kex2SecretType = 1
	Kex2SecretTypeV1Mobile  Kex2SecretType = 2
	Kex2SecretTypeV2        Kex2SecretType = 3
)

type KexRole

type KexRole int
const (
	KexRoleProvisioner KexRole = iota
	KexRoleProvisionee
)

type KexRouter

type KexRouter struct {
	MetaContextified
}

KexRouter implements the kex2.MessageRouter interface.

func NewKexRouter

func NewKexRouter(m MetaContext) *KexRouter

NewKexRouter creates a contextified KexRouter.

func (*KexRouter) Get

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

Get implements Get in the kex2.MessageRouter interface.

func (*KexRouter) Post

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

Post implements Post in the kex2.MessageRouter interface.

type KeyCannotDecryptError

type KeyCannotDecryptError struct{}

func (KeyCannotDecryptError) Error

func (k KeyCannotDecryptError) Error() string

type KeyCannotEncryptError

type KeyCannotEncryptError struct{}

func (KeyCannotEncryptError) Error

func (k KeyCannotEncryptError) Error() string

type KeyCannotSignError

type KeyCannotSignError struct{}

func (KeyCannotSignError) Error

func (s KeyCannotSignError) Error() string

type KeyCannotVerifyError

type KeyCannotVerifyError struct{}

func (KeyCannotVerifyError) Error

func (k KeyCannotVerifyError) Error() string

type KeyCorruptedError

type KeyCorruptedError struct {
	Msg string
}

func (KeyCorruptedError) Error

func (e KeyCorruptedError) Error() string

func (KeyCorruptedError) ToStatus

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

type KeyExistsError

type KeyExistsError struct {
	Key *PGPFingerprint
}

func (KeyExistsError) Error

func (k KeyExistsError) Error() string

func (KeyExistsError) ToStatus

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

type KeyExpiredError

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

func (KeyExpiredError) Error

func (r KeyExpiredError) Error() string

type KeyFamily

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

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

	BundlesForTesting []string

	Contextified
	// contains filtered or unexported fields
}

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

func ParseKeyFamily

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

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

func (KeyFamily) Export

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

func (*KeyFamily) LocalDelegate

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

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

func (KeyFamily) ShallowCopy

func (kf KeyFamily) ShallowCopy() *KeyFamily

type KeyFamilyError

type KeyFamilyError struct {
	Msg string
}

func (KeyFamilyError) Error

func (e KeyFamilyError) Error() string

type KeyGen

type KeyGen int

type KeyGenError

type KeyGenError struct {
	Msg string
}

func (KeyGenError) Error

func (e KeyGenError) Error() string

func (KeyGenError) ToStatus

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

type KeyMaskNotFoundError

type KeyMaskNotFoundError struct {
	App keybase1.TeamApplication
	Gen keybase1.PerTeamKeyGeneration
}

func (KeyMaskNotFoundError) Error

func (e KeyMaskNotFoundError) Error() string

func (KeyMaskNotFoundError) ToStatus

func (e KeyMaskNotFoundError) ToStatus() keybase1.Status

type KeyPseudonym

type KeyPseudonym [32]byte

KeyPseudonym is a "random looking" identifier which refers to a specific application key belonging to a user or team (the key is referred to by the application id, the generation number and the user or team id). Pseudonyms are only used for saltpack encryption at the moment, but more applications are possible. They are used to avoid that, when decrypting a message encrypted with a team key, a user has to loop through all the keys of all the teams he is part of to find the right one. To avoid this, when encrypting for a team, the sender generates such a pseudonym (which refers to the key it used to encrypt), sends it to the server and includes it as a recipient identifier for the appropriare recipient payload box in the header of the saltpack message. When decrypting a saltpack message, a recipient can ask the server if any of the recipient identifiers in the message correspond to known pseudonyms (for teams the user is part of), and use the response from the server to identify which key to use for decryption. This mechanism substitutes an older kbfs based one (which is still supported to allow decryptions of old saltpack messages).

A pseudonym is computed as an HMAC (with a random nonce as a key) of the information it refers to in order to prevent the server from tampering with the mapping (we rely on collision resistance and not unforgeability, as the server knows the nonce, so a simple SHA256 would have worked as well).

func MakeKeyPseudonym

func MakeKeyPseudonym(info KeyPseudonymInfo) (KeyPseudonym, error)

MakePseudonym makes a key pseudonym from the given input.

func (KeyPseudonym) Eq

func (p KeyPseudonym) Eq(r KeyPseudonym) bool

func (*KeyPseudonym) MarshalJSON

func (p *KeyPseudonym) MarshalJSON() ([]byte, error)

func (KeyPseudonym) String

func (p KeyPseudonym) String() string

func (*KeyPseudonym) UnmarshalJSON

func (p *KeyPseudonym) UnmarshalJSON(b []byte) error

type KeyPseudonymError

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

func NewKeyPseudonymError

func NewKeyPseudonymError(message string) KeyPseudonymError

func (KeyPseudonymError) Error

func (e KeyPseudonymError) Error() string

type KeyPseudonymGetError

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

PseudonymGetError is sometimes written by unmarshaling (some fields of) a server response.

func (KeyPseudonymGetError) Error

func (e KeyPseudonymGetError) Error() string

type KeyPseudonymInfo

type KeyPseudonymInfo struct {
	KeyPseudonym KeyPseudonym
	ID           keybase1.UserOrTeamID
	Application  keybase1.TeamApplication
	KeyGen       KeyGen
	Nonce        KeyPseudonymNonce
}

KeyPseudonymInfo contains the KeyPseudonym as well as information about the key it represents.

type KeyPseudonymNonce

type KeyPseudonymNonce [32]byte

func RandomPseudonymNonce

func RandomPseudonymNonce() KeyPseudonymNonce

RandomPseudonymNonce returns a random nonce, which is used as an HMAC key.

func (*KeyPseudonymNonce) MarshalJSON

func (p *KeyPseudonymNonce) MarshalJSON() ([]byte, error)

func (KeyPseudonymNonce) String

func (p KeyPseudonymNonce) String() string

func (*KeyPseudonymNonce) UnmarshalJSON

func (p *KeyPseudonymNonce) UnmarshalJSON(b []byte) error

type KeyPseudonymOrError

type KeyPseudonymOrError struct {
	// Exactly one of these 2 fields is nil.
	Err  error
	Info *KeyPseudonymInfo
}

func GetKeyPseudonyms

func GetKeyPseudonyms(m MetaContext, pnyms []KeyPseudonym) ([]KeyPseudonymOrError, error)

GetKeyPseudonyms fetches info for a list of pseudonyms. The output structs are returned in the order corresponding to the inputs. The top-level error is filled if the entire request fails. The error in each of the returned structs may be filled for per-pseudonym errors.

type KeyRevokedError

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

func NewKeyRevokedError

func NewKeyRevokedError(m string) KeyRevokedError

func (KeyRevokedError) Error

func (r KeyRevokedError) Error() string

func (KeyRevokedError) ToStatus

func (e KeyRevokedError) ToStatus() keybase1.Status

type KeyRole

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

type KeySection

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

func (KeySection) ToJSON

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

type KeyStatus

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

type KeyType

type KeyType int
const (
	KeyTypeNone                  KeyType = 0
	KeyTypeOpenPGPPublic         KeyType = 1
	KeyTypeP3skbPrivate          KeyType = 2
	KeyTypeKbNaclEddsa           KeyType = 3
	KeyTypeKbNaclDH              KeyType = 4
	KeyTypeKbNaclEddsaServerHalf KeyType = 5
	KeyTypeKbNaclDHServerHalf    KeyType = 6
)

type KeyUnimplementedError

type KeyUnimplementedError struct{}

func (KeyUnimplementedError) Error

func (k KeyUnimplementedError) Error() string

type KeyUnlocker

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

func NewKeyUnlocker

func NewKeyUnlocker(tries int, reason string, keyDesc string, which PassphraseType, useSecretStore bool, ui SecretUI, unlocker UnlockerFunc) KeyUnlocker

func (KeyUnlocker) Run

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

type KeyVersionError

type KeyVersionError struct{}

func (KeyVersionError) Error

func (k KeyVersionError) Error() string

type KeybaseSaltpackError

type KeybaseSaltpackError struct{}

func (KeybaseSaltpackError) Error

func (e KeybaseSaltpackError) Error() string

type KeybaseTime

type KeybaseTime struct {
	Unix  int64          // UTC wallclock time
	Chain keybase1.Seqno // Merkle root chain time
}

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

func NowAsKeybaseTime

func NowAsKeybaseTime(seqno keybase1.Seqno) *KeybaseTime

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

func TclToKeybaseTime

func TclToKeybaseTime(tcl TypedChainLink) *KeybaseTime

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

type KeychainMode

type KeychainMode int
const (
	KeychainModeNone   KeychainMode = 0
	KeychainModeOS     KeychainMode = 1
	KeychainModeMemory KeychainMode = 2
)

type KeyringFile

type KeyringFile struct {
	Entities openpgp.EntityList

	Contextified
	// contains filtered or unexported fields
}

func (KeyringFile) GetFilename

func (k KeyringFile) GetFilename() string

func (*KeyringFile) Index

func (k *KeyringFile) Index() error

func (*KeyringFile) Load

func (k *KeyringFile) Load() error

func (*KeyringFile) LoadAndIndex

func (k *KeyringFile) LoadAndIndex() error

func (KeyringFile) Save

func (k KeyringFile) Save(g *GlobalContext) error

func (KeyringFile) WriteTo

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

type Keyrings

type Keyrings struct {
	Contextified
}

func NewKeyrings

func NewKeyrings(g *GlobalContext) *Keyrings

func (*Keyrings) GetSecretKeyAndSKBWithPrompt

func (k *Keyrings) GetSecretKeyAndSKBWithPrompt(m MetaContext, arg SecretKeyPromptArg) (key GenericKey, skb *SKB, err error)

func (*Keyrings) GetSecretKeyLocked

func (k *Keyrings) GetSecretKeyLocked(m MetaContext, ska SecretKeyArg) (ret *SKB, err error)

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

func (*Keyrings) GetSecretKeyWithPassphrase

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

func (*Keyrings) GetSecretKeyWithPrompt

func (k *Keyrings) GetSecretKeyWithPrompt(m MetaContext, arg SecretKeyPromptArg) (key GenericKey, err error)

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

func (*Keyrings) GetSecretKeyWithStoredSecret

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

type LKSec

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

func NewLKSec

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

func NewLKSecForEncrypt

func NewLKSecForEncrypt(m MetaContext, ui SecretUI, uid keybase1.UID) (ret *LKSec, err error)

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

func NewLKSecWithClientHalf

func NewLKSecWithClientHalf(clientHalf LKSecClientHalf, ppgen PassphraseGeneration, uid keybase1.UID) *LKSec

func NewLKSecWithDeviceID

func NewLKSecWithDeviceID(pps *PassphraseStream, uid keybase1.UID, deviceID keybase1.DeviceID) *LKSec

func NewLKSecWithFullSecret

func NewLKSecWithFullSecret(secret LKSecFullSecret, uid keybase1.UID) *LKSec

func (LKSec) ClientHalf

func (s LKSec) ClientHalf() LKSecClientHalf

func (*LKSec) ComputeClientHalf

func (s *LKSec) ComputeClientHalf() (ret LKSecClientHalf, err error)

func (*LKSec) CorruptedFullSecretForBug3964Testing

func (s *LKSec) CorruptedFullSecretForBug3964Testing(srv LKSecServerHalf) LKSecFullSecret

func (*LKSec) Decrypt

func (s *LKSec) Decrypt(m MetaContext, src []byte) (res []byte, gen PassphraseGeneration, erroneousMask LKSecServerHalf, err error)

func (*LKSec) Encrypt

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

func (*LKSec) EncryptClientHalfRecovery

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

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

func (*LKSec) FullSecret

func (s *LKSec) FullSecret() LKSecFullSecret

func (*LKSec) GenerateServerHalf

func (s *LKSec) GenerateServerHalf() error

func (LKSec) Generation

func (s LKSec) Generation() PassphraseGeneration

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

func (*LKSec) GetSecret

func (s *LKSec) GetSecret(m MetaContext) (secret LKSecFullSecret, err error)

func (*LKSec) GetServerHalf

func (s *LKSec) GetServerHalf() LKSecServerHalf

func (*LKSec) Load

func (s *LKSec) Load(m MetaContext) (err error)

func (*LKSec) LoadServerDetails

func (s *LKSec) LoadServerDetails(m MetaContext) (ret DeviceKeyMap, err error)

func (*LKSec) LoadServerHalf

func (s *LKSec) LoadServerHalf(m MetaContext) (err error)

func (LKSec) ServerHalf

func (s LKSec) ServerHalf() LKSecServerHalf

func (*LKSec) SetClientHalf

func (s *LKSec) SetClientHalf(b LKSecClientHalf)

func (*LKSec) SetFullSecret

func (s *LKSec) SetFullSecret(m MetaContext)

func (*LKSec) SetServerHalf

func (s *LKSec) SetServerHalf(b LKSecServerHalf)

func (*LKSec) SetUID

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

func (*LKSec) ToSKB

func (s *LKSec) ToSKB(m MetaContext, key GenericKey) (ret *SKB, err error)

ToSKB exports a generic key with the given LKSec to a SecretKeyBundle, performing all necessary encryption.

type LKSecClientHalf

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

func NewLKSecClientHalfFromBytes

func NewLKSecClientHalfFromBytes(b []byte) (ret LKSecClientHalf, err error)

func (LKSecClientHalf) Bytes

func (c LKSecClientHalf) Bytes() []byte

func (LKSecClientHalf) ComputeMask

func (c LKSecClientHalf) ComputeMask(c2 LKSecClientHalf) LKSecMask

func (LKSecClientHalf) Equal

func (c LKSecClientHalf) Equal(c2 LKSecClientHalf) bool

func (LKSecClientHalf) IsNil

func (c LKSecClientHalf) IsNil() bool

type LKSecFullSecret

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

func (LKSecFullSecret) Bytes

func (f LKSecFullSecret) Bytes() []byte

func (LKSecFullSecret) Equal

func (f LKSecFullSecret) Equal(f2 LKSecFullSecret) bool

func (LKSecFullSecret) IsNil

func (f LKSecFullSecret) IsNil() bool

type LKSecMask

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

func (LKSecMask) EncodeToHex

func (m LKSecMask) EncodeToHex() string

func (LKSecMask) IsNil

func (m LKSecMask) IsNil() bool

type LKSecServerHalf

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

func NewLKSecServerHalfFromHex

func NewLKSecServerHalfFromHex(s string) (ret LKSecServerHalf, err error)

func NewLKSecServerHalfZeros

func NewLKSecServerHalfZeros() LKSecServerHalf

func (LKSecServerHalf) Bytes

func (s LKSecServerHalf) Bytes() []byte

func (LKSecServerHalf) ComputeClientHalf

func (s LKSecServerHalf) ComputeClientHalf(f LKSecFullSecret) LKSecClientHalf

func (LKSecServerHalf) ComputeFullSecret

func (s LKSecServerHalf) ComputeFullSecret(c LKSecClientHalf) LKSecFullSecret

func (LKSecServerHalf) EncodeToHex

func (s LKSecServerHalf) EncodeToHex() string

func (LKSecServerHalf) IsNil

func (s LKSecServerHalf) IsNil() bool

type LKSecServerHalfSet

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

func NewLKSecServerHalfSet

func NewLKSecServerHalfSet() *LKSecServerHalfSet

func (*LKSecServerHalfSet) Add

func (*LKSecServerHalfSet) EncodeToHexList

func (l *LKSecServerHalfSet) EncodeToHexList() string

type LRUContext

type LRUContext interface {
	VLogContext
	KVStoreContext
	ClockContext
}

type LRUKeyer

type LRUKeyer interface {
	MemKey() string
	DbKey() DbKey
}

type LRUer

type LRUer interface {
	Get(context.Context, LRUContext, LRUKeyer) (interface{}, error)
	Put(context.Context, LRUContext, LRUKeyer, interface{}) error
	OnLogout(mctx MetaContext) error
	OnDbNuke(mctx MetaContext) error
}

type LabelCb

type LabelCb func(typ keybase1.ClientType)

LabelCb is a callback to be run when a client connects and labels itself.

type Lease

type Lease struct {
	MerkleSeqno keybase1.Seqno    `json:"merkle_seqno"`
	LeaseID     keybase1.LeaseID  `json:"downgrade_lease_id"`
	HashMeta    keybase1.HashMeta `json:"hash_meta"`
}

type LevelDBOpenClosedError

type LevelDBOpenClosedError struct{}

func (LevelDBOpenClosedError) Error

func (e LevelDBOpenClosedError) Error() string

type LevelDb

type LevelDb struct {
	// We use a RWMutex here to ensure close doesn't happen in the middle of
	// other DB operations, and DB operations doesn't happen after close. The
	// lock should be considered for the db pointer and dbOpenerOnce pointer,
	// rather than the DB itself.  More specifically, close does Lock(), while
	// other DB operations does RLock().
	sync.RWMutex

	Contextified
	// contains filtered or unexported fields
}

func NewLevelDb

func NewLevelDb(g *GlobalContext, filename func() string) *LevelDb

func (*LevelDb) Clean

func (l *LevelDb) Clean(force bool) (err error)

func (*LevelDb) Close

func (l *LevelDb) Close() error

func (*LevelDb) CompactionStats

func (l *LevelDb) CompactionStats() (memActive, tableActive bool, err error)

func (*LevelDb) Delete

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

func (*LevelDb) ForceOpen

func (l *LevelDb) ForceOpen() error

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

func (*LevelDb) Get

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

func (*LevelDb) GetFilename

func (l *LevelDb) GetFilename() string

func (*LevelDb) KeysWithPrefixes

func (l *LevelDb) KeysWithPrefixes(prefixes ...[]byte) (DBKeySet, error)

func (*LevelDb) Lookup

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

func (*LevelDb) Nuke

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

func (*LevelDb) Open

func (l *LevelDb) Open() error

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

func (*LevelDb) OpenTransaction

func (l *LevelDb) OpenTransaction() (LocalDbTransaction, error)

func (*LevelDb) Opts

func (l *LevelDb) Opts() *opt.Options

Opts returns the options for all leveldb databases.

PC: I think it's worth trying a bloom filter. From docs: "In many cases, a filter can cut down the number of disk seeks from a handful to a single disk seek per DB.Get call."

func (*LevelDb) Put

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

func (*LevelDb) Stats

func (l *LevelDb) Stats() (stats string)

type LevelDbTransaction

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

func (LevelDbTransaction) Commit

func (l LevelDbTransaction) Commit() (err error)

func (LevelDbTransaction) Delete

func (l LevelDbTransaction) Delete(id DbKey) error

func (LevelDbTransaction) Discard

func (l LevelDbTransaction) Discard()

func (LevelDbTransaction) Get

func (l LevelDbTransaction) Get(id DbKey) (val []byte, found bool, err error)

func (LevelDbTransaction) Lookup

func (l LevelDbTransaction) Lookup(id DbKey) (val []byte, found bool, err error)

func (LevelDbTransaction) Put

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

type Lexer

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

func NewLexer

func NewLexer(s string) *Lexer

func (*Lexer) Get

func (lx *Lexer) Get() Token

func (*Lexer) Putback

func (lx *Lexer) Putback()

type LinkCache

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

LinkCache is a cache of ChainLinks. It is safe to use concurrently.

func NewLinkCache

func NewLinkCache(maxSize int, cleanDur time.Duration) *LinkCache

NewLinkCache creates a LinkCache. When finished using this LinkCache, call Shutdown on it to clean up.

func (*LinkCache) Clean

func (c *LinkCache) Clean()

func (*LinkCache) Get

func (c *LinkCache) Get(id LinkID) (link ChainLink, ok bool)

Get retrieves a ChainLink from the cache. If nothing exists for this LinkID, it will return false for ok.

func (*LinkCache) Len

func (c *LinkCache) Len() int

Len returns the number of ChainLinks cached.

func (*LinkCache) Mutate

func (c *LinkCache) Mutate(id LinkID, f func(c *ChainLink))

func (*LinkCache) Put

func (c *LinkCache) Put(m MetaContext, id LinkID, link ChainLink)

func (*LinkCache) Remove

func (c *LinkCache) Remove(id LinkID)

Remove deletes a ChainLink from the cache.

func (*LinkCache) Shutdown

func (c *LinkCache) Shutdown()

Shutdown terminates the use of this cache.

type LinkCheckResult

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

func (LinkCheckResult) Export

func (LinkCheckResult) ExportToIdentifyRow

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

func (LinkCheckResult) GetCached

func (l LinkCheckResult) GetCached() *CheckResult

func (LinkCheckResult) GetDiff

func (l LinkCheckResult) GetDiff() TrackDiff

func (LinkCheckResult) GetError

func (l LinkCheckResult) GetError() error

func (LinkCheckResult) GetHint

func (l LinkCheckResult) GetHint() *SigHint

func (LinkCheckResult) GetPosition

func (l LinkCheckResult) GetPosition() int

func (LinkCheckResult) GetProofError

func (l LinkCheckResult) GetProofError() ProofError

func (LinkCheckResult) GetRemoteDiff

func (l LinkCheckResult) GetRemoteDiff() TrackDiff

func (LinkCheckResult) GetTorWarning

func (l LinkCheckResult) GetTorWarning() bool

type LinkID

type LinkID []byte

func ComputeLinkID

func ComputeLinkID(d []byte) LinkID

func GetLinkID

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

func ImportLinkID

func ImportLinkID(i keybase1.LinkID) (LinkID, error)

func LinkIDFromHex

func LinkIDFromHex(s string) (LinkID, error)

func MakeSig

func MakeSig(
	m MetaContext,
	signingKey GenericKey,
	v1LinkType LinkType,
	innerLinkJSON []byte,
	hasRevokes SigHasRevokes,
	seqType keybase1.SeqType,
	ignoreIfUnsupported SigIgnoreIfUnsupported,
	me *User,
	sigVersion SigVersion) (sig string, sigID keybase1.SigID, linkID LinkID, err error)

func MakeSigchainV2OuterSig

func MakeSigchainV2OuterSig(
	m MetaContext,
	signingKey GenericKey,
	v1LinkType LinkType,
	seqno keybase1.Seqno,
	innerLinkJSON []byte,
	prevLinkID LinkID,
	hasRevokes SigHasRevokes,
	seqType keybase1.SeqType,
	ignoreIfUnsupported SigIgnoreIfUnsupported,
	highSkip *HighSkip,
) (sig string, sigid keybase1.SigID, linkID LinkID, err error)

func SignJSON

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

SimpleSignJson marshals the given Json structure and then signs it.

func (LinkID) Eq

func (l LinkID) Eq(i2 LinkID) bool

func (LinkID) Export

func (i LinkID) Export() keybase1.LinkID

func (*LinkID) MarshalJSON

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

func (LinkID) String

func (l LinkID) String() string

func (*LinkID) UnmarshalJSON

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

type LinkType

type LinkType string

type LoadUnlockedDeviceKeysMode

type LoadUnlockedDeviceKeysMode int
const (
	// Normal checks the cache and polls if it is stale. StaleOK checks the cache
	// and polls if it is empty. Offline uses the cache and errors if it is empty.
	LoadUnlockedDeviceKeysModeNormal LoadUnlockedDeviceKeysMode = iota
	LoadUnlockedDeviceKeysModeStaleOK
	LoadUnlockedDeviceKeysModeOffline
)

type LoadUserArg

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

func NewLoadUserArg

func NewLoadUserArg(g *GlobalContext) LoadUserArg

func NewLoadUserArgWithContext

func NewLoadUserArgWithContext(ctx context.Context, g *GlobalContext) LoadUserArg

func NewLoadUserArgWithMetaContext

func NewLoadUserArgWithMetaContext(m MetaContext) LoadUserArg

func NewLoadUserByNameArg

func NewLoadUserByNameArg(g *GlobalContext, name string) LoadUserArg

func NewLoadUserByUIDArg

func NewLoadUserByUIDArg(ctx context.Context, g *GlobalContext, uid keybase1.UID) LoadUserArg

func NewLoadUserByUIDForceArg

func NewLoadUserByUIDForceArg(g *GlobalContext, uid keybase1.UID) LoadUserArg

func NewLoadUserForceArg

func NewLoadUserForceArg(g *GlobalContext) LoadUserArg

func NewLoadUserPubOptionalArg

func NewLoadUserPubOptionalArg(g *GlobalContext) LoadUserArg

func NewLoadUserSelfAndUIDArg

func NewLoadUserSelfAndUIDArg(g *GlobalContext) LoadUserArg

func NewLoadUserSelfArg

func NewLoadUserSelfArg(g *GlobalContext) LoadUserArg

func (LoadUserArg) EnsureCtxAndLogTag

func (arg LoadUserArg) EnsureCtxAndLogTag() LoadUserArg

func (LoadUserArg) ForUPAKLite

func (arg LoadUserArg) ForUPAKLite() LoadUserArg

func (LoadUserArg) GetNetContext

func (arg LoadUserArg) GetNetContext() context.Context

func (LoadUserArg) MetaContext

func (arg LoadUserArg) MetaContext() MetaContext

func (LoadUserArg) String

func (arg LoadUserArg) String() string

func (LoadUserArg) ToMerkleOpts

func (arg LoadUserArg) ToMerkleOpts() MerkleOpts

func (LoadUserArg) WithAbortIfSigchainUnchanged

func (arg LoadUserArg) WithAbortIfSigchainUnchanged() LoadUserArg

func (LoadUserArg) WithCachedOnly

func (arg LoadUserArg) WithCachedOnly(b bool) LoadUserArg

func (LoadUserArg) WithForceMerkleServerPolling

func (arg LoadUserArg) WithForceMerkleServerPolling(b bool) LoadUserArg

func (LoadUserArg) WithForcePoll

func (arg LoadUserArg) WithForcePoll(fp bool) LoadUserArg

func (LoadUserArg) WithForceReload

func (arg LoadUserArg) WithForceReload() LoadUserArg

func (LoadUserArg) WithLoginContext

func (arg LoadUserArg) WithLoginContext(l LoginContext) LoadUserArg

func (LoadUserArg) WithName

func (arg LoadUserArg) WithName(n string) LoadUserArg

func (LoadUserArg) WithNetContext

func (arg LoadUserArg) WithNetContext(ctx context.Context) LoadUserArg

func (LoadUserArg) WithPublicKeyOptional

func (arg LoadUserArg) WithPublicKeyOptional() LoadUserArg

func (LoadUserArg) WithResolveBody

func (arg LoadUserArg) WithResolveBody(r *jsonw.Wrapper) LoadUserArg

func (LoadUserArg) WithSelf

func (arg LoadUserArg) WithSelf(self bool) LoadUserArg

func (LoadUserArg) WithStaleOK

func (arg LoadUserArg) WithStaleOK(b bool) LoadUserArg

func (LoadUserArg) WithStubMode

func (arg LoadUserArg) WithStubMode(sm StubMode) LoadUserArg

func (LoadUserArg) WithUID

func (arg LoadUserArg) WithUID(uid keybase1.UID) LoadUserArg

type LocalDb

type LocalDb interface {
	LocalDbOps
	Open() error
	Stats() string
	CompactionStats() (bool, bool, error)
	ForceOpen() error
	Close() error
	Nuke() (string, error)
	Clean(force bool) error
	OpenTransaction() (LocalDbTransaction, error)
	KeysWithPrefixes(prefixes ...[]byte) (DBKeySet, error)
}

type LocalDbOps

type LocalDbOps interface {
	Put(id DbKey, aliases []DbKey, value []byte) error
	Delete(id DbKey) error
	Get(id DbKey) ([]byte, bool, error)
	Lookup(alias DbKey) ([]byte, bool, error)
}

type LocalDbTransaction

type LocalDbTransaction interface {
	LocalDbOps
	Commit() error
	Discard()
}

type LocalSigchainGuard

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

A guard used to tell background tasks to stay off the sigchain while the user is changing their sigchain on purpose. Don't treat this as a lock, it's very sloppy. The guard exists to avoid races where an intentional action like provisioning loads the sigchain, but then it gets changed by a background task, so the intentional action would fail. This is just an atomic bool. Intentional actions can acquire it multiple times, release it even when others have it, so it's sloppy, but you'll never deadlock.

func NewLocalSigchainGuard

func NewLocalSigchainGuard(g *GlobalContext) *LocalSigchainGuard

func (*LocalSigchainGuard) Clear

func (l *LocalSigchainGuard) Clear(ctx context.Context, reason string)

func (*LocalSigchainGuard) IsAvailable

func (l *LocalSigchainGuard) IsAvailable(ctx context.Context, reason string) bool

func (*LocalSigchainGuard) Set

func (l *LocalSigchainGuard) Set(ctx context.Context, reason string)

type LockPIDFile

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

func NewLockPIDFile

func NewLockPIDFile(g *GlobalContext, s string) *LockPIDFile

func (*LockPIDFile) Close

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

func (*LockPIDFile) Lock

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

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

type LockTable

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

func NewLockTable

func NewLockTable() *LockTable

func (*LockTable) AcquireOnName

func (t *LockTable) AcquireOnName(ctx context.Context, g VLogContext, s string) (ret *NamedLock)

AcquireOnName acquires s's lock. Never gives up.

func (*LockTable) AcquireOnNameWithContext

func (t *LockTable) AcquireOnNameWithContext(ctx context.Context, g VLogContext, s string) (ret *NamedLock, err error)

AcquireOnNameWithContext acquires s's lock. Returns (ret, nil) if the lock was acquired. Returns (nil, err) if it was not. The error is from ctx.Err().

func (*LockTable) AcquireOnNameWithContextAndTimeout

func (t *LockTable) AcquireOnNameWithContextAndTimeout(ctx context.Context, g VLogContext, s string, timeout time.Duration) (ret *NamedLock, err error)

AcquireOnNameWithContextAndTimeout acquires s's lock. Returns (ret, nil) if the lock was acquired. Returns (nil, err) if it was not. The error is from ctx.Err() or context.DeadlineExceeded.

type LockedTriplesec

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

LockedTriplesec is a wrapper around a Triplesec interface, which allows multiple goroutines to handle the same underlying Triplesec at the same time. The mechanism is simply a mutex wrapping all accesses.

func NewLockedTriplesec

func NewLockedTriplesec(t Triplesec) *LockedTriplesec

func (*LockedTriplesec) Decrypt

func (t *LockedTriplesec) Decrypt(b []byte) ([]byte, error)

func (*LockedTriplesec) DeriveKey

func (t *LockedTriplesec) DeriveKey(l int) ([]byte, []byte, error)

func (*LockedTriplesec) Encrypt

func (t *LockedTriplesec) Encrypt(b []byte) ([]byte, error)

func (*LockedTriplesec) Scrub

func (t *LockedTriplesec) Scrub()

type LogContext

type LogContext interface {
	GetLog() logger.Logger
}

type LogFunc

type LogFunc func(format string, args ...interface{})

type LogGetter

type LogGetter func() logger.Logger

type LogProfileContext

type LogProfileContext struct {
	Contextified
	Path string
}

LogProfileContext for LogProfile

func (*LogProfileContext) LogProfile

func (l *LogProfileContext) LogProfile(path string) ([]string, error)

type LogUI

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

type LoggedInError

type LoggedInError struct{}

func (LoggedInError) Error

func (e LoggedInError) Error() string

func (LoggedInError) ToStatus

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

type LoggedInWrongUserError

type LoggedInWrongUserError struct {
	ExistingName  NormalizedUsername
	AttemptedName NormalizedUsername
}

func (LoggedInWrongUserError) Error

func (e LoggedInWrongUserError) Error() string

func (LoggedInWrongUserError) ToStatus

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

type LoginAttempt

type LoginAttempt int
const (
	LoginAttemptNone    LoginAttempt = 0
	LoginAttemptOffline LoginAttempt = 1
	LoginAttemptOnline  LoginAttempt = 2
)

type LoginContext

type LoginContext interface {
	LoggedInLoad() (bool, error)
	Salt() []byte
	CreateStreamCache(tsec Triplesec, pps *PassphraseStream)
	SetStreamCache(c *PassphraseStreamCache)
	PassphraseStreamCache() *PassphraseStreamCache

	CreateLoginSessionWithSalt(emailOrUsername string, salt []byte) error
	LoginSession() *LoginSession
	SetLoginSession(l *LoginSession)

	LocalSession() *Session
	GetUID() keybase1.UID
	GetUsername() NormalizedUsername
	GetUserVersion() keybase1.UserVersion
	SaveState(sessionID, csrf string, username NormalizedUsername, uv keybase1.UserVersion, deviceID keybase1.DeviceID) error
	SetUsernameUserVersion(username NormalizedUsername, uv keybase1.UserVersion) error

	Keyring(m MetaContext) (*SKBKeyringFile, error)
	ClearKeyring()
	SecretSyncer() *SecretSyncer
	RunSecretSyncer(m MetaContext, uid keybase1.UID) error
	Dump(m MetaContext, prefix string)
}

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

type LoginHook

type LoginHook interface {
	OnLogin(mctx MetaContext) error
}

type LoginOfflineError

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

func NewLoginOfflineError

func NewLoginOfflineError(msg string) LoginOfflineError

func (LoginOfflineError) Error

func (e LoginOfflineError) Error() string

type LoginRequiredError

type LoginRequiredError struct {
	Context string
}

func (LoginRequiredError) Error

func (e LoginRequiredError) Error() string

func (LoginRequiredError) ToStatus

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

type LoginSession

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

func NewLoginSession

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

func NewLoginSessionWithSalt

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

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

func (*LoginSession) Clear

func (s *LoginSession) Clear() error

Clear removes the loginSession value from s. It does not clear the salt. Unclear how this is useful.

func (*LoginSession) Dump

func (s *LoginSession) Dump()

func (*LoginSession) ExistsFor

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

func (*LoginSession) Load

func (s *LoginSession) Load(m MetaContext) error

func (*LoginSession) NotExpired

func (s *LoginSession) NotExpired() bool

func (*LoginSession) Salt

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

func (*LoginSession) Session

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

func (*LoginSession) SessionEncoded

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

func (*LoginSession) Status

func (s *LoginSession) Status() *keybase1.SessionStatus

type LoginSessionNotFound

type LoginSessionNotFound struct {
	SessionID int
}

func (LoginSessionNotFound) Error

func (e LoginSessionNotFound) Error() string

type LoginStateTimeoutError

type LoginStateTimeoutError struct {
	ActiveRequest    string
	AttemptedRequest string
	Duration         time.Duration
}

func (LoginStateTimeoutError) Error

func (e LoginStateTimeoutError) Error() string

func (LoginStateTimeoutError) ToStatus

func (e LoginStateTimeoutError) ToStatus() keybase1.Status

type LoginUI

type LoginUI interface {
	keybase1.LoginUiInterface
}

type LogoutError

type LogoutError struct{}

func (LogoutError) Error

func (e LogoutError) Error() string

type LogoutHook

type LogoutHook interface {
	OnLogout(mctx MetaContext) error
}

type LogoutOptions

type LogoutOptions struct {
	KeepSecrets bool
	Force       bool
}

type LoopbackAddr

type LoopbackAddr struct{}

LoopbackAddr is an address class that implement the net.Addr interface for loopback devices

func (LoopbackAddr) Network

func (la LoopbackAddr) Network() (s string)

Network returns the name of the network

func (LoopbackAddr) String

func (la LoopbackAddr) String() (s string)

String returns the string form of address

type LoopbackConn

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

LoopbackConn implments the net.Conn interface but is used to loopback from a process to itself. It is goroutine safe.

func (*LoopbackConn) Close

func (lc *LoopbackConn) Close() (err error)

Close closes the connection. Any blocked Read or Write operations will be unblocked and return errors.

func (*LoopbackConn) LocalAddr

func (lc *LoopbackConn) LocalAddr() (addr net.Addr)

LocalAddr returns the local network address.

func (*LoopbackConn) Read

func (lc *LoopbackConn) Read(b []byte) (n int, err error)

Read reads data from the connection.

func (*LoopbackConn) RemoteAddr

func (lc *LoopbackConn) RemoteAddr() (addr net.Addr)

RemoteAddr returns the remote network address.

func (*LoopbackConn) SetDeadline

func (lc *LoopbackConn) SetDeadline(t time.Time) (err error)

SetDeadline sets the read and write deadlines associated with the connection. It is equivalent to calling both SetReadDeadline and SetWriteDeadline.

A deadline is an absolute time after which I/O operations fail with a timeout (see type Error) instead of blocking. The deadline applies to all future I/O, not just the immediately following call to Read or Write.

An idle timeout can be implemented by repeatedly extending the deadline after successful Read or Write calls.

A zero value for t means I/O operations will not time out.

func (*LoopbackConn) SetReadDeadline

func (lc *LoopbackConn) SetReadDeadline(t time.Time) (err error)

SetReadDeadline sets the deadline for future Read calls. A zero value for t means Read will not time out.

func (*LoopbackConn) SetWriteDeadline

func (lc *LoopbackConn) SetWriteDeadline(t time.Time) (err error)

SetWriteDeadline sets the deadline for future Write calls. Even if write times out, it may return n > 0, indicating that some of the data was successfully written. A zero value for t means Write will not time out.

func (*LoopbackConn) Write

func (lc *LoopbackConn) Write(b []byte) (n int, err error)

Write writes data to the connection.

type LoopbackListener

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

LoopbackListener is a listener that creates new loopback connections. It is goroutine safe.

func NewLoopbackListener

func NewLoopbackListener(ctx LogContext) *LoopbackListener

NewLoopbackListener creates a new Loopback listener

func (*LoopbackListener) Accept

func (ll *LoopbackListener) Accept() (ret net.Conn, err error)

Accept waits for and returns the next connection to the listener.

func (*LoopbackListener) Addr

func (ll *LoopbackListener) Addr() (addr net.Addr)

Addr returns the listener's network address.

func (*LoopbackListener) Close

func (ll *LoopbackListener) Close() (err error)

Close closes the listener. Any blocked Accept operations will be unblocked and return errors

func (*LoopbackListener) Dial

func (ll *LoopbackListener) Dial() (net.Conn, error)

LoopbackDial dials the given LoopbackListener and yields an new net.Conn that's a connection to it.

type Markup

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

func FmtMarkup

func FmtMarkup(f string, args ...interface{}) *Markup

func NewMarkup

func NewMarkup(s string) *Markup

func (*Markup) Append

func (m *Markup) Append(s string)

func (Markup) Export

func (m Markup) Export() (ret keybase1.Text)

func (Markup) GetRaw

func (m Markup) GetRaw() string

func (Markup) ToReader

func (m Markup) ToReader() io.Reader

type MemDb

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

func NewMemDb

func NewMemDb(size int) *MemDb

func (*MemDb) Clean

func (m *MemDb) Clean(force bool) error

func (*MemDb) Close

func (m *MemDb) Close() error

func (*MemDb) CompactionStats

func (m *MemDb) CompactionStats() (bool, bool, error)

func (*MemDb) Delete

func (m *MemDb) Delete(id DbKey) error

func (*MemDb) ForceOpen

func (m *MemDb) ForceOpen() error

func (*MemDb) Get

func (m *MemDb) Get(id DbKey) ([]byte, bool, error)

func (*MemDb) KeysWithPrefixes

func (m *MemDb) KeysWithPrefixes(prefixes ...[]byte) (DBKeySet, error)

func (*MemDb) Lookup

func (m *MemDb) Lookup(alias DbKey) ([]byte, bool, error)

func (*MemDb) Nuke

func (m *MemDb) Nuke() (string, error)

func (*MemDb) Open

func (m *MemDb) Open() error

func (*MemDb) OpenTransaction

func (m *MemDb) OpenTransaction() (res LocalDbTransaction, err error)

func (*MemDb) Put

func (m *MemDb) Put(id DbKey, aliases []DbKey, value []byte) error

func (*MemDb) Stats

func (m *MemDb) Stats() string

type MemLRUer

type MemLRUer interface {
	Get(key interface{}) (interface{}, bool)
	Put(key, value interface{}) bool
	OnLogout(mctx MetaContext) error
	OnDbNuke(mctx MetaContext) error
}

type MerkleClashError

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

func (MerkleClashError) Error

func (m MerkleClashError) Error() string

type MerkleClient

type MerkleClient struct {
	Contextified

	// protects whole object
	//
	// Warning: Never grab the latestRootLock while holding this lock, as the
	// opposite happens and so you might introduce deadlocks.
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewMerkleClient

func NewMerkleClient(g *GlobalContext) *MerkleClient

func (*MerkleClient) CanExamineHistoricalRoot

func (mc *MerkleClient) CanExamineHistoricalRoot(m MetaContext, q keybase1.Seqno) bool

func (*MerkleClient) FetchRootFromServer

func (mc *MerkleClient) FetchRootFromServer(m MetaContext, freshness time.Duration) (mr *MerkleRoot, err error)

FetchRootFromServer fetches a root from the server. If the last-fetched root was fetched within freshness ago, then OK to return the last-fetched root. Otherwise refetch. Similarly, if the freshness passed is 0, then always refresh.

func (*MerkleClient) FetchRootFromServerByMinSeqno

func (mc *MerkleClient) FetchRootFromServerByMinSeqno(m MetaContext, lowerBound keybase1.Seqno) (mr *MerkleRoot, err error)

FetchRootFromServerByMinSeqno returns the latest root this client knows about. If the seqno of the latest root is smaller than the lowerBound argument, a new api call is made to the server. However, if the server returns a root at a seqno smaller than lowerBound, no errors are raised.

func (*MerkleClient) FirstExaminableHistoricalRoot

func (mc *MerkleClient) FirstExaminableHistoricalRoot(m MetaContext) *keybase1.Seqno

func (*MerkleClient) FirstMainRootWithHiddenRootHash

func (mc *MerkleClient) FirstMainRootWithHiddenRootHash(m MetaContext) (s keybase1.Seqno, err error)

func (*MerkleClient) LastRoot

func (mc *MerkleClient) LastRoot(m MetaContext) *MerkleRoot

func (*MerkleClient) LastRootToSigJSON

func (mc *MerkleClient) LastRootToSigJSON(m MetaContext) (ret *jsonw.Wrapper, err error)

func (*MerkleClient) LookupLeafAtHashMeta

func (mc *MerkleClient) LookupLeafAtHashMeta(m MetaContext, leafID keybase1.UserOrTeamID, hm keybase1.HashMeta) (leaf *MerkleGenericLeaf, err error)

func (*MerkleClient) LookupLeafAtSeqno

func (mc *MerkleClient) LookupLeafAtSeqno(m MetaContext, leafID keybase1.UserOrTeamID, s keybase1.Seqno) (leaf *MerkleGenericLeaf, root *MerkleRoot, err error)

func (*MerkleClient) LookupLeafAtSeqnoForAudit

func (mc *MerkleClient) LookupLeafAtSeqnoForAudit(m MetaContext, leafID keybase1.UserOrTeamID, s keybase1.Seqno, processHiddenResponseFunc ProcessHiddenRespFunc) (leaf *MerkleGenericLeaf, root *MerkleRoot, hiddenResp *MerkleHiddenResponse, err error)

func (*MerkleClient) LookupRootAtSeqno

func (mc *MerkleClient) LookupRootAtSeqno(m MetaContext, s keybase1.Seqno) (root *MerkleRoot, err error)

func (*MerkleClient) LookupTeam

func (mc *MerkleClient) LookupTeam(m MetaContext, teamID keybase1.TeamID) (leaf *MerkleTeamLeaf, err error)

func (*MerkleClient) LookupTeamWithHidden

func (mc *MerkleClient) LookupTeamWithHidden(m MetaContext, teamID keybase1.TeamID, processHiddenRespFunc ProcessHiddenRespFunc) (leaf *MerkleTeamLeaf, hiddenResp *MerkleHiddenResponse, lastMerkleRoot *MerkleRoot, err error)

func (*MerkleClient) LookupUser

func (mc *MerkleClient) LookupUser(m MetaContext, q HTTPArgs, sigHints *SigHints, opts MerkleOpts) (u *MerkleUserLeaf, err error)

type MerkleClientError

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

func NewClientMerkleFailedCheckpointError

func NewClientMerkleFailedCheckpointError(m string) MerkleClientError

func NewClientMerkleSkipHashMismatchError

func NewClientMerkleSkipHashMismatchError(m string) MerkleClientError

func NewClientMerkleSkipMissingError

func NewClientMerkleSkipMissingError(m string) MerkleClientError

func (MerkleClientError) Error

func (m MerkleClientError) Error() string

func (MerkleClientError) IsNotFound

func (m MerkleClientError) IsNotFound() bool

func (MerkleClientError) IsOldTree

func (m MerkleClientError) IsOldTree() bool

func (MerkleClientError) IsSkipHashMismatch

func (m MerkleClientError) IsSkipHashMismatch() bool

func (MerkleClientError) ToStatus

func (e MerkleClientError) ToStatus() (ret keybase1.Status)

type MerkleClientInterface

type MerkleClientInterface interface {
	CanExamineHistoricalRoot(m MetaContext, q keybase1.Seqno) bool
	FetchRootFromServerByMinSeqno(m MetaContext, lowerBound keybase1.Seqno) (mr *MerkleRoot, err error)
	FetchRootFromServer(m MetaContext, freshness time.Duration) (mr *MerkleRoot, err error)
	FirstExaminableHistoricalRoot(m MetaContext) *keybase1.Seqno
	FirstMainRootWithHiddenRootHash(m MetaContext) (s keybase1.Seqno, err error)
	LastRoot(m MetaContext) *MerkleRoot
	LastRootToSigJSON(m MetaContext) (ret *jsonw.Wrapper, err error)
	LookupLeafAtHashMeta(m MetaContext, leafID keybase1.UserOrTeamID, hm keybase1.HashMeta) (leaf *MerkleGenericLeaf, err error)
	LookupLeafAtSeqno(m MetaContext, leafID keybase1.UserOrTeamID, s keybase1.Seqno) (leaf *MerkleGenericLeaf, root *MerkleRoot, err error)
	LookupLeafAtSeqnoForAudit(m MetaContext, leafID keybase1.UserOrTeamID, s keybase1.Seqno, processHiddenRespFunc ProcessHiddenRespFunc) (leaf *MerkleGenericLeaf, root *MerkleRoot, hiddenResp *MerkleHiddenResponse, err error)
	LookupRootAtSeqno(m MetaContext, s keybase1.Seqno) (root *MerkleRoot, err error)
	LookupTeam(m MetaContext, teamID keybase1.TeamID) (leaf *MerkleTeamLeaf, err error)
	LookupTeamWithHidden(m MetaContext, teamID keybase1.TeamID, processHiddenRespFunc ProcessHiddenRespFunc) (leaf *MerkleTeamLeaf, hiddenResp *MerkleHiddenResponse, lastMerkleRoot *MerkleRoot, err error)
	LookupUser(m MetaContext, q HTTPArgs, sigHints *SigHints, opts MerkleOpts) (u *MerkleUserLeaf, err error)
}

type MerkleGenericLeaf

type MerkleGenericLeaf struct {
	LeafID  keybase1.UserOrTeamID
	Public  *MerkleTriple
	Private *MerkleTriple
	// contains filtered or unexported fields
}

func (MerkleGenericLeaf) PartialClone

func (l MerkleGenericLeaf) PartialClone() MerkleGenericLeaf

type MerkleHiddenResponse

type MerkleHiddenResponse struct {
	RespType            MerkleHiddenResponseType `json:"resp_type"`
	CommittedHiddenTail *sig3.Tail               `json:"committed_hidden_tail"`
	UncommittedSeqno    keybase1.Seqno           `json:"uncommitted_seqno"`
}

func (*MerkleHiddenResponse) GetCommittedSeqno

func (m *MerkleHiddenResponse) GetCommittedSeqno() keybase1.Seqno

func (*MerkleHiddenResponse) GetUncommittedSeqno

func (m *MerkleHiddenResponse) GetUncommittedSeqno() keybase1.Seqno

type MerkleHiddenResponseType

type MerkleHiddenResponseType uint8
const (
	// the server did not include any hidden chain data
	MerkleHiddenResponseTypeNONE MerkleHiddenResponseType = 1
	// the server provided a proof of absence (or inclusion with an empty leaf) for
	// the requested key
	MerkleHiddenResponseTypeABSENCEPROOF MerkleHiddenResponseType = 2
	// the server provided a valid inclusion proof for the returned leaf in the tree
	MerkleHiddenResponseTypeOK MerkleHiddenResponseType = 3

	// All hidden checks should be skipped as the feature flag is off
	MerkleHiddenResponseTypeFLAGOFF MerkleHiddenResponseType = 127
)

type MerkleOpts

type MerkleOpts struct {

	// Used externally
	NoServerPolling bool
	// contains filtered or unexported fields
}

type MerklePathNotFoundError

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

func (MerklePathNotFoundError) Error

func (m MerklePathNotFoundError) Error() string

type MerkleResetChainTail

type MerkleResetChainTail struct {
	Seqno keybase1.Seqno
	Hash  keybase1.SHA512
}

type MerkleResets

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

type MerkleRoot

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

func GetMerkleCheckpoint

func GetMerkleCheckpoint(m MetaContext) *MerkleRoot

func NewMerkleRootFromJSON

func NewMerkleRootFromJSON(jw *jsonw.Wrapper, opts MerkleOpts) (ret *MerkleRoot, err error)

func (*MerkleRoot) BlindMerkleRootHash

func (mr *MerkleRoot) BlindMerkleRootHash() string

func (*MerkleRoot) Ctime

func (mr *MerkleRoot) Ctime() int64

func (MerkleRoot) ExportToAVDL

func (mr MerkleRoot) ExportToAVDL(g *GlobalContext) keybase1.MerkleRootAndTime

func (*MerkleRoot) ExternalURLHash

func (mr *MerkleRoot) ExternalURLHash() string

func (*MerkleRoot) Fetched

func (mr *MerkleRoot) Fetched() time.Time

func (*MerkleRoot) HasSkips

func (mr *MerkleRoot) HasSkips() bool

func (MerkleRoot) HashMeta

func (mr MerkleRoot) HashMeta() keybase1.HashMeta

func (MerkleRoot) IsNil

func (mr MerkleRoot) IsNil() bool

func (*MerkleRoot) KBFSPrivate

func (mr *MerkleRoot) KBFSPrivate() (keybase1.KBFSRootHash, *keybase1.Seqno)

func (*MerkleRoot) KBFSPrivateTeam

func (mr *MerkleRoot) KBFSPrivateTeam() (keybase1.KBFSRootHash, *keybase1.Seqno)

func (*MerkleRoot) KBFSPublic

func (mr *MerkleRoot) KBFSPublic() (keybase1.KBFSRootHash, *keybase1.Seqno)

func (*MerkleRoot) LegacyUIDRootHash

func (mr *MerkleRoot) LegacyUIDRootHash() NodeHash

func (*MerkleRoot) ProofServicesHash

func (mr *MerkleRoot) ProofServicesHash() string

func (*MerkleRoot) PvlHash

func (mr *MerkleRoot) PvlHash() string

func (*MerkleRoot) RootHash

func (mr *MerkleRoot) RootHash() NodeHash

func (*MerkleRoot) Seqno

func (mr *MerkleRoot) Seqno() *keybase1.Seqno

func (MerkleRoot) ShallowCopy

func (mr MerkleRoot) ShallowCopy() *MerkleRoot

func (MerkleRoot) ShortHash

func (mr MerkleRoot) ShortHash() NodeHashShort

func (*MerkleRoot) SkipToSeqno

func (mr *MerkleRoot) SkipToSeqno(s keybase1.Seqno) NodeHash

func (*MerkleRoot) ToInfo

func (mr *MerkleRoot) ToInfo() chat1.MerkleRoot

func (*MerkleRoot) ToJSON

func (mr *MerkleRoot) ToJSON() (jw *jsonw.Wrapper)

func (*MerkleRoot) ToMerkleRootV2

func (mr *MerkleRoot) ToMerkleRootV2() keybase1.MerkleRootV2

func (*MerkleRoot) ToSigJSON

func (mr *MerkleRoot) ToSigJSON() (ret *jsonw.Wrapper)

type MerkleRootPayload

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

func NewMerkleRootPayloadFromJSONString

func NewMerkleRootPayloadFromJSONString(s string) (ret MerkleRootPayload, err error)

type MerkleRootPayloadUnpacked

type MerkleRootPayloadUnpacked struct {
	Body struct {
		Kbfs struct {
			Private struct {
				Root    keybase1.KBFSRootHash `json:"root"`
				Version *keybase1.Seqno       `json:"version"`
			} `json:"private"`
			Public struct {
				Root    keybase1.KBFSRootHash `json:"root"`
				Version *keybase1.Seqno       `json:"version"`
			} `json:"public"`
			PrivateTeam struct {
				Root    keybase1.KBFSRootHash `json:"root"`
				Version *keybase1.Seqno       `json:"version"`
			} `json:"privateteam"`
		} `json:"kbfs"`
		LegacyUIDRoot       NodeHashShort  `json:"legacy_uid_root"`
		Prev                NodeHashLong   `json:"prev"`
		Root                NodeHashLong   `json:"root"`
		Seqno               keybase1.Seqno `json:"seqno"`
		Skips               SkipTable      `json:"skips"`
		Txid                string         `json:"txid"`
		Type                string         `json:"type"`
		Version             int            `json:"version"`
		PvlHash             string         `json:"pvl_hash"`
		ProofServicesHash   string         `json:"proof_services_hash"`
		ExternalURLHash     string         `json:"external_urls_hash"`
		BlindMerkleRootHash string         `json:"blind_merkle_root_hash"`
	} `json:"body"`
	Ctime int64  `json:"ctime"`
	Tag   string `json:"tag"`
}

type MerkleStore

type MerkleStore interface {
	GetLatestEntry(m MetaContext) (keybase1.MerkleStoreEntry, error)
	GetLatestEntryWithKnown(MetaContext, *keybase1.MerkleStoreKitHash) (*keybase1.MerkleStoreEntry, error)
}

Generic store for data that is hashed into the merkle root. Used by pvl and parameterized proofs.

type MerkleTeamLeaf

type MerkleTeamLeaf struct {
	TeamID  keybase1.TeamID
	Public  *MerkleTriple
	Private *MerkleTriple
}

func (MerkleTeamLeaf) MerkleGenericLeaf

func (l MerkleTeamLeaf) MerkleGenericLeaf() *MerkleGenericLeaf

type MerkleTriple

type MerkleTriple struct {
	Seqno  keybase1.Seqno     `json:"seqno"`
	LinkID LinkID             `json:"id"`
	SigID  keybase1.SigIDBase `json:"sigid,omitempty"`
}

func GetMerkleTriple

func GetMerkleTriple(jw *jsonw.Wrapper) (ret *MerkleTriple, err error)

func (MerkleTriple) Eq

func (mt MerkleTriple) Eq(mt2 MerkleTriple) bool

func (MerkleTriple) Less

func (mt MerkleTriple) Less(mt2 MerkleTriple) bool

type MerkleUserLeaf

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

func (*MerkleUserLeaf) MatchUser

func (mul *MerkleUserLeaf) MatchUser(u *User, uid keybase1.UID, nun NormalizedUsername) (err error)

func (MerkleUserLeaf) MerkleGenericLeaf

func (mul MerkleUserLeaf) MerkleGenericLeaf() *MerkleGenericLeaf

func (MerkleUserLeaf) Public

func (mul MerkleUserLeaf) Public() *MerkleTriple

type MetaContext

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

func NewMetaContext

func NewMetaContext(ctx context.Context, g *GlobalContext) MetaContext

func NewMetaContextBackground

func NewMetaContextBackground(g *GlobalContext) MetaContext

func NewMetaContextForTest

func NewMetaContextForTest(tc TestContext) MetaContext

func NewMetaContextForTestWithLogUI

func NewMetaContextForTestWithLogUI(tc TestContext) MetaContext

func NewMetaContextTODO

func NewMetaContextTODO(g *GlobalContext) MetaContext

func (MetaContext) ActiveDevice

func (m MetaContext) ActiveDevice() *ActiveDevice

func (MetaContext) BackgroundWithCancel

func (m MetaContext) BackgroundWithCancel() (MetaContext, func())

func (MetaContext) BackgroundWithLogTags

func (m MetaContext) BackgroundWithLogTags() MetaContext

func (MetaContext) CommitProvisionalLogin

func (m MetaContext) CommitProvisionalLogin() MetaContext

func (MetaContext) Ctx

func (m MetaContext) Ctx() context.Context

func (MetaContext) CurrentUID

func (m MetaContext) CurrentUID() keybase1.UID

func (MetaContext) CurrentUserVersion

func (m MetaContext) CurrentUserVersion() keybase1.UserVersion

func (MetaContext) CurrentUsername

func (m MetaContext) CurrentUsername() NormalizedUsername

func (MetaContext) Debug

func (m MetaContext) Debug(f string, args ...interface{})

func (MetaContext) DebugStack

func (m MetaContext) DebugStack()

func (MetaContext) Dump

func (m MetaContext) Dump()

func (MetaContext) EnsureCtx

func (m MetaContext) EnsureCtx() MetaContext

func (MetaContext) Error

func (m MetaContext) Error(f string, args ...interface{})

func (MetaContext) G

func (m MetaContext) G() *GlobalContext

func (MetaContext) HasAnySession

func (m MetaContext) HasAnySession() (ret bool)

func (MetaContext) Info

func (m MetaContext) Info(f string, args ...interface{})

func (MetaContext) Keyring

func (m MetaContext) Keyring() (ret *SKBKeyringFile, err error)

func (MetaContext) LoginContext

func (m MetaContext) LoginContext() LoginContext

func (MetaContext) LogoutAndDeprovisionIfRevoked

func (m MetaContext) LogoutAndDeprovisionIfRevoked() (err error)

LogoutAndDeprovisionIfRevoked loads the user and checks if the current device keys have been revoked. If so, it calls Logout and then runs the ClearSecretsOnDeprovision

func (MetaContext) LogoutKeepSecrets

func (mctx MetaContext) LogoutKeepSecrets() (err error)

func (MetaContext) LogoutKillSecrets

func (mctx MetaContext) LogoutKillSecrets() (err error)

func (MetaContext) LogoutSelfCheck

func (mctx MetaContext) LogoutSelfCheck() error

LogoutSelfCheck checks with the API server to see if this uid+device pair should logout.

func (MetaContext) LogoutUsernameWithOptions

func (mctx MetaContext) LogoutUsernameWithOptions(username NormalizedUsername, options LogoutOptions) (err error)

func (MetaContext) LogoutWithOptions

func (mctx MetaContext) LogoutWithOptions(options LogoutOptions) (err error)

func (MetaContext) NIST

func (m MetaContext) NIST() (*NIST, error)

func (MetaContext) PassphraseStream

func (m MetaContext) PassphraseStream() *PassphraseStream

func (MetaContext) PassphraseStreamAndTriplesec

func (m MetaContext) PassphraseStreamAndTriplesec() (*PassphraseStream, Triplesec)

func (MetaContext) PerfDebug

func (m MetaContext) PerfDebug(f string, args ...interface{})

func (MetaContext) PerfTrace

func (m MetaContext) PerfTrace(msg string, err *error) func()

func (MetaContext) ProvisionalSessionArgs

func (m MetaContext) ProvisionalSessionArgs() (token string, csrf string)

func (MetaContext) SecretKeyPromptArg

func (m MetaContext) SecretKeyPromptArg(ska SecretKeyArg, reason string) SecretKeyPromptArg

func (MetaContext) SetActiveDevice

func (m MetaContext) SetActiveDevice(uv keybase1.UserVersion, deviceID keybase1.DeviceID,
	sigKey, encKey GenericKey, deviceName string, keychainMode KeychainMode) error

SetActiveDevice sets the active device to have the UserVersion, deviceID, sigKey, encKey and deviceName as specified, and does so while grabbing the global switchUser lock, since it should be sycnhronized with attempts to switch the global logged in user. It does not, however, change the `current_user` in the config file, or edit the global config file in any way.

func (MetaContext) SetEncryptionKey

func (m MetaContext) SetEncryptionKey(uv keybase1.UserVersion, deviceID keybase1.DeviceID, encKey GenericKey) error

func (MetaContext) SetSigningKey

func (m MetaContext) SetSigningKey(uv keybase1.UserVersion, deviceID keybase1.DeviceID, sigKey GenericKey, deviceName string) error

func (MetaContext) SwitchUser

func (m MetaContext) SwitchUser(n NormalizedUsername) error

func (MetaContext) SwitchUserDeprovisionNukeConfig

func (m MetaContext) SwitchUserDeprovisionNukeConfig(username NormalizedUsername) error

func (MetaContext) SwitchUserLoggedOut

func (m MetaContext) SwitchUserLoggedOut() (err error)

SwitchUserLoggedOut clears the active device and the current_user stanza of the config file, all while holding the switchUserMu

func (MetaContext) SwitchUserNewConfig

func (m MetaContext) SwitchUserNewConfig(u keybase1.UID, n NormalizedUsername, salt []byte, d keybase1.DeviceID) error

SwitchUserNewConfig switches the global active "user" as far as the global config file is concerned. It switches the user to a new user, and therefore you should specify the username, salt, and device ID for this user on this device. It will take out the global `switchUserMu` and also clear out the global ActiveDevice at the same time. We follow the same pattern here and elsewhere: atomically mutate the `current_user` of the config file as we set the global ActiveDevice.

func (MetaContext) SwitchUserNewConfigActiveDevice

func (m MetaContext) SwitchUserNewConfigActiveDevice(uv keybase1.UserVersion, n NormalizedUsername, salt []byte, d keybase1.DeviceID, sigKey GenericKey, encKey GenericKey, deviceName string, keychainMode KeychainMode) error

SwitchUserNewConfigActiveDevice creates a new config file stanza and an active device for the given user, all while holding the switchUserMu lock.

func (MetaContext) SwitchUserNukeConfig

func (m MetaContext) SwitchUserNukeConfig(n NormalizedUsername) error

SwitchUserNukeConfig removes the given username from the config file, and then switches to not having a current user (by clearing the ActiveDevice, etc). It does this in a critical section, holding switchUserMu.

func (MetaContext) SwitchUserToActiveDevice

func (m MetaContext) SwitchUserToActiveDevice(n NormalizedUsername, ad *ActiveDevice) (err error)

func (MetaContext) SwitchUserToActiveOneshotDevice

func (m MetaContext) SwitchUserToActiveOneshotDevice(uv keybase1.UserVersion, nun NormalizedUsername, d *DeviceWithKeys) (err error)

SetActiveOneshotDevice acquires the switchUserMu mutex, setting the active device to one that corresponds to the given UID and DeviceWithKeys, and also sets the config file to a temporary in-memory config (not writing to disk) to satisfy local requests for g.Env.*

func (MetaContext) SyncSecrets

func (m MetaContext) SyncSecrets() (ss *SecretSyncer, err error)

func (MetaContext) SyncSecretsForUID

func (m MetaContext) SyncSecretsForUID(u keybase1.UID) (ss *SecretSyncer, err error)

func (MetaContext) TimeBuckets

func (m MetaContext) TimeBuckets() (MetaContext, *profiling.TimeBuckets)

func (MetaContext) TimeTracer

func (m MetaContext) TimeTracer(label string, enabled bool) profiling.TimeTracer

func (MetaContext) Trace

func (m MetaContext) Trace(msg string, err *error) func()

func (MetaContext) TriplesecAndGeneration

func (m MetaContext) TriplesecAndGeneration() (ret Triplesec, ppgen PassphraseGeneration)

func (MetaContext) UIs

func (m MetaContext) UIs() UIs

func (MetaContext) UpdateContextToLoggerContext

func (m MetaContext) UpdateContextToLoggerContext(c context.Context) logger.ContextInterface

func (MetaContext) VLogf

func (m MetaContext) VLogf(lev VDebugLevel, msg string, args ...interface{})

func (MetaContext) VTrace

func (m MetaContext) VTrace(lev VDebugLevel, msg string, err *error) func()

func (MetaContext) Warning

func (m MetaContext) Warning(f string, args ...interface{})

func (MetaContext) WithAPITokener

func (m MetaContext) WithAPITokener(t APITokener) MetaContext

func (MetaContext) WithActiveDevice

func (m MetaContext) WithActiveDevice(a *ActiveDevice) MetaContext

func (MetaContext) WithContext

func (m MetaContext) WithContext(ctx context.Context) MetaContext

func (MetaContext) WithContextCancel

func (m MetaContext) WithContextCancel() (MetaContext, func())

func (MetaContext) WithCtx

func (m MetaContext) WithCtx(c context.Context) MetaContext

func (MetaContext) WithDelegatedIdentifyUI

func (m MetaContext) WithDelegatedIdentifyUI(u IdentifyUI) MetaContext

func (MetaContext) WithGPGUI

func (m MetaContext) WithGPGUI(u GPGUI) MetaContext

func (MetaContext) WithGlobalActiveDevice

func (m MetaContext) WithGlobalActiveDevice() MetaContext

func (MetaContext) WithIdentifyUI

func (m MetaContext) WithIdentifyUI(u IdentifyUI) MetaContext

func (MetaContext) WithLogTag

func (m MetaContext) WithLogTag(k string) MetaContext

func (MetaContext) WithLogTags

func (m MetaContext) WithLogTags(tags map[string]string) MetaContext

func (MetaContext) WithLogUI

func (m MetaContext) WithLogUI(u LogUI) MetaContext

func (MetaContext) WithLoginContext

func (m MetaContext) WithLoginContext(l LoginContext) MetaContext

func (MetaContext) WithNewProvisionalLoginContext

func (m MetaContext) WithNewProvisionalLoginContext() MetaContext

func (MetaContext) WithNewProvisionalLoginContextForUser

func (m MetaContext) WithNewProvisionalLoginContextForUser(u *User) MetaContext

func (MetaContext) WithNewProvisionalLoginContextForUserVersionAndUsername

func (m MetaContext) WithNewProvisionalLoginContextForUserVersionAndUsername(uv keybase1.UserVersion, un NormalizedUsername) MetaContext

func (MetaContext) WithPgpUI

func (m MetaContext) WithPgpUI(u PgpUI) MetaContext

func (MetaContext) WithProvisioningKeyActiveDevice

func (m MetaContext) WithProvisioningKeyActiveDevice(d *DeviceWithKeys, uv keybase1.UserVersion) MetaContext

func (MetaContext) WithSaltpackUI

func (m MetaContext) WithSaltpackUI(s SaltpackUI) MetaContext

func (MetaContext) WithSecretUI

func (m MetaContext) WithSecretUI(u SecretUI) MetaContext

func (MetaContext) WithTimeBuckets

func (m MetaContext) WithTimeBuckets() (MetaContext, *profiling.TimeBuckets)

func (MetaContext) WithTimeout

func (m MetaContext) WithTimeout(timeout time.Duration) (MetaContext, func())

func (MetaContext) WithUIs

func (m MetaContext) WithUIs(u UIs) MetaContext

type MetaContextified

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

func NewMetaContextified

func NewMetaContextified(m MetaContext) MetaContextified

func (MetaContextified) G

func (MetaContextified) M

type MiniChatPayment

type MiniChatPayment struct {
	Username NormalizedUsername
	Amount   string
	Currency string
}

MiniChatPayment is the argument for sending an in-chat payment.

type MiniChatPaymentResult

type MiniChatPaymentResult struct {
	Username  NormalizedUsername
	PaymentID stellar1.PaymentID
	Error     error
}

MiniChatPaymentResult is the result of sending an in-chat payment to one username.

type MiniChatPaymentSpec

type MiniChatPaymentSpec struct {
	Username      NormalizedUsername
	Error         error
	XLMAmount     string
	DisplayAmount string // optional
}

MiniChatPaymentSpec describes the amounts involved in a MiniChatPayment.

type MiniChatPaymentSummary

type MiniChatPaymentSummary struct {
	Specs        []MiniChatPaymentSpec
	XLMTotal     string
	DisplayTotal string
}

MiniChatPaymentSummary contains all the recipients and the amounts they will receive plus a total in XLM and in the sender's preferred currency.

type MissingDelegationTypeError

type MissingDelegationTypeError struct{}

func (MissingDelegationTypeError) Error

type MobileAppState

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

MobileAppState tracks the state of foreground/background status of the app in which the service is running in.

func NewMobileAppState

func NewMobileAppState(g *GlobalContext) *MobileAppState

func (*MobileAppState) NextUpdate

func (a *MobileAppState) NextUpdate(lastState *keybase1.MobileAppState) chan keybase1.MobileAppState

NextUpdate returns a channel that triggers when the app state changes

func (*MobileAppState) State

State returns the current app state

func (*MobileAppState) StateAndMtime

func (a *MobileAppState) StateAndMtime() (keybase1.MobileAppState, *time.Time)

func (*MobileAppState) Update

func (a *MobileAppState) Update(state keybase1.MobileAppState)

Update updates the current app state, and notifies any waiting calls from NextUpdate

func (*MobileAppState) UpdateWithCheck

func (a *MobileAppState) UpdateWithCheck(state keybase1.MobileAppState,
	check func(keybase1.MobileAppState) bool)

type MobileNetState

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

MobileNetState tracks the state of the network status of the app in which the service is running in.

func NewMobileNetState

func NewMobileNetState(g *GlobalContext) *MobileNetState

func (*MobileNetState) NextUpdate

func (a *MobileNetState) NextUpdate(lastState *keybase1.MobileNetworkState) chan keybase1.MobileNetworkState

NextUpdate returns a channel that triggers when the network state changes

func (*MobileNetState) State

State returns the current network state

func (*MobileNetState) Update

func (a *MobileNetState) Update(state keybase1.MobileNetworkState)

Update updates the current network state, and notifies any waiting calls from NextUpdate

type NIST

type NIST struct {
	Contextified
	sync.RWMutex
	// contains filtered or unexported fields
}

func (*NIST) DidFail

func (n *NIST) DidFail() bool

func (*NIST) DidSucceed

func (n *NIST) DidSucceed() bool

func (*NIST) IsExpired

func (n *NIST) IsExpired() bool

func (*NIST) IsStillValid

func (n *NIST) IsStillValid() (bool, time.Duration)

func (*NIST) MarkFailure

func (n *NIST) MarkFailure()

func (*NIST) MarkSuccess

func (n *NIST) MarkSuccess()

func (*NIST) Token

func (n *NIST) Token() *NISTToken

type NISTFactory

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

func NewNISTFactory

func NewNISTFactory(g *GlobalContext, uid keybase1.UID, deviceID keybase1.DeviceID, key GenericKey) *NISTFactory

func (*NISTFactory) GenerateWebAuthToken

func (f *NISTFactory) GenerateWebAuthToken(ctx context.Context) (ret *NIST, err error)

func (*NISTFactory) NIST

func (f *NISTFactory) NIST(ctx context.Context) (ret *NIST, err error)

func (*NISTFactory) UID

func (f *NISTFactory) UID() keybase1.UID

type NISTToken

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

func (NISTToken) Bytes

func (n NISTToken) Bytes() []byte

func (NISTToken) Hash

func (n NISTToken) Hash() []byte

func (NISTToken) ShortHash

func (n NISTToken) ShortHash() []byte

func (NISTToken) String

func (n NISTToken) String() string

type NaclDHKeyPair

type NaclDHKeyPair struct {
	Public  NaclDHKeyPublic
	Private *NaclDHKeyPrivate
}

func GenerateNaclDHKeyPair

func GenerateNaclDHKeyPair() (NaclDHKeyPair, error)

func ImportDHKeypairFromKID

func ImportDHKeypairFromKID(k keybase1.KID) (*NaclDHKeyPair, error)

func ImportNaclDHKeyPairFromBytes

func ImportNaclDHKeyPairFromBytes(pub []byte, priv []byte) (ret NaclDHKeyPair, err error)

func ImportNaclDHKeyPairFromHex

func ImportNaclDHKeyPairFromHex(s string) (ret NaclDHKeyPair, err error)

func MakeNaclDHKeyPairFromSecret

func MakeNaclDHKeyPairFromSecret(secret [NaclDHKeySecretSize]byte) (NaclDHKeyPair, error)

MakeNaclDHKeyPairFromSecret makes a DH key pair given a secret. Of course, the security of depends entirely on the randomness of the bytes in the secret.

func MakeNaclDHKeyPairFromSecretBytes

func MakeNaclDHKeyPairFromSecretBytes(secret []byte) (NaclDHKeyPair, error)

func (NaclDHKeyPair) CanDecrypt

func (k NaclDHKeyPair) CanDecrypt() bool

CanDecrypt returns true if there's a private key available

func (NaclDHKeyPair) CanEncrypt

func (k NaclDHKeyPair) CanEncrypt() bool

CanEncrypt always returns true for an encryption key pair.

func (NaclDHKeyPair) CanSign

func (k NaclDHKeyPair) CanSign() bool

func (NaclDHKeyPair) CheckSecretKey

func (k NaclDHKeyPair) CheckSecretKey() error

func (NaclDHKeyPair) Clone

func (k NaclDHKeyPair) Clone() (ret NaclDHKeyPair)

func (NaclDHKeyPair) Decrypt

func (k NaclDHKeyPair) Decrypt(nei *NaclEncryptionInfo) (plaintext []byte, sender keybase1.KID, err error)

Decrypt a NaclEncryptionInfo packet, and on success return the plaintext and the kbcrypto.KID of the sender (which might be an ephemeral key).

func (NaclDHKeyPair) DecryptFromString

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

DecryptFromString decrypts the output of EncryptToString above, and returns the kbcrypto.KID of the other end.

func (NaclDHKeyPair) Encode

func (k NaclDHKeyPair) Encode() (string, error)

func (NaclDHKeyPair) Encrypt

func (k NaclDHKeyPair) Encrypt(msg []byte, sender *NaclDHKeyPair) (*NaclEncryptionInfo, error)

Encrypt a message to the key `k` from the given `sender`. If sender is nil, an ephemeral keypair will be invented

func (NaclDHKeyPair) EncryptToString

func (k NaclDHKeyPair) EncryptToString(plaintext []byte, sender GenericKey) (string, error)

EncryptToString encrypts the plaintext using DiffieHelman; the this object is the receiver, and the passed sender is optional. If not provided, we'll make up an ephemeral key.

func (NaclDHKeyPair) ExportPublicAndPrivate

func (k NaclDHKeyPair) ExportPublicAndPrivate() (RawPublicKey, RawPrivateKey, error)

func (NaclDHKeyPair) GetAlgoType

func (k NaclDHKeyPair) GetAlgoType() kbcrypto.AlgoType

func (NaclDHKeyPair) GetBinaryKID

func (k NaclDHKeyPair) GetBinaryKID() (ret keybase1.BinaryKID)

func (NaclDHKeyPair) GetFingerprintP

func (k NaclDHKeyPair) GetFingerprintP() *PGPFingerprint

func (NaclDHKeyPair) GetKID

func (k NaclDHKeyPair) GetKID() keybase1.KID

func (NaclDHKeyPair) HasSecretKey

func (k NaclDHKeyPair) HasSecretKey() bool

func (NaclDHKeyPair) IsNil

func (k NaclDHKeyPair) IsNil() bool

func (NaclDHKeyPair) SecretSymmetricKey

func (k NaclDHKeyPair) SecretSymmetricKey(reason EncryptionReason) (NaclSecretBoxKey, error)

func (NaclDHKeyPair) SignToString

func (k NaclDHKeyPair) SignToString(msg []byte) (sig string, id keybase1.SigIDBase, err error)

func (NaclDHKeyPair) ToShortIDString

func (k NaclDHKeyPair) ToShortIDString() string

func (NaclDHKeyPair) VerboseDescription

func (k NaclDHKeyPair) VerboseDescription() string

func (NaclDHKeyPair) VerifyString

func (k NaclDHKeyPair) VerifyString(ctx VerifyContext, sig string, msg []byte) (id keybase1.SigIDBase, err error)

func (NaclDHKeyPair) VerifyStringAndExtract

func (k NaclDHKeyPair) VerifyStringAndExtract(ctx VerifyContext, sig string) (msg []byte, id keybase1.SigIDBase, err error)

type NaclDHKeyPrivate

type NaclDHKeyPrivate [NaclDHKeysize]byte

type NaclDHKeyPublic

type NaclDHKeyPublic [NaclDHKeysize]byte

func (NaclDHKeyPublic) GetBinaryKID

func (k NaclDHKeyPublic) GetBinaryKID() keybase1.BinaryKID

func (NaclDHKeyPublic) GetKID

func (k NaclDHKeyPublic) GetKID() keybase1.KID

type NaclEncryptionInfo

type NaclEncryptionInfo struct {
	Ciphertext     []byte            `codec:"ciphertext"`
	EncryptionType kbcrypto.AlgoType `codec:"enc_type"`
	Nonce          []byte            `codec:"nonce"`
	Receiver       []byte            `codec:"receiver_key"`
	Sender         []byte            `codec:"sender_key"`
}

func DecodeArmoredNaclEncryptionInfoPacket

func DecodeArmoredNaclEncryptionInfoPacket(s string) (NaclEncryptionInfo, error)

func DecodeNaclEncryptionInfoPacket

func DecodeNaclEncryptionInfoPacket(data []byte) (NaclEncryptionInfo, error)

func (*NaclEncryptionInfo) GetTagAndVersion

func (k *NaclEncryptionInfo) GetTagAndVersion() (kbcrypto.PacketTag, kbcrypto.PacketVersion)

type NaclGenerator

type NaclGenerator func() (NaclKeyPair, error)

type NaclKeyGen

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

func NewNaclKeyGen

func NewNaclKeyGen(arg NaclKeyGenArg) *NaclKeyGen

func (*NaclKeyGen) Generate

func (g *NaclKeyGen) Generate() (err error)

func (*NaclKeyGen) GetKeyPair

func (g *NaclKeyGen) GetKeyPair() NaclKeyPair

func (*NaclKeyGen) Push

func (g *NaclKeyGen) Push(m MetaContext, aggregated bool) (d Delegator, err error)

func (*NaclKeyGen) SaveLKS

func (g *NaclKeyGen) SaveLKS(m MetaContext, lks *LKSec) error

func (*NaclKeyGen) UpdateArg

func (g *NaclKeyGen) UpdateArg(signer GenericKey, eldestKID keybase1.KID, delegationType DelegationType, user *User)

type NaclKeyGenArg

type NaclKeyGenArg struct {
	Signer         GenericKey // who is going to sign us into the Chain
	ExpiresIn      int
	Generator      NaclGenerator
	Me             *User
	DelegationType DelegationType
	ExpireIn       int          // how long it lasts
	EldestKeyID    keybase1.KID // the eldest KID for this epoch
	Device         *Device
	RevSig         string // optional reverse sig.  set to nil for autogenerate.
}

type NaclKeyPair

type NaclKeyPair interface {
	GenericKey
}

type NaclSecretBoxKey

type NaclSecretBoxKey [NaclSecretBoxKeySize]byte

func DeriveSymmetricKey

func DeriveSymmetricKey(inKey NaclSecretBoxKey, reason EncryptionReason) (NaclSecretBoxKey, error)

Derive a symmetric key. Uses HMAC(key=reason, data=key) Note the message and data are swapped as inputs to HMAC because that is less likely to be accidentally used for another purpose such as authentication.

func (NaclSecretBoxKey) IsZero

func (k NaclSecretBoxKey) IsZero() bool

type NaclSigningKeyPair

type NaclSigningKeyPair struct {
	Public  kbcrypto.NaclSigningKeyPublic
	Private *kbcrypto.NaclSigningKeyPrivate
}

func GenerateNaclSigningKeyPair

func GenerateNaclSigningKeyPair() (NaclSigningKeyPair, error)

func GenerateNaclSigningKeyPairFromSeed

func GenerateNaclSigningKeyPairFromSeed(seed [ed25519.SeedSize]byte) (NaclSigningKeyPair, error)

func ImportNaclSigningKeyPairFromBytes

func ImportNaclSigningKeyPairFromBytes(pub []byte, priv []byte) (ret NaclSigningKeyPair, err error)

func ImportNaclSigningKeyPairFromHex

func ImportNaclSigningKeyPairFromHex(s string) (ret NaclSigningKeyPair, err error)

func MakeNaclSigningKeyPairFromSecret

func MakeNaclSigningKeyPairFromSecret(secret [NaclSigningKeySecretSize]byte) (NaclSigningKeyPair, error)

MakeNaclSigningKeyPairFromSecret makes a signing key pair given a secret. Of course, the security of depends entirely on the randomness of the bytes in the secret.

func MakeNaclSigningKeyPairFromSecretBytes

func MakeNaclSigningKeyPairFromSecretBytes(secret []byte) (NaclSigningKeyPair, error)

func MakeNaclSigningKeyPairFromStellarAccountID

func MakeNaclSigningKeyPairFromStellarAccountID(accountID stellar1.AccountID) (res NaclSigningKeyPair, err error)

func MakeNaclSigningKeyPairFromStellarSecretKey

func MakeNaclSigningKeyPairFromStellarSecretKey(sec stellar1.SecretKey) (res NaclSigningKeyPair, err error)

func (NaclSigningKeyPair) CanDecrypt

func (k NaclSigningKeyPair) CanDecrypt() bool

CanDecrypt always returns false for a signing key pair.

func (NaclSigningKeyPair) CanEncrypt

func (k NaclSigningKeyPair) CanEncrypt() bool

CanEncrypt always returns false for a signing key pair.

func (NaclSigningKeyPair) CanSign

func (k NaclSigningKeyPair) CanSign() bool

func (NaclSigningKeyPair) CheckSecretKey

func (k NaclSigningKeyPair) CheckSecretKey() error

func (NaclSigningKeyPair) DecryptFromString

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

DecryptFromString fails for this type of key.

func (NaclSigningKeyPair) Encode

func (k NaclSigningKeyPair) Encode() (string, error)

func (NaclSigningKeyPair) EncryptToString

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

EncryptToString fails for this type of key.

func (NaclSigningKeyPair) ExportPublicAndPrivate

func (k NaclSigningKeyPair) ExportPublicAndPrivate() (RawPublicKey, RawPrivateKey, error)

func (NaclSigningKeyPair) GetAlgoType

func (k NaclSigningKeyPair) GetAlgoType() kbcrypto.AlgoType

func (NaclSigningKeyPair) GetBinaryKID

func (k NaclSigningKeyPair) GetBinaryKID() (ret keybase1.BinaryKID)

func (NaclSigningKeyPair) GetFingerprintP

func (k NaclSigningKeyPair) GetFingerprintP() *PGPFingerprint

func (NaclSigningKeyPair) GetKID

func (k NaclSigningKeyPair) GetKID() (ret keybase1.KID)

func (NaclSigningKeyPair) HasSecretKey

func (k NaclSigningKeyPair) HasSecretKey() bool

func (NaclSigningKeyPair) IsNil

func (k NaclSigningKeyPair) IsNil() bool

func (NaclSigningKeyPair) SecretSymmetricKey

func (k NaclSigningKeyPair) SecretSymmetricKey(reason EncryptionReason) (NaclSecretBoxKey, error)

func (NaclSigningKeyPair) Sign

func (NaclSigningKeyPair) SignToString

func (k NaclSigningKeyPair) SignToString(msg []byte) (string, keybase1.SigIDBase, error)

func (NaclSigningKeyPair) SignV2

func (NaclSigningKeyPair) ToShortIDString

func (k NaclSigningKeyPair) ToShortIDString() string

func (NaclSigningKeyPair) VerboseDescription

func (k NaclSigningKeyPair) VerboseDescription() string

func (NaclSigningKeyPair) VerifyString

func (k NaclSigningKeyPair) VerifyString(ctx VerifyContext, sig string, msg []byte) (id keybase1.SigIDBase, err error)

func (NaclSigningKeyPair) VerifyStringAndExtract

func (k NaclSigningKeyPair) VerifyStringAndExtract(ctx VerifyContext, sig string) (msg []byte, id keybase1.SigIDBase, err error)

type NamedDbNukeHook

type NamedDbNukeHook struct {
	DbNukeHook
	// contains filtered or unexported fields
}

type NamedLock

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

func (*NamedLock) Release

func (l *NamedLock) Release(ctx context.Context)

type NamedLogoutHook

type NamedLogoutHook struct {
	LogoutHook
	// contains filtered or unexported fields
}

type NeedInputError

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

func (NeedInputError) Error

func (e NeedInputError) Error() string

type NeedOtherRekeyError

type NeedOtherRekeyError struct {
	// Canonical tlf name
	Tlf string
	Msg string
}

NeedOtherRekeyError indicates that the folder in question needs to be rekeyed for the local device, and can only done so by one of the other users.

func (NeedOtherRekeyError) Error

func (e NeedOtherRekeyError) Error() string

func (NeedOtherRekeyError) ToStatus

func (e NeedOtherRekeyError) ToStatus() keybase1.Status

type NeedSelfRekeyError

type NeedSelfRekeyError struct {
	// Canonical tlf name
	Tlf string
	Msg string
}

NeedSelfRekeyError indicates that the folder in question needs to be rekeyed for the local device, and can be done so by one of the other user's devices.

func (NeedSelfRekeyError) Error

func (e NeedSelfRekeyError) Error() string

func (NeedSelfRekeyError) ToStatus

func (e NeedSelfRekeyError) ToStatus() keybase1.Status

type NegBoolFunc

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

type NetContext

type NetContext interface {
	GetNetContext() context.Context
}

type NetworkStatsJSON

type NetworkStatsJSON struct {
	Local  []keybase1.InstrumentationStat `json:"local"`
	Remote []keybase1.InstrumentationStat `json:"remote"`
}

type NoActiveDeviceError

type NoActiveDeviceError struct{}

func (NoActiveDeviceError) Error

func (e NoActiveDeviceError) Error() string

type NoConfigFileError

type NoConfigFileError struct{}

func (NoConfigFileError) Error

func (n NoConfigFileError) Error() string

type NoConfigWriterError

type NoConfigWriterError struct{}

func (NoConfigWriterError) Error

func (e NoConfigWriterError) Error() string

type NoDecryptionKeyError

type NoDecryptionKeyError struct {
	Msg string
}

func (NoDecryptionKeyError) Error

func (e NoDecryptionKeyError) Error() string

func (NoDecryptionKeyError) ToStatus

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

type NoDeviceError

type NoDeviceError struct {
	Reason string
}

func NewNoDeviceError

func NewNoDeviceError(s string) NoDeviceError

func (NoDeviceError) Error

func (e NoDeviceError) Error() string

func (NoDeviceError) ToStatus

func (e NoDeviceError) ToStatus() keybase1.Status

type NoKeyError

type NoKeyError struct {
	Msg string
}

func (NoKeyError) Error

func (u NoKeyError) Error() string

func (NoKeyError) ToStatus

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

type NoKeyringsError

type NoKeyringsError struct{}

func (NoKeyringsError) Error

func (k NoKeyringsError) Error() string

type NoMatchingGPGKeysError

type NoMatchingGPGKeysError struct {
	Fingerprints    []string
	HasActiveDevice bool // true if the user has an active device that they chose not to use
}

func (NoMatchingGPGKeysError) Error

func (e NoMatchingGPGKeysError) Error() string

func (NoMatchingGPGKeysError) ToStatus

func (e NoMatchingGPGKeysError) ToStatus() keybase1.Status

type NoNaClEncryptionKeyError

type NoNaClEncryptionKeyError struct {
	Username     string
	HasPGPKey    bool
	HasPUK       bool
	HasDeviceKey bool
	HasPaperKey  bool
}

func (NoNaClEncryptionKeyError) Error

func (e NoNaClEncryptionKeyError) Error() string

func (NoNaClEncryptionKeyError) ToStatus

type NoOpError

type NoOpError struct {
	Desc string
}

NoOpError is returned when an RPC call is issued but it would result in no change, so the call is dropped.

func (NoOpError) Error

func (e NoOpError) Error() string

func (NoOpError) ToStatus

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

type NoPGPEncryptionKeyError

type NoPGPEncryptionKeyError struct {
	User                    string
	HasKeybaseEncryptionKey bool
}

func (NoPGPEncryptionKeyError) Error

func (e NoPGPEncryptionKeyError) Error() string

func (NoPGPEncryptionKeyError) ToStatus

type NoPaperKeysError

type NoPaperKeysError struct {
}

func (NoPaperKeysError) Error

func (u NoPaperKeysError) Error() string

func (NoPaperKeysError) ToStatus

func (e NoPaperKeysError) ToStatus() (ret keybase1.Status)

type NoSecretKeyError

type NoSecretKeyError struct {
}

func (NoSecretKeyError) Error

func (u NoSecretKeyError) Error() string

func (NoSecretKeyError) ToStatus

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

type NoSelectedKeyError

type NoSelectedKeyError struct{}

func (NoSelectedKeyError) Error

func (n NoSelectedKeyError) Error() string

type NoSessionError

type NoSessionError struct{}

func (NoSessionError) Error

func (e NoSessionError) Error() string

KBFS currently matching on this string, so be careful changing this:

func (NoSessionError) ToStatus

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

type NoSessionWriterError

type NoSessionWriterError struct{}

func (NoSessionWriterError) Error

func (e NoSessionWriterError) Error() string

type NoSigChainError

type NoSigChainError struct{}

func (NoSigChainError) Error

func (e NoSigChainError) Error() string

func (NoSigChainError) ToStatus

func (e NoSigChainError) ToStatus() keybase1.Status

type NoSpaceOnDeviceError

type NoSpaceOnDeviceError struct {
	Desc string
}

func (NoSpaceOnDeviceError) Error

func (e NoSpaceOnDeviceError) Error() string

func (NoSpaceOnDeviceError) ToStatus

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

type NoSyncedPGPKeyError

type NoSyncedPGPKeyError struct{}

func (NoSyncedPGPKeyError) Error

func (e NoSyncedPGPKeyError) Error() string

func (NoSyncedPGPKeyError) ToStatus

func (e NoSyncedPGPKeyError) ToStatus() keybase1.Status

type NoTriplesecError

type NoTriplesecError struct{}

func (NoTriplesecError) Error

func (e NoTriplesecError) Error() string

type NoUIDError

type NoUIDError struct{}

func (NoUIDError) Error

func (e NoUIDError) Error() string

type NoUIError

type NoUIError struct {
	Which string
}

func (NoUIError) Error

func (e NoUIError) Error() string

func (NoUIError) ToStatus

func (e NoUIError) ToStatus() keybase1.Status

type NoUserConfigError

type NoUserConfigError struct{}

func (NoUserConfigError) Error

func (n NoUserConfigError) Error() string

type NoUsernameError

type NoUsernameError struct{}

func NewNoUsernameError

func NewNoUsernameError() NoUsernameError

func (NoUsernameError) Error

func (e NoUsernameError) Error() string

type NodeHash

type NodeHash interface {
	Check(s string) bool // Check if the node hashes to this string
	String() string

	IsNil() bool
	Eq(h NodeHash) bool
	// contains filtered or unexported methods
}

func GetNodeHash

func GetNodeHash(w *jsonw.Wrapper) (NodeHash, error)

func NodeHashFromHex

func NodeHashFromHex(s string) (NodeHash, error)

type NodeHashAny

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

NodeHashAny incorporates either a short (256-bit) or a long (512-bit) hash. It's unfortunate we need it, but I didn't see any other way to use the Go json marshal/unmarshal system where the hashes might be either short or long. Our hacky solution is to have a union-type struct that supports both, and just to unmarshal into the relevant field. Note this type also fits ths NodeHash interface.

func (NodeHashAny) Check

func (h NodeHashAny) Check(s string) bool

func (NodeHashAny) Eq

func (h NodeHashAny) Eq(h2 NodeHash) bool

func (NodeHashAny) IsNil

func (h NodeHashAny) IsNil() bool

func (*NodeHashAny) MarshalJSON

func (h *NodeHashAny) MarshalJSON() ([]byte, error)

func (NodeHashAny) String

func (h NodeHashAny) String() string

func (*NodeHashAny) UnmarshalJSON

func (h *NodeHashAny) UnmarshalJSON(b []byte) error

type NodeHashLong

type NodeHashLong [NodeHashLenLong]byte

func (NodeHashLong) Check

func (h1 NodeHashLong) Check(s string) bool

func (NodeHashLong) Eq

func (h1 NodeHashLong) Eq(h2 NodeHash) bool

func (NodeHashLong) IsNil

func (h1 NodeHashLong) IsNil() bool

func (NodeHashLong) String

func (h1 NodeHashLong) String() string

func (*NodeHashLong) UnmarshalJSON

func (h1 *NodeHashLong) UnmarshalJSON(b []byte) error

type NodeHashShort

type NodeHashShort [NodeHashLenShort]byte

func (NodeHashShort) Check

func (h1 NodeHashShort) Check(s string) bool

func (NodeHashShort) Eq

func (h1 NodeHashShort) Eq(h2 NodeHash) bool

func (NodeHashShort) ExportToHashMeta

func (h1 NodeHashShort) ExportToHashMeta() keybase1.HashMeta

func (NodeHashShort) IsNil

func (h1 NodeHashShort) IsNil() bool

func (NodeHashShort) String

func (h1 NodeHashShort) String() string

func (*NodeHashShort) UnmarshalJSON

func (h1 *NodeHashShort) UnmarshalJSON(b []byte) error

type NoiseBytes

type NoiseBytes [noiseFileLen]byte

func MakeNoise

func MakeNoise() (nb NoiseBytes, err error)

type NoopNotifyListener

type NoopNotifyListener struct{}

func (*NoopNotifyListener) AvatarUpdated

func (n *NoopNotifyListener) AvatarUpdated(name string, formats []keybase1.AvatarFormat)

func (*NoopNotifyListener) BadgeState

func (n *NoopNotifyListener) BadgeState(badgeState keybase1.BadgeState)

func (*NoopNotifyListener) BoxAuditError

func (n *NoopNotifyListener) BoxAuditError(msg string)

func (*NoopNotifyListener) CanUserPerformChanged

func (n *NoopNotifyListener) CanUserPerformChanged(teamName string)

func (*NoopNotifyListener) Chat

func (n *NoopNotifyListener) Chat(uid keybase1.UID, convID chat1.ConversationID)

func (*NoopNotifyListener) ChatAttachmentDownloadComplete

func (n *NoopNotifyListener) ChatAttachmentDownloadComplete(uid keybase1.UID, convID chat1.ConversationID,
	msgID chat1.MessageID)

func (*NoopNotifyListener) ChatAttachmentDownloadProgress

func (n *NoopNotifyListener) ChatAttachmentDownloadProgress(uid keybase1.UID, convID chat1.ConversationID,
	msgID chat1.MessageID, bytesComplete, bytesTotal int64)

func (*NoopNotifyListener) ChatAttachmentUploadProgress

func (n *NoopNotifyListener) ChatAttachmentUploadProgress(uid keybase1.UID, convID chat1.ConversationID,
	outboxID chat1.OutboxID, bytesComplete, bytesTotal int64)

func (*NoopNotifyListener) ChatAttachmentUploadStart

func (n *NoopNotifyListener) ChatAttachmentUploadStart(uid keybase1.UID, convID chat1.ConversationID,
	outboxID chat1.OutboxID)

func (*NoopNotifyListener) ChatConvUpdate

func (n *NoopNotifyListener) ChatConvUpdate(uid keybase1.UID, convID chat1.ConversationID)

func (*NoopNotifyListener) ChatIdentifyUpdate

func (n *NoopNotifyListener) ChatIdentifyUpdate(update keybase1.CanonicalTLFNameAndIDWithBreaks)

func (*NoopNotifyListener) ChatInboxStale

func (n *NoopNotifyListener) ChatInboxStale(uid keybase1.UID)

func (*NoopNotifyListener) ChatInboxSyncStarted

func (n *NoopNotifyListener) ChatInboxSyncStarted(uid keybase1.UID)

func (*NoopNotifyListener) ChatInboxSynced

func (n *NoopNotifyListener) ChatInboxSynced(uid keybase1.UID, topicType chat1.TopicType,
	syncRes chat1.ChatSyncResult)

func (*NoopNotifyListener) ChatJoinedConversation

func (n *NoopNotifyListener) ChatJoinedConversation(uid keybase1.UID, convID chat1.ConversationID,
	conv *chat1.InboxUIItem)

func (*NoopNotifyListener) ChatKBFSToImpteamUpgrade

func (n *NoopNotifyListener) ChatKBFSToImpteamUpgrade(uid keybase1.UID, convID chat1.ConversationID)

func (*NoopNotifyListener) ChatLeftConversation

func (n *NoopNotifyListener) ChatLeftConversation(uid keybase1.UID, convID chat1.ConversationID)

func (*NoopNotifyListener) ChatParticipantsInfo

func (n *NoopNotifyListener) ChatParticipantsInfo(
	participants map[chat1.ConvIDStr][]chat1.UIParticipant)

func (*NoopNotifyListener) ChatPaymentInfo

func (n *NoopNotifyListener) ChatPaymentInfo(uid keybase1.UID, convID chat1.ConversationID,
	msgID chat1.MessageID, info chat1.UIPaymentInfo)

func (*NoopNotifyListener) ChatPromptUnfurl

func (n *NoopNotifyListener) ChatPromptUnfurl(uid keybase1.UID, convID chat1.ConversationID,
	msgID chat1.MessageID, domain string)

func (*NoopNotifyListener) ChatRequestInfo

func (n *NoopNotifyListener) ChatRequestInfo(uid keybase1.UID, convID chat1.ConversationID,
	msgID chat1.MessageID, info chat1.UIRequestInfo)

func (*NoopNotifyListener) ChatResetConversation

func (n *NoopNotifyListener) ChatResetConversation(uid keybase1.UID, convID chat1.ConversationID)

func (*NoopNotifyListener) ChatSetConvRetention

func (n *NoopNotifyListener) ChatSetConvRetention(uid keybase1.UID, convID chat1.ConversationID)

func (*NoopNotifyListener) ChatSetConvSettings

func (n *NoopNotifyListener) ChatSetConvSettings(uid keybase1.UID, convID chat1.ConversationID)

func (*NoopNotifyListener) ChatSetTeamRetention

func (n *NoopNotifyListener) ChatSetTeamRetention(uid keybase1.UID, teamID keybase1.TeamID)

func (*NoopNotifyListener) ChatSubteamRename

func (n *NoopNotifyListener) ChatSubteamRename(uid keybase1.UID, convIDs []chat1.ConversationID)

func (*NoopNotifyListener) ChatTLFFinalize

func (n *NoopNotifyListener) ChatTLFFinalize(uid keybase1.UID, convID chat1.ConversationID,
	finalizeInfo chat1.ConversationFinalizeInfo)

func (*NoopNotifyListener) ChatTLFResolve

func (n *NoopNotifyListener) ChatTLFResolve(uid keybase1.UID, convID chat1.ConversationID,
	resolveInfo chat1.ConversationResolveInfo)

func (*NoopNotifyListener) ChatThreadsStale

func (n *NoopNotifyListener) ChatThreadsStale(uid keybase1.UID, updates []chat1.ConversationStaleUpdate)

func (*NoopNotifyListener) ChatTypingUpdate

func (n *NoopNotifyListener) ChatTypingUpdate([]chat1.ConvTypingUpdate)

func (*NoopNotifyListener) ChatWelcomeMessageLoaded

func (n *NoopNotifyListener) ChatWelcomeMessageLoaded(keybase1.TeamID, chat1.WelcomeMessageDisplay)

func (*NoopNotifyListener) ClientOutOfDate

func (n *NoopNotifyListener) ClientOutOfDate(to, uri, msg string)

func (*NoopNotifyListener) DeviceCloneCountChanged

func (n *NoopNotifyListener) DeviceCloneCountChanged(newClones int)

func (*NoopNotifyListener) EmailAddressVerified

func (n *NoopNotifyListener) EmailAddressVerified(emailAddress keybase1.EmailAddress)

func (*NoopNotifyListener) EmailsChanged

func (n *NoopNotifyListener) EmailsChanged(list []keybase1.Email, category string, email keybase1.EmailAddress)

func (*NoopNotifyListener) FSActivity

func (n *NoopNotifyListener) FSActivity(activity keybase1.FSNotification)

func (*NoopNotifyListener) FSEditListRequest

func (n *NoopNotifyListener) FSEditListRequest(arg keybase1.FSEditListRequest)

func (*NoopNotifyListener) FSEditListResponse

func (n *NoopNotifyListener) FSEditListResponse(arg keybase1.FSEditListArg)

func (*NoopNotifyListener) FSFavoritesChanged

func (n *NoopNotifyListener) FSFavoritesChanged()

func (*NoopNotifyListener) FSOnlineStatusChanged

func (n *NoopNotifyListener) FSOnlineStatusChanged(online bool)

func (*NoopNotifyListener) FSOverallSyncStatusChanged

func (n *NoopNotifyListener) FSOverallSyncStatusChanged(status keybase1.FolderSyncStatus)

func (*NoopNotifyListener) FSPathUpdated

func (n *NoopNotifyListener) FSPathUpdated(path string)

func (*NoopNotifyListener) FSSubscriptionNotify

func (n *NoopNotifyListener) FSSubscriptionNotify(arg keybase1.FSSubscriptionNotifyArg)

func (*NoopNotifyListener) FSSubscriptionNotifyPath

func (n *NoopNotifyListener) FSSubscriptionNotifyPath(arg keybase1.FSSubscriptionNotifyPathArg)

func (*NoopNotifyListener) FSSyncEvent

func (n *NoopNotifyListener) FSSyncEvent(arg keybase1.FSPathSyncStatus)

func (*NoopNotifyListener) FSSyncStatusResponse

func (n *NoopNotifyListener) FSSyncStatusResponse(arg keybase1.FSSyncStatusArg)

func (*NoopNotifyListener) FavoritesChanged

func (n *NoopNotifyListener) FavoritesChanged(uid keybase1.UID)

func (*NoopNotifyListener) FeaturedBotsUpdate

func (n *NoopNotifyListener) FeaturedBotsUpdate(bots []keybase1.FeaturedBot, limit, offset int)

func (*NoopNotifyListener) HTTPSrvInfoUpdate

func (n *NoopNotifyListener) HTTPSrvInfoUpdate(keybase1.HttpSrvInfo)
func (n *NoopNotifyListener) HandleKeybaseLink(link string, deferred bool)

func (*NoopNotifyListener) IdentifyUpdate

func (n *NoopNotifyListener) IdentifyUpdate(okUsernames []string, brokenUsernames []string)

func (*NoopNotifyListener) KeyfamilyChanged

func (n *NoopNotifyListener) KeyfamilyChanged(uid keybase1.UID)

func (*NoopNotifyListener) Login

func (n *NoopNotifyListener) Login(username string)

func (*NoopNotifyListener) Logout

func (n *NoopNotifyListener) Logout()

func (*NoopNotifyListener) NewChatActivity

func (n *NoopNotifyListener) NewChatActivity(uid keybase1.UID, activity chat1.ChatActivity,
	source chat1.ChatActivitySource)

func (*NoopNotifyListener) NewChatKBFSFileEditActivity

func (n *NoopNotifyListener) NewChatKBFSFileEditActivity(uid keybase1.UID, activity chat1.ChatActivity)

func (*NoopNotifyListener) NewTeamEK

func (n *NoopNotifyListener) NewTeamEK(teamID keybase1.TeamID, generation keybase1.EkGeneration)

func (*NoopNotifyListener) NewTeambotEK

func (n *NoopNotifyListener) NewTeambotEK(teamID keybase1.TeamID, generation keybase1.EkGeneration)

func (*NoopNotifyListener) NewTeambotKey

func (n *NoopNotifyListener) NewTeambotKey(teamID keybase1.TeamID, generation keybase1.TeambotKeyGeneration)

func (*NoopNotifyListener) NewlyAddedToTeam

func (n *NoopNotifyListener) NewlyAddedToTeam(teamID keybase1.TeamID)

func (*NoopNotifyListener) PGPKeyInSecretStoreFile

func (n *NoopNotifyListener) PGPKeyInSecretStoreFile()

func (*NoopNotifyListener) PaperKeyCached

func (n *NoopNotifyListener) PaperKeyCached(uid keybase1.UID, encKID keybase1.KID, sigKID keybase1.KID)

func (*NoopNotifyListener) PasswordChanged

func (n *NoopNotifyListener) PasswordChanged()

func (*NoopNotifyListener) PhoneNumbersChanged

func (n *NoopNotifyListener) PhoneNumbersChanged(list []keybase1.UserPhoneNumber, category string, phoneNumber keybase1.PhoneNumber)

func (*NoopNotifyListener) Reachability

func (n *NoopNotifyListener) Reachability(keybase1.Reachability)

func (*NoopNotifyListener) ReachabilityChanged

func (n *NoopNotifyListener) ReachabilityChanged(r keybase1.Reachability)

func (*NoopNotifyListener) RootAuditError

func (n *NoopNotifyListener) RootAuditError(msg string)

func (*NoopNotifyListener) RuntimeStatsUpdate

func (n *NoopNotifyListener) RuntimeStatsUpdate(*keybase1.RuntimeStats)

func (*NoopNotifyListener) SaltpackOperationDone

func (n *NoopNotifyListener) SaltpackOperationDone(opType keybase1.SaltpackOperationType, filename string)

func (*NoopNotifyListener) SaltpackOperationProgress

func (n *NoopNotifyListener) SaltpackOperationProgress(opType keybase1.SaltpackOperationType, filename string, bytesComplete, bytesTotal int64)

func (*NoopNotifyListener) SaltpackOperationStart

func (n *NoopNotifyListener) SaltpackOperationStart(opType keybase1.SaltpackOperationType, filename string)

func (*NoopNotifyListener) TeamChangedByID

func (n *NoopNotifyListener) TeamChangedByID(teamID keybase1.TeamID, latestSeqno keybase1.Seqno, implicitTeam bool, changes keybase1.TeamChangeSet, latestHiddenSeqno keybase1.Seqno, source keybase1.TeamChangedSource)

func (*NoopNotifyListener) TeamChangedByName

func (n *NoopNotifyListener) TeamChangedByName(teamName string, latestSeqno keybase1.Seqno, implicitTeam bool, changes keybase1.TeamChangeSet, latestHiddenSeqno keybase1.Seqno, source keybase1.TeamChangedSource)

func (*NoopNotifyListener) TeamDeleted

func (n *NoopNotifyListener) TeamDeleted(teamID keybase1.TeamID)

func (*NoopNotifyListener) TeamExit

func (n *NoopNotifyListener) TeamExit(teamID keybase1.TeamID)

func (*NoopNotifyListener) TeamMetadataUpdate

func (n *NoopNotifyListener) TeamMetadataUpdate()

func (*NoopNotifyListener) TeamRoleMapChanged

func (n *NoopNotifyListener) TeamRoleMapChanged(version keybase1.UserTeamVersion)

func (*NoopNotifyListener) TeamTreeMembershipsDone

func (n *NoopNotifyListener) TeamTreeMembershipsDone(keybase1.TeamTreeMembershipsDoneResult)

func (*NoopNotifyListener) TeamTreeMembershipsPartial

func (n *NoopNotifyListener) TeamTreeMembershipsPartial(keybase1.TeamTreeMembership)

func (*NoopNotifyListener) TeambotEKNeeded

func (n *NoopNotifyListener) TeambotEKNeeded(teamID keybase1.TeamID, botUID keybase1.UID,
	generation keybase1.EkGeneration, forceCreateGen *keybase1.EkGeneration)

func (*NoopNotifyListener) TeambotKeyNeeded

func (n *NoopNotifyListener) TeambotKeyNeeded(teamID keybase1.TeamID, botUID keybase1.UID,
	generation keybase1.TeambotKeyGeneration)

func (*NoopNotifyListener) TrackingChanged

func (n *NoopNotifyListener) TrackingChanged(uid keybase1.UID, username NormalizedUsername)

func (*NoopNotifyListener) TrackingInfo

func (n *NoopNotifyListener) TrackingInfo(uid keybase1.UID, followers, followees []string)

func (*NoopNotifyListener) UpdateInviteCounts

func (n *NoopNotifyListener) UpdateInviteCounts(keybase1.InviteCounts)

func (*NoopNotifyListener) UserBlocked

func (*NoopNotifyListener) UserChanged

func (n *NoopNotifyListener) UserChanged(uid keybase1.UID)

func (*NoopNotifyListener) WalletAccountDetailsUpdate

func (n *NoopNotifyListener) WalletAccountDetailsUpdate(accountID stellar1.AccountID, account stellar1.WalletAccountLocal)

func (*NoopNotifyListener) WalletAccountsUpdate

func (n *NoopNotifyListener) WalletAccountsUpdate(accounts []stellar1.WalletAccountLocal)

func (*NoopNotifyListener) WalletPaymentNotification

func (n *NoopNotifyListener) WalletPaymentNotification(accountID stellar1.AccountID, paymentID stellar1.PaymentID)

func (*NoopNotifyListener) WalletPaymentStatusNotification

func (n *NoopNotifyListener) WalletPaymentStatusNotification(accountID stellar1.AccountID, paymentID stellar1.PaymentID)

func (*NoopNotifyListener) WalletPendingPaymentsUpdate

func (n *NoopNotifyListener) WalletPendingPaymentsUpdate(accountID stellar1.AccountID, pending []stellar1.PaymentOrErrorLocal)

func (*NoopNotifyListener) WalletRecentPaymentsUpdate

func (n *NoopNotifyListener) WalletRecentPaymentsUpdate(accountID stellar1.AccountID, firstPage stellar1.PaymentsPageLocal)

func (*NoopNotifyListener) WalletRequestStatusNotification

func (n *NoopNotifyListener) WalletRequestStatusNotification(reqID stellar1.KeybaseRequestID)

func (*NoopNotifyListener) WebOfTrustChanged

func (n *NoopNotifyListener) WebOfTrustChanged(username string)

type NopWriteCloser

type NopWriteCloser struct {
	W io.Writer
}

NopWriteCloser is like an io.NopCloser, but for an io.Writer. TODO: we have two of these in OpenPGP packages alone. This probably needs to be promoted somewhere more common.

From here:

https://code.google.com/p/go/source/browse/openpgp/write.go?repo=crypto&r=1e7a3e301825bf9cb32e0535f3761d62d2d369d1#364

func (NopWriteCloser) Close

func (c NopWriteCloser) Close() error

func (NopWriteCloser) Write

func (c NopWriteCloser) Write(data []byte) (n int, err error)

type NormalizedUsername

type NormalizedUsername = kbun.NormalizedUsername

TODO (CORE-6576): Remove these aliases once everything outside of this repo points to kbun.

func NewNormalizedUsername

func NewNormalizedUsername(s string) NormalizedUsername

func NormalizedUsernameFromUPK2

func NormalizedUsernameFromUPK2(u keybase1.UserPlusKeysV2) NormalizedUsername

func ValidateNormalizedUsername

func ValidateNormalizedUsername(username string) (NormalizedUsername, error)

type NotConfirmedError

type NotConfirmedError struct{}

func (NotConfirmedError) Error

func (e NotConfirmedError) Error() string

type NotFoundError

type NotFoundError struct {
	Msg string
}

func (NotFoundError) Error

func (e NotFoundError) Error() string

func (NotFoundError) ToStatus

func (e NotFoundError) ToStatus() keybase1.Status

type NotLatestSubchainError

type NotLatestSubchainError struct {
	Msg string
}

func (NotLatestSubchainError) Error

func (e NotLatestSubchainError) Error() string

type NotProvisionedError

type NotProvisionedError struct{}

func (NotProvisionedError) Error

func (e NotProvisionedError) Error() string

type NotifyListener

type NotifyListener interface {
	Logout()
	Login(username string)
	ClientOutOfDate(to, uri, msg string)
	UserChanged(uid keybase1.UID)
	TrackingChanged(uid keybase1.UID, username NormalizedUsername)
	TrackingInfo(uid keybase1.UID, followers, followees []string)
	FSOnlineStatusChanged(online bool)
	FSActivity(activity keybase1.FSNotification)
	FSPathUpdated(path string)
	FSEditListResponse(arg keybase1.FSEditListArg)
	FSSyncStatusResponse(arg keybase1.FSSyncStatusArg)
	FSSyncEvent(arg keybase1.FSPathSyncStatus)
	FSEditListRequest(arg keybase1.FSEditListRequest)
	FSOverallSyncStatusChanged(arg keybase1.FolderSyncStatus)
	FSFavoritesChanged()
	FavoritesChanged(uid keybase1.UID)
	FSSubscriptionNotify(arg keybase1.FSSubscriptionNotifyArg)
	FSSubscriptionNotifyPath(arg keybase1.FSSubscriptionNotifyPathArg)
	PaperKeyCached(uid keybase1.UID, encKID keybase1.KID, sigKID keybase1.KID)
	KeyfamilyChanged(uid keybase1.UID)
	NewChatActivity(uid keybase1.UID, activity chat1.ChatActivity, source chat1.ChatActivitySource)
	NewChatKBFSFileEditActivity(uid keybase1.UID, activity chat1.ChatActivity)
	ChatIdentifyUpdate(update keybase1.CanonicalTLFNameAndIDWithBreaks)
	ChatTLFFinalize(uid keybase1.UID, convID chat1.ConversationID,
		finalizeInfo chat1.ConversationFinalizeInfo)
	ChatTLFResolve(uid keybase1.UID, convID chat1.ConversationID,
		resolveInfo chat1.ConversationResolveInfo)
	ChatInboxStale(uid keybase1.UID)
	ChatThreadsStale(uid keybase1.UID, updates []chat1.ConversationStaleUpdate)
	ChatInboxSynced(uid keybase1.UID, topicType chat1.TopicType, syncRes chat1.ChatSyncResult)
	ChatInboxSyncStarted(uid keybase1.UID)
	ChatTypingUpdate([]chat1.ConvTypingUpdate)
	ChatJoinedConversation(uid keybase1.UID, convID chat1.ConversationID, conv *chat1.InboxUIItem)
	ChatLeftConversation(uid keybase1.UID, convID chat1.ConversationID)
	ChatResetConversation(uid keybase1.UID, convID chat1.ConversationID)
	ChatSetConvRetention(uid keybase1.UID, convID chat1.ConversationID)
	ChatSetTeamRetention(uid keybase1.UID, teamID keybase1.TeamID)
	ChatSetConvSettings(uid keybase1.UID, convID chat1.ConversationID)
	ChatSubteamRename(uid keybase1.UID, convIDs []chat1.ConversationID)
	ChatKBFSToImpteamUpgrade(uid keybase1.UID, convID chat1.ConversationID)
	ChatAttachmentUploadStart(uid keybase1.UID, convID chat1.ConversationID, outboxID chat1.OutboxID)
	ChatAttachmentUploadProgress(uid keybase1.UID, convID chat1.ConversationID, outboxID chat1.OutboxID,
		bytesComplete, bytesTotal int64)
	ChatAttachmentDownloadProgress(uid keybase1.UID, convID chat1.ConversationID, msgID chat1.MessageID,
		bytesComplete, bytesTotal int64)
	ChatAttachmentDownloadComplete(uid keybase1.UID, convID chat1.ConversationID, msgID chat1.MessageID)
	ChatPaymentInfo(uid keybase1.UID, convID chat1.ConversationID, msgID chat1.MessageID, info chat1.UIPaymentInfo)
	ChatRequestInfo(uid keybase1.UID, convID chat1.ConversationID, msgID chat1.MessageID, info chat1.UIRequestInfo)
	ChatPromptUnfurl(uid keybase1.UID, convID chat1.ConversationID, msgID chat1.MessageID, domain string)
	ChatConvUpdate(uid keybase1.UID, convID chat1.ConversationID)
	ChatWelcomeMessageLoaded(teamID keybase1.TeamID, message chat1.WelcomeMessageDisplay)
	ChatParticipantsInfo(participants map[chat1.ConvIDStr][]chat1.UIParticipant)
	PGPKeyInSecretStoreFile()
	BadgeState(badgeState keybase1.BadgeState)
	ReachabilityChanged(r keybase1.Reachability)
	TeamChangedByID(teamID keybase1.TeamID, latestSeqno keybase1.Seqno, implicitTeam bool, changes keybase1.TeamChangeSet, latestHiddenSeqno keybase1.Seqno, source keybase1.TeamChangedSource)
	TeamChangedByName(teamName string, latestSeqno keybase1.Seqno, implicitTeam bool, changes keybase1.TeamChangeSet, latestHiddenSeqno keybase1.Seqno, source keybase1.TeamChangedSource)
	TeamDeleted(teamID keybase1.TeamID)
	TeamRoleMapChanged(version keybase1.UserTeamVersion)
	UserBlocked(b keybase1.UserBlockedBody)
	TeamExit(teamID keybase1.TeamID)
	NewlyAddedToTeam(teamID keybase1.TeamID)
	NewTeamEK(teamID keybase1.TeamID, generation keybase1.EkGeneration)
	NewTeambotEK(teamID keybase1.TeamID, generation keybase1.EkGeneration)
	TeambotEKNeeded(teamID keybase1.TeamID, botUID keybase1.UID, generation keybase1.EkGeneration, forceCreateGen *keybase1.EkGeneration)
	NewTeambotKey(teamID keybase1.TeamID, generation keybase1.TeambotKeyGeneration)
	TeambotKeyNeeded(teamID keybase1.TeamID, botUID keybase1.UID, generation keybase1.TeambotKeyGeneration)
	AvatarUpdated(name string, formats []keybase1.AvatarFormat)
	DeviceCloneCountChanged(newClones int)
	WalletPaymentNotification(accountID stellar1.AccountID, paymentID stellar1.PaymentID)
	WalletPaymentStatusNotification(accountID stellar1.AccountID, paymentID stellar1.PaymentID)
	WalletRequestStatusNotification(reqID stellar1.KeybaseRequestID)
	WalletAccountDetailsUpdate(accountID stellar1.AccountID, account stellar1.WalletAccountLocal)
	WalletAccountsUpdate(accounts []stellar1.WalletAccountLocal)
	WalletPendingPaymentsUpdate(accountID stellar1.AccountID, pending []stellar1.PaymentOrErrorLocal)
	WalletRecentPaymentsUpdate(accountID stellar1.AccountID, firstPage stellar1.PaymentsPageLocal)
	TeamMetadataUpdate()
	CanUserPerformChanged(teamName string)
	PhoneNumbersChanged(list []keybase1.UserPhoneNumber, category string, phoneNumber keybase1.PhoneNumber)
	EmailAddressVerified(emailAddress keybase1.EmailAddress)
	EmailsChanged(list []keybase1.Email, category string, email keybase1.EmailAddress)
	PasswordChanged()
	RootAuditError(msg string)
	BoxAuditError(msg string)
	RuntimeStatsUpdate(*keybase1.RuntimeStats)
	HTTPSrvInfoUpdate(keybase1.HttpSrvInfo)
	HandleKeybaseLink(link string, deferred bool)
	IdentifyUpdate(okUsernames []string, brokenUsernames []string)
	Reachability(keybase1.Reachability)
	FeaturedBotsUpdate(bots []keybase1.FeaturedBot, limit, offset int)
	SaltpackOperationStart(opType keybase1.SaltpackOperationType, filename string)
	SaltpackOperationProgress(opType keybase1.SaltpackOperationType, filename string, bytesComplete, bytesTotal int64)
	SaltpackOperationDone(opType keybase1.SaltpackOperationType, filename string)
	UpdateInviteCounts(keybase1.InviteCounts)
	TeamTreeMembershipsPartial(keybase1.TeamTreeMembership)
	TeamTreeMembershipsDone(keybase1.TeamTreeMembershipsDoneResult)
	WebOfTrustChanged(username string)
}

NotifyListener provides hooks for listening for when notifications are called. It is intended to simplify testing notifications.

type NotifyListenerID

type NotifyListenerID string

type NotifyRouter

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

NotifyRouter routes notifications to the various active RPC connections. It's careful only to route to those who are interested

func NewNotifyRouter

func NewNotifyRouter(g *GlobalContext) *NotifyRouter

NewNotifyRouter makes a new notification router; we should only make one of these per process.

func (*NotifyRouter) AddConnection

func (n *NotifyRouter) AddConnection(xp rpc.Transporter, ch chan error) ConnectionID

AddConnection should be called every time there's a new RPC connection established for this server. The caller should pass in the Transporter and also the channel that will get messages when the channel closes.

func (*NotifyRouter) AddListener

func (n *NotifyRouter) AddListener(listener NotifyListener) NotifyListenerID

func (*NotifyRouter) GetChannels

GetChannels retrieves which notification channels a connection is interested it given its ID.

func (*NotifyRouter) HandleAppExit

func (n *NotifyRouter) HandleAppExit()

HandleAppExit is called whenever an app exit command is issued

func (*NotifyRouter) HandleAvatarUpdated

func (n *NotifyRouter) HandleAvatarUpdated(ctx context.Context, name string, formats []keybase1.AvatarFormat,
	typ keybase1.AvatarUpdateType)

func (*NotifyRouter) HandleBadgeState

func (n *NotifyRouter) HandleBadgeState(badgeState keybase1.BadgeState)

HandleBadgeState is called whenever the badge state changes It will broadcast the messages to all curious listeners.

func (*NotifyRouter) HandleBoxAuditError

func (n *NotifyRouter) HandleBoxAuditError(ctx context.Context, msg string)

func (*NotifyRouter) HandleCanUserPerformChanged

func (n *NotifyRouter) HandleCanUserPerformChanged(ctx context.Context, teamName string)

HandleCanUserPerformChanged is called when a notification is received from gregor that we think might be of interest to the UI, specifically the parts of the UI that update permissions for a user in a team.

func (*NotifyRouter) HandleChatAttachmentDownloadComplete

func (n *NotifyRouter) HandleChatAttachmentDownloadComplete(ctx context.Context, uid keybase1.UID,
	convID chat1.ConversationID, msgID chat1.MessageID)

func (*NotifyRouter) HandleChatAttachmentDownloadProgress

func (n *NotifyRouter) HandleChatAttachmentDownloadProgress(ctx context.Context, uid keybase1.UID,
	convID chat1.ConversationID, msgID chat1.MessageID, bytesComplete, bytesTotal int64)

func (*NotifyRouter) HandleChatAttachmentUploadProgress

func (n *NotifyRouter) HandleChatAttachmentUploadProgress(ctx context.Context, uid keybase1.UID,
	convID chat1.ConversationID, outboxID chat1.OutboxID, bytesComplete, bytesTotal int64)

func (*NotifyRouter) HandleChatAttachmentUploadStart

func (n *NotifyRouter) HandleChatAttachmentUploadStart(ctx context.Context, uid keybase1.UID,
	convID chat1.ConversationID, outboxID chat1.OutboxID)

func (*NotifyRouter) HandleChatConvUpdate

func (n *NotifyRouter) HandleChatConvUpdate(ctx context.Context, uid keybase1.UID,
	convID chat1.ConversationID, topicType chat1.TopicType, conv *chat1.InboxUIItem)

func (*NotifyRouter) HandleChatIdentifyUpdate

func (n *NotifyRouter) HandleChatIdentifyUpdate(ctx context.Context, update keybase1.CanonicalTLFNameAndIDWithBreaks)

func (*NotifyRouter) HandleChatInboxStale

func (n *NotifyRouter) HandleChatInboxStale(ctx context.Context, uid keybase1.UID)

func (*NotifyRouter) HandleChatInboxSyncStarted

func (n *NotifyRouter) HandleChatInboxSyncStarted(ctx context.Context, uid keybase1.UID)

func (*NotifyRouter) HandleChatInboxSynced

func (n *NotifyRouter) HandleChatInboxSynced(ctx context.Context, uid keybase1.UID,
	topicType chat1.TopicType, syncRes chat1.ChatSyncResult)

func (*NotifyRouter) HandleChatJoinedConversation

func (n *NotifyRouter) HandleChatJoinedConversation(ctx context.Context, uid keybase1.UID,
	convID chat1.ConversationID, topicType chat1.TopicType, conv *chat1.InboxUIItem)

func (*NotifyRouter) HandleChatKBFSToImpteamUpgrade

func (n *NotifyRouter) HandleChatKBFSToImpteamUpgrade(ctx context.Context, uid keybase1.UID,
	convID chat1.ConversationID, topicType chat1.TopicType)

func (*NotifyRouter) HandleChatLeftConversation

func (n *NotifyRouter) HandleChatLeftConversation(ctx context.Context, uid keybase1.UID,
	convID chat1.ConversationID, topicType chat1.TopicType)

func (*NotifyRouter) HandleChatParticipantsInfo

func (n *NotifyRouter) HandleChatParticipantsInfo(ctx context.Context,
	participants map[chat1.ConvIDStr][]chat1.UIParticipant)

func (*NotifyRouter) HandleChatPaymentInfo

func (n *NotifyRouter) HandleChatPaymentInfo(ctx context.Context, uid keybase1.UID, convID chat1.ConversationID, msgID chat1.MessageID, info chat1.UIPaymentInfo)

func (*NotifyRouter) HandleChatPromptUnfurl

func (n *NotifyRouter) HandleChatPromptUnfurl(ctx context.Context, uid keybase1.UID,
	convID chat1.ConversationID, msgID chat1.MessageID, domain string)

func (*NotifyRouter) HandleChatRequestInfo

func (n *NotifyRouter) HandleChatRequestInfo(ctx context.Context, uid keybase1.UID, convID chat1.ConversationID, msgID chat1.MessageID, info chat1.UIRequestInfo)

func (*NotifyRouter) HandleChatResetConversation

func (n *NotifyRouter) HandleChatResetConversation(ctx context.Context, uid keybase1.UID,
	convID chat1.ConversationID, topicType chat1.TopicType)

func (*NotifyRouter) HandleChatSetConvRetention

func (n *NotifyRouter) HandleChatSetConvRetention(ctx context.Context, uid keybase1.UID,
	convID chat1.ConversationID, topicType chat1.TopicType, conv *chat1.InboxUIItem)

func (*NotifyRouter) HandleChatSetConvSettings

func (n *NotifyRouter) HandleChatSetConvSettings(ctx context.Context, uid keybase1.UID,
	convID chat1.ConversationID, topicType chat1.TopicType, conv *chat1.InboxUIItem)

func (*NotifyRouter) HandleChatSetTeamRetention

func (n *NotifyRouter) HandleChatSetTeamRetention(ctx context.Context, uid keybase1.UID,
	teamID keybase1.TeamID, topicType chat1.TopicType, convs []chat1.InboxUIItem)

func (*NotifyRouter) HandleChatSubteamRename

func (n *NotifyRouter) HandleChatSubteamRename(ctx context.Context, uid keybase1.UID,
	convIDs []chat1.ConversationID, topicType chat1.TopicType, convs []chat1.InboxUIItem)

func (*NotifyRouter) HandleChatTLFFinalize

func (n *NotifyRouter) HandleChatTLFFinalize(ctx context.Context, uid keybase1.UID,
	convID chat1.ConversationID, topicType chat1.TopicType, finalizeInfo chat1.ConversationFinalizeInfo,
	conv *chat1.InboxUIItem)

func (*NotifyRouter) HandleChatTLFResolve

func (n *NotifyRouter) HandleChatTLFResolve(ctx context.Context, uid keybase1.UID,
	convID chat1.ConversationID, topicType chat1.TopicType, resolveInfo chat1.ConversationResolveInfo)

func (*NotifyRouter) HandleChatThreadsStale

func (n *NotifyRouter) HandleChatThreadsStale(ctx context.Context, uid keybase1.UID,
	updates []chat1.ConversationStaleUpdate)

func (*NotifyRouter) HandleChatTypingUpdate

func (n *NotifyRouter) HandleChatTypingUpdate(ctx context.Context, updates []chat1.ConvTypingUpdate)

func (*NotifyRouter) HandleChatWelcomeMessageLoaded

func (n *NotifyRouter) HandleChatWelcomeMessageLoaded(ctx context.Context,
	teamID keybase1.TeamID, message chat1.WelcomeMessageDisplay)

func (*NotifyRouter) HandleClientOutOfDate

func (n *NotifyRouter) HandleClientOutOfDate(upgradeTo, upgradeURI, upgradeMsg string)

ClientOutOfDate is called whenever the API server tells us our client is out of date. (This is done by adding special headers to every API response that an out-of-date client makes.)

func (*NotifyRouter) HandleDeviceCloneNotification

func (n *NotifyRouter) HandleDeviceCloneNotification(newClones int)

HandleDeviceCloneNotification is called when a run of the device clone status update finds a newly-added, possible clone. It will broadcast the messages to all curious listeners.

func (*NotifyRouter) HandleEmailAddressChanged

func (n *NotifyRouter) HandleEmailAddressChanged(ctx context.Context, list []keybase1.Email, category string, emailAddress keybase1.EmailAddress)

func (*NotifyRouter) HandleEmailAddressVerified

func (n *NotifyRouter) HandleEmailAddressVerified(ctx context.Context, emailAddress keybase1.EmailAddress)

func (*NotifyRouter) HandleFSActivity

func (n *NotifyRouter) HandleFSActivity(activity keybase1.FSNotification)

HandleFSActivity is called for any KBFS notification. It will broadcast the messages to all curious listeners.

func (*NotifyRouter) HandleFSEditListRequest

func (n *NotifyRouter) HandleFSEditListRequest(ctx context.Context, arg keybase1.FSEditListRequest)

HandleFSEditListRequest is called for KBFS edit list request notifications.

func (*NotifyRouter) HandleFSEditListResponse

func (n *NotifyRouter) HandleFSEditListResponse(ctx context.Context, arg keybase1.FSEditListArg)

HandleFSEditListResponse is called for KBFS edit list response notifications.

func (*NotifyRouter) HandleFSFavoritesChanged

func (n *NotifyRouter) HandleFSFavoritesChanged()

HandleFSFavoritesChanged is called when the overall sync status changes. It will broadcast the messages to all curious listeners.

func (*NotifyRouter) HandleFSOnlineStatusChanged

func (n *NotifyRouter) HandleFSOnlineStatusChanged(online bool)

HandleFSOnlineStatusChanged is called when KBFS's online status changes. It will broadcast the messages to all curious listeners.

func (*NotifyRouter) HandleFSOverallSyncStatusChanged

func (n *NotifyRouter) HandleFSOverallSyncStatusChanged(status keybase1.FolderSyncStatus)

HandleFSOverallSyncStatusChanged is called when the overall sync status changes. It will broadcast the messages to all curious listeners.

func (*NotifyRouter) HandleFSPathUpdated

func (n *NotifyRouter) HandleFSPathUpdated(path string)

HandleFSPathUpdated is called for any path update notification. It will broadcast the messages to all curious listeners.

func (*NotifyRouter) HandleFSSubscriptionNotify

func (n *NotifyRouter) HandleFSSubscriptionNotify(arg keybase1.FSSubscriptionNotifyArg)

func (*NotifyRouter) HandleFSSubscriptionNotifyPath

func (n *NotifyRouter) HandleFSSubscriptionNotifyPath(arg keybase1.FSSubscriptionNotifyPathArg)

func (*NotifyRouter) HandleFSSyncEvent

func (n *NotifyRouter) HandleFSSyncEvent(ctx context.Context, arg keybase1.FSPathSyncStatus)

HandleFSSyncEvent is called for KBFS sync event notifications.

func (*NotifyRouter) HandleFSSyncStatus

func (n *NotifyRouter) HandleFSSyncStatus(ctx context.Context, arg keybase1.FSSyncStatusArg)

HandleFSSyncStatus is called for KBFS sync status notifications.

func (*NotifyRouter) HandleFavoritesChanged

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

HandleFavoritesChanged is called whenever the kbfs favorites change for a user (and caches should be invalidated). It will broadcast the messages to all curious listeners.

func (*NotifyRouter) HandleFeaturedBots

func (n *NotifyRouter) HandleFeaturedBots(ctx context.Context, bots []keybase1.FeaturedBot, limit, offset int)

func (*NotifyRouter) HandleHTTPSrvInfoUpdate

func (n *NotifyRouter) HandleHTTPSrvInfoUpdate(ctx context.Context, info keybase1.HttpSrvInfo)
func (n *NotifyRouter) HandleHandleKeybaseLink(ctx context.Context, link string, deferred bool)

func (*NotifyRouter) HandleIdentifyUpdate

func (n *NotifyRouter) HandleIdentifyUpdate(ctx context.Context, okUsernames []string, brokenUsernames []string)

func (*NotifyRouter) HandleKeyfamilyChanged

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

HandleKeyfamilyChanged is called whenever a user's keyfamily changes.

func (*NotifyRouter) HandleLogin

func (n *NotifyRouter) HandleLogin(ctx context.Context, u string)

HandleLogin is called when a user logs in.

func (*NotifyRouter) HandleLogout

func (n *NotifyRouter) HandleLogout(ctx context.Context)

HandleLogout is called whenever the current user logged out. It will broadcast the message to all connections who care about such a message.

func (*NotifyRouter) HandleNewChatActivity

func (n *NotifyRouter) HandleNewChatActivity(ctx context.Context, uid keybase1.UID,
	topicType chat1.TopicType, activity *chat1.ChatActivity, source chat1.ChatActivitySource, canSkip bool)

func (*NotifyRouter) HandleNewTeamEK

func (n *NotifyRouter) HandleNewTeamEK(ctx context.Context, teamID keybase1.TeamID,
	generation keybase1.EkGeneration)

func (*NotifyRouter) HandleNewTeambotEK

func (n *NotifyRouter) HandleNewTeambotEK(ctx context.Context, teamID keybase1.TeamID,
	generation keybase1.EkGeneration)

func (*NotifyRouter) HandleNewTeambotKey

func (n *NotifyRouter) HandleNewTeambotKey(ctx context.Context, teamID keybase1.TeamID,
	app keybase1.TeamApplication, generation keybase1.TeambotKeyGeneration)

func (*NotifyRouter) HandleNewlyAddedToTeam

func (n *NotifyRouter) HandleNewlyAddedToTeam(ctx context.Context, teamID keybase1.TeamID)

func (*NotifyRouter) HandlePGPKeyInSecretStoreFile

func (n *NotifyRouter) HandlePGPKeyInSecretStoreFile()

HandlePGPKeyInSecretStoreFile is called to notify a user that they have a PGP key that is unlockable by a secret stored in a file in their home directory.

func (*NotifyRouter) HandlePaperKeyCached

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

HandlePaperKeyCached is called whenever a paper key is cached in response to a rekey harassment.

func (*NotifyRouter) HandlePasswordChanged

func (n *NotifyRouter) HandlePasswordChanged(ctx context.Context, passphraseState keybase1.PassphraseState)

func (*NotifyRouter) HandlePhoneNumbersChanged

func (n *NotifyRouter) HandlePhoneNumbersChanged(ctx context.Context, list []keybase1.UserPhoneNumber, category string, phoneNumber keybase1.PhoneNumber)

func (*NotifyRouter) HandleReachability

func (n *NotifyRouter) HandleReachability(r keybase1.Reachability)

func (*NotifyRouter) HandleRootAuditError

func (n *NotifyRouter) HandleRootAuditError(msg string)

RootAuditError is called when the merkle root auditor finds an invalid skip sequence in a random old block.

func (*NotifyRouter) HandleRuntimeStatsUpdate

func (n *NotifyRouter) HandleRuntimeStatsUpdate(ctx context.Context, stats *keybase1.RuntimeStats)

func (*NotifyRouter) HandleSaltpackOperationDone

func (n *NotifyRouter) HandleSaltpackOperationDone(ctx context.Context, opType keybase1.SaltpackOperationType, filename string)

func (*NotifyRouter) HandleSaltpackOperationProgress

func (n *NotifyRouter) HandleSaltpackOperationProgress(ctx context.Context, opType keybase1.SaltpackOperationType, filename string, bytesComplete, bytesTotal int64)

func (*NotifyRouter) HandleSaltpackOperationStart

func (n *NotifyRouter) HandleSaltpackOperationStart(ctx context.Context, opType keybase1.SaltpackOperationType, filename string)

func (*NotifyRouter) HandleServiceShutdown

func (n *NotifyRouter) HandleServiceShutdown()

HandleServiceShutdown is called whenever the service shuts down.

func (*NotifyRouter) HandleSignup

func (n *NotifyRouter) HandleSignup(ctx context.Context, u string)

HandleSignup is called when a user is signed up. It will broadcast a loggedIn notification with a flag to signify this was because of a signup.

func (*NotifyRouter) HandleTeamAbandoned

func (n *NotifyRouter) HandleTeamAbandoned(ctx context.Context, teamID keybase1.TeamID)

func (*NotifyRouter) HandleTeamChangedByBothKeys

func (n *NotifyRouter) HandleTeamChangedByBothKeys(ctx context.Context,
	teamID keybase1.TeamID, teamName string, latestSeqno keybase1.Seqno, implicitTeam bool, changes keybase1.TeamChangeSet,
	latestHiddenSeqno keybase1.Seqno, latestOffchainSeqno keybase1.Seqno, source keybase1.TeamChangedSource)

teamID and teamName are not necessarily the same team

func (*NotifyRouter) HandleTeamChangedByID

func (n *NotifyRouter) HandleTeamChangedByID(ctx context.Context,
	teamID keybase1.TeamID, latestSeqno keybase1.Seqno, implicitTeam bool, changes keybase1.TeamChangeSet,
	latestHiddenSeqno keybase1.Seqno, latestOffchainSeqno keybase1.Seqno, source keybase1.TeamChangedSource)

func (*NotifyRouter) HandleTeamChangedByName

func (n *NotifyRouter) HandleTeamChangedByName(ctx context.Context,
	teamName string, latestSeqno keybase1.Seqno, implicitTeam bool, changes keybase1.TeamChangeSet,
	latestHiddenSeqno keybase1.Seqno, latestOffchainSeqno keybase1.Seqno, source keybase1.TeamChangedSource)

func (*NotifyRouter) HandleTeamDeleted

func (n *NotifyRouter) HandleTeamDeleted(ctx context.Context, teamID keybase1.TeamID)

func (*NotifyRouter) HandleTeamExit

func (n *NotifyRouter) HandleTeamExit(ctx context.Context, teamID keybase1.TeamID)

func (*NotifyRouter) HandleTeamMetadataUpdate

func (n *NotifyRouter) HandleTeamMetadataUpdate(ctx context.Context)

TeamMetadataUpdateUnverified is called when a notification is received that affects the teams tab root page.

func (*NotifyRouter) HandleTeamRoleMapChanged

func (n *NotifyRouter) HandleTeamRoleMapChanged(ctx context.Context, version keybase1.UserTeamVersion)

func (*NotifyRouter) HandleTeamTreeMembershipsDone

func (n *NotifyRouter) HandleTeamTreeMembershipsDone(ctx context.Context, result keybase1.TeamTreeMembershipsDoneResult)

func (*NotifyRouter) HandleTeamTreeMembershipsPartial

func (n *NotifyRouter) HandleTeamTreeMembershipsPartial(ctx context.Context,
	result keybase1.TeamTreeMembership)

func (*NotifyRouter) HandleTeambotEKNeeded

func (n *NotifyRouter) HandleTeambotEKNeeded(ctx context.Context, teamID keybase1.TeamID,
	botUID keybase1.UID, generation keybase1.EkGeneration, forceCreateGen *keybase1.EkGeneration)

func (*NotifyRouter) HandleTeambotKeyNeeded

func (n *NotifyRouter) HandleTeambotKeyNeeded(ctx context.Context, teamID keybase1.TeamID,
	botUID keybase1.UID, app keybase1.TeamApplication, generation keybase1.TeambotKeyGeneration)

func (*NotifyRouter) HandleTrackingChanged

func (n *NotifyRouter) HandleTrackingChanged(uid keybase1.UID, username NormalizedUsername, isTracking bool)

HandleTrackingChanged is called whenever we have a new tracking or untracking chain link related to a given user. It will broadcast the messages to all curious listeners. isTracking is set to true if current user is tracking uid.

func (*NotifyRouter) HandleTrackingInfo

func (n *NotifyRouter) HandleTrackingInfo(arg keybase1.TrackingInfoArg)

func (*NotifyRouter) HandleUpdateInviteCounts

func (n *NotifyRouter) HandleUpdateInviteCounts(ctx context.Context, counts keybase1.InviteCounts)

func (*NotifyRouter) HandleUserBlocked

func (n *NotifyRouter) HandleUserBlocked(ctx context.Context, b keybase1.UserBlockedBody)

func (*NotifyRouter) HandleUserChanged

func (n *NotifyRouter) HandleUserChanged(mctx MetaContext, uid keybase1.UID, reason string)

HandleUserChanged is called whenever we know that a given user has changed (and must be cache-busted). It will broadcast the messages to all curious listeners. NOTE: we now only do this for the current logged in user

func (*NotifyRouter) HandleWalletAccountDetailsUpdate

func (n *NotifyRouter) HandleWalletAccountDetailsUpdate(ctx context.Context, accountID stellar1.AccountID, account stellar1.WalletAccountLocal)

func (*NotifyRouter) HandleWalletAccountsUpdate

func (n *NotifyRouter) HandleWalletAccountsUpdate(ctx context.Context, accounts []stellar1.WalletAccountLocal)

func (*NotifyRouter) HandleWalletPaymentNotification

func (n *NotifyRouter) HandleWalletPaymentNotification(ctx context.Context, accountID stellar1.AccountID, paymentID stellar1.PaymentID)

func (*NotifyRouter) HandleWalletPaymentStatusNotification

func (n *NotifyRouter) HandleWalletPaymentStatusNotification(ctx context.Context, accountID stellar1.AccountID, paymentID stellar1.PaymentID)

func (*NotifyRouter) HandleWalletPendingPaymentsUpdate

func (n *NotifyRouter) HandleWalletPendingPaymentsUpdate(ctx context.Context, accountID stellar1.AccountID, pending []stellar1.PaymentOrErrorLocal)

func (*NotifyRouter) HandleWalletRecentPaymentsUpdate

func (n *NotifyRouter) HandleWalletRecentPaymentsUpdate(ctx context.Context, accountID stellar1.AccountID, firstPage stellar1.PaymentsPageLocal)

func (*NotifyRouter) HandleWalletRequestStatusNotification

func (n *NotifyRouter) HandleWalletRequestStatusNotification(ctx context.Context, reqID stellar1.KeybaseRequestID)

func (*NotifyRouter) HandleWebOfTrustChanged

func (n *NotifyRouter) HandleWebOfTrustChanged(username string)

func (*NotifyRouter) RemoveListener

func (n *NotifyRouter) RemoveListener(id NotifyListenerID)

func (*NotifyRouter) SendLogin

func (n *NotifyRouter) SendLogin(ctx context.Context, u string, signedUp bool)

SendLogin is called whenever a user logs in. It will broadcast the message to all connections who care about such a message.

func (*NotifyRouter) SetChannels

SetChannels sets which notification channels are interested for the connection with the given connection ID.

func (*NotifyRouter) Shutdown

func (n *NotifyRouter) Shutdown()

type NullConfiguration

type NullConfiguration struct{}

func (NullConfiguration) GetAPIDump

func (n NullConfiguration) GetAPIDump() (bool, bool)

func (NullConfiguration) GetAPITimeout

func (n NullConfiguration) GetAPITimeout() (time.Duration, bool)

func (NullConfiguration) GetAllUserConfigs

func (n NullConfiguration) GetAllUserConfigs() (*UserConfig, []UserConfig, error)

func (NullConfiguration) GetAllUsernames

func (NullConfiguration) GetAndroidInstallReferrerChecked

func (n NullConfiguration) GetAndroidInstallReferrerChecked() bool

func (NullConfiguration) GetAppType

func (n NullConfiguration) GetAppType() AppType

func (NullConfiguration) GetAttachmentDisableMulti

func (n NullConfiguration) GetAttachmentDisableMulti() (bool, bool)

func (NullConfiguration) GetAttachmentHTTPStartPort

func (n NullConfiguration) GetAttachmentHTTPStartPort() (int, bool)

func (NullConfiguration) GetAutoFork

func (n NullConfiguration) GetAutoFork() (bool, bool)

func (NullConfiguration) GetBGIdentifierDisabled

func (n NullConfiguration) GetBGIdentifierDisabled() (bool, bool)

func (NullConfiguration) GetBool

func (n NullConfiguration) GetBool(string, bool) (bool, bool)

func (NullConfiguration) GetBoolAtPath

func (n NullConfiguration) GetBoolAtPath(string) (bool, bool)

func (NullConfiguration) GetBug3964RepairTime

func (n NullConfiguration) GetBug3964RepairTime(NormalizedUsername) (time.Time, error)

func (NullConfiguration) GetBundledCA

func (n NullConfiguration) GetBundledCA(h string) string

func (NullConfiguration) GetChatDbFilename

func (n NullConfiguration) GetChatDbFilename() string

func (NullConfiguration) GetChatDelivererInterval

func (n NullConfiguration) GetChatDelivererInterval() (time.Duration, bool)

func (NullConfiguration) GetChatInboxSourceLocalizeThreads

func (n NullConfiguration) GetChatInboxSourceLocalizeThreads() (int, bool)

func (NullConfiguration) GetCodeSigningKIDs

func (n NullConfiguration) GetCodeSigningKIDs() []string

func (NullConfiguration) GetConfigFilename

func (n NullConfiguration) GetConfigFilename() string

func (NullConfiguration) GetDbFilename

func (n NullConfiguration) GetDbFilename() string

func (NullConfiguration) GetDebug

func (n NullConfiguration) GetDebug() (bool, bool)

func (NullConfiguration) GetDebugJourneycard

func (n NullConfiguration) GetDebugJourneycard() (bool, bool)

func (NullConfiguration) GetDeviceCloneStateFilename

func (n NullConfiguration) GetDeviceCloneStateFilename() string

func (NullConfiguration) GetDeviceID

func (n NullConfiguration) GetDeviceID() keybase1.DeviceID

func (NullConfiguration) GetDeviceIDForUID

func (n NullConfiguration) GetDeviceIDForUID(u keybase1.UID) keybase1.DeviceID

func (NullConfiguration) GetDeviceIDForUsername

func (n NullConfiguration) GetDeviceIDForUsername(un NormalizedUsername) keybase1.DeviceID

func (NullConfiguration) GetDisableBgConvLoader

func (n NullConfiguration) GetDisableBgConvLoader() (bool, bool)

func (NullConfiguration) GetDisableEKBackgroundKeygen

func (n NullConfiguration) GetDisableEKBackgroundKeygen() (bool, bool)

func (NullConfiguration) GetDisableMerkleAuditor

func (n NullConfiguration) GetDisableMerkleAuditor() (bool, bool)

func (NullConfiguration) GetDisableSearchIndexer

func (n NullConfiguration) GetDisableSearchIndexer() (bool, bool)

func (NullConfiguration) GetDisableTeamAuditor

func (n NullConfiguration) GetDisableTeamAuditor() (bool, bool)

func (NullConfiguration) GetDisableTeamBoxAuditor

func (n NullConfiguration) GetDisableTeamBoxAuditor() (bool, bool)

func (NullConfiguration) GetDisplayRawUntrustedOutput

func (n NullConfiguration) GetDisplayRawUntrustedOutput() (bool, bool)

func (NullConfiguration) GetEKLogFile

func (n NullConfiguration) GetEKLogFile() string

func (NullConfiguration) GetEmail

func (n NullConfiguration) GetEmail() string

func (NullConfiguration) GetEnableBotLiteMode

func (n NullConfiguration) GetEnableBotLiteMode() (bool, bool)

func (NullConfiguration) GetExternalURLKitFilename

func (n NullConfiguration) GetExternalURLKitFilename() string

func (NullConfiguration) GetExtraNetLogging

func (n NullConfiguration) GetExtraNetLogging() (bool, bool)

func (NullConfiguration) GetFeatureFlags

func (n NullConfiguration) GetFeatureFlags() (FeatureFlags, error)

func (NullConfiguration) GetFloatAtPath

func (n NullConfiguration) GetFloatAtPath(string) (float64, bool)

func (NullConfiguration) GetForceLinuxKeyring

func (n NullConfiguration) GetForceLinuxKeyring() (bool, bool)

func (NullConfiguration) GetForceSecretStoreFile

func (n NullConfiguration) GetForceSecretStoreFile() (bool, bool)

func (NullConfiguration) GetGString

func (n NullConfiguration) GetGString(string) string

func (NullConfiguration) GetGUIConfigFilename

func (n NullConfiguration) GetGUIConfigFilename() string

func (NullConfiguration) GetGUILogFile

func (n NullConfiguration) GetGUILogFile() string

func (NullConfiguration) GetGpg

func (n NullConfiguration) GetGpg() string

func (NullConfiguration) GetGpgHome

func (n NullConfiguration) GetGpgHome() string

func (NullConfiguration) GetGpgOptions

func (n NullConfiguration) GetGpgOptions() []string

func (NullConfiguration) GetGregorDisabled

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

func (NullConfiguration) GetGregorPingInterval

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

func (NullConfiguration) GetGregorPingTimeout

func (n NullConfiguration) GetGregorPingTimeout() (time.Duration, bool)

func (NullConfiguration) GetGregorSaveInterval

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

func (NullConfiguration) GetGregorURI

func (n NullConfiguration) GetGregorURI() string

func (NullConfiguration) GetHome

func (n NullConfiguration) GetHome() string

func (NullConfiguration) GetIntAtPath

func (n NullConfiguration) GetIntAtPath(string) (int, bool)

func (NullConfiguration) GetInterfaceAtPath

func (n NullConfiguration) GetInterfaceAtPath(string) (interface{}, error)

func (NullConfiguration) GetLevelDBNumFiles

func (n NullConfiguration) GetLevelDBNumFiles() (int, bool)

func (NullConfiguration) GetLevelDBWriteBufferMB

func (n NullConfiguration) GetLevelDBWriteBufferMB() (int, bool)

func (NullConfiguration) GetLinkCacheCleanDur

func (n NullConfiguration) GetLinkCacheCleanDur() (time.Duration, bool)

func (NullConfiguration) GetLinkCacheSize

func (n NullConfiguration) GetLinkCacheSize() (int, bool)

func (NullConfiguration) GetLocalRPCDebug

func (n NullConfiguration) GetLocalRPCDebug() string

func (NullConfiguration) GetLocalTrackMaxAge

func (n NullConfiguration) GetLocalTrackMaxAge() (time.Duration, bool)

func (NullConfiguration) GetLogFile

func (n NullConfiguration) GetLogFile() string

func (NullConfiguration) GetLogFormat

func (n NullConfiguration) GetLogFormat() string

func (NullConfiguration) GetLogPrefix

func (n NullConfiguration) GetLogPrefix() string

func (NullConfiguration) GetMerkleKIDs

func (n NullConfiguration) GetMerkleKIDs() []string

func (NullConfiguration) GetMobileSharedHome

func (n NullConfiguration) GetMobileSharedHome() string

func (NullConfiguration) GetMountDir

func (n NullConfiguration) GetMountDir() string

func (NullConfiguration) GetMountDirDefault

func (n NullConfiguration) GetMountDirDefault() string

func (NullConfiguration) GetNoAutoFork

func (n NullConfiguration) GetNoAutoFork() (bool, bool)

func (NullConfiguration) GetNoPinentry

func (n NullConfiguration) GetNoPinentry() (bool, bool)

func (NullConfiguration) GetNullAtPath

func (n NullConfiguration) GetNullAtPath(string) bool

func (NullConfiguration) GetPGPFingerprint

func (n NullConfiguration) GetPGPFingerprint() *PGPFingerprint

func (NullConfiguration) GetParamProofKitFilename

func (n NullConfiguration) GetParamProofKitFilename() string

func (NullConfiguration) GetPassphraseState

func (n NullConfiguration) GetPassphraseState() *keybase1.PassphraseState

func (NullConfiguration) GetPassphraseStateForUsername

func (n NullConfiguration) GetPassphraseStateForUsername(NormalizedUsername) *keybase1.PassphraseState

func (NullConfiguration) GetPayloadCacheSize

func (n NullConfiguration) GetPayloadCacheSize() (int, bool)

func (NullConfiguration) GetPerfLogFile

func (n NullConfiguration) GetPerfLogFile() string

func (NullConfiguration) GetPidFile

func (n NullConfiguration) GetPidFile() string

func (NullConfiguration) GetPinentry

func (n NullConfiguration) GetPinentry() string

func (NullConfiguration) GetProofCacheLongDur

func (n NullConfiguration) GetProofCacheLongDur() (time.Duration, bool)

func (NullConfiguration) GetProofCacheMediumDur

func (n NullConfiguration) GetProofCacheMediumDur() (time.Duration, bool)

func (NullConfiguration) GetProofCacheShortDur

func (n NullConfiguration) GetProofCacheShortDur() (time.Duration, bool)

func (NullConfiguration) GetProofCacheSize

func (n NullConfiguration) GetProofCacheSize() (int, bool)

func (NullConfiguration) GetProveBypass

func (n NullConfiguration) GetProveBypass() (bool, bool)

func (NullConfiguration) GetProxy

func (n NullConfiguration) GetProxy() string

func (NullConfiguration) GetProxyCACerts

func (n NullConfiguration) GetProxyCACerts() ([]string, error)

func (NullConfiguration) GetProxyType

func (n NullConfiguration) GetProxyType() string

func (NullConfiguration) GetPvlKitFilename

func (n NullConfiguration) GetPvlKitFilename() string

func (NullConfiguration) GetReadDeletedSigChain

func (n NullConfiguration) GetReadDeletedSigChain() (bool, bool)

func (NullConfiguration) GetRememberPassphrase

func (n NullConfiguration) GetRememberPassphrase(NormalizedUsername) (bool, bool)

func (NullConfiguration) GetRunMode

func (n NullConfiguration) GetRunMode() (RunMode, error)

func (NullConfiguration) GetRuntimeStatsEnabled

func (n NullConfiguration) GetRuntimeStatsEnabled() (bool, bool)

func (NullConfiguration) GetSalt

func (n NullConfiguration) GetSalt() []byte

func (NullConfiguration) GetScraperTimeout

func (n NullConfiguration) GetScraperTimeout() (time.Duration, bool)

func (NullConfiguration) GetSecretKeyringTemplate

func (n NullConfiguration) GetSecretKeyringTemplate() string

func (NullConfiguration) GetSecretStorePrimingDisabled

func (n NullConfiguration) GetSecretStorePrimingDisabled() (bool, bool)

func (NullConfiguration) GetSecurityAccessGroupOverride

func (n NullConfiguration) GetSecurityAccessGroupOverride() (bool, bool)

func (NullConfiguration) GetServerURI

func (n NullConfiguration) GetServerURI() (string, error)

func (NullConfiguration) GetSessionFilename

func (n NullConfiguration) GetSessionFilename() string

func (NullConfiguration) GetSlowGregorConn

func (n NullConfiguration) GetSlowGregorConn() (bool, bool)

func (NullConfiguration) GetSocketFile

func (n NullConfiguration) GetSocketFile() string

func (NullConfiguration) GetStandalone

func (n NullConfiguration) GetStandalone() (bool, bool)

func (NullConfiguration) GetStayLoggedOut

func (n NullConfiguration) GetStayLoggedOut() (bool, bool)

func (NullConfiguration) GetString

func (n NullConfiguration) GetString(string) string

func (NullConfiguration) GetStringAtPath

func (n NullConfiguration) GetStringAtPath(string) (string, bool)

func (NullConfiguration) GetTimers

func (n NullConfiguration) GetTimers() string

func (NullConfiguration) GetTorHiddenAddress

func (n NullConfiguration) GetTorHiddenAddress() string

func (NullConfiguration) GetTorMode

func (n NullConfiguration) GetTorMode() (TorMode, error)

func (NullConfiguration) GetTorProxy

func (n NullConfiguration) GetTorProxy() string

func (NullConfiguration) GetUID

func (n NullConfiguration) GetUID() (ret keybase1.UID)

func (NullConfiguration) GetUIDForUsername

func (n NullConfiguration) GetUIDForUsername(u NormalizedUsername) keybase1.UID

func (NullConfiguration) GetUIDMapFullNameCacheSize

func (n NullConfiguration) GetUIDMapFullNameCacheSize() (int, bool)

func (NullConfiguration) GetUPAKCacheSize

func (n NullConfiguration) GetUPAKCacheSize() (int, bool)

func (NullConfiguration) GetUpdateDisabled

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

func (NullConfiguration) GetUpdateLastChecked

func (n NullConfiguration) GetUpdateLastChecked() keybase1.Time

func (NullConfiguration) GetUpdatePreferenceAuto

func (n NullConfiguration) GetUpdatePreferenceAuto() (bool, bool)

func (NullConfiguration) GetUpdatePreferenceSkip

func (n NullConfiguration) GetUpdatePreferenceSkip() string

func (NullConfiguration) GetUpdatePreferenceSnoozeUntil

func (n NullConfiguration) GetUpdatePreferenceSnoozeUntil() keybase1.Time

func (NullConfiguration) GetUpdateURL

func (n NullConfiguration) GetUpdateURL() string

func (NullConfiguration) GetUpdaterConfigFilename

func (n NullConfiguration) GetUpdaterConfigFilename() string

func (NullConfiguration) GetUseDefaultLogFile

func (n NullConfiguration) GetUseDefaultLogFile() (bool, bool)

func (NullConfiguration) GetUseRootConfigFile

func (n NullConfiguration) GetUseRootConfigFile() (bool, bool)

func (NullConfiguration) GetUserCacheMaxAge

func (n NullConfiguration) GetUserCacheMaxAge() (time.Duration, bool)

func (NullConfiguration) GetUserConfig

func (n NullConfiguration) GetUserConfig() (*UserConfig, error)

func (NullConfiguration) GetUserConfigForUsername

func (n NullConfiguration) GetUserConfigForUsername(s NormalizedUsername) (*UserConfig, error)

func (NullConfiguration) GetUsername

func (n NullConfiguration) GetUsername() NormalizedUsername

func (NullConfiguration) GetUsernameForUID

func (n NullConfiguration) GetUsernameForUID(u keybase1.UID) NormalizedUsername

func (NullConfiguration) GetVDebugSetting

func (n NullConfiguration) GetVDebugSetting() string

func (NullConfiguration) IsCertPinningEnabled

func (n NullConfiguration) IsCertPinningEnabled() bool

func (NullConfiguration) IsMobileExtension

func (n NullConfiguration) IsMobileExtension() (bool, bool)

type NullConnectivityMonitor

type NullConnectivityMonitor struct {
}

func (NullConnectivityMonitor) CheckReachability

func (s NullConnectivityMonitor) CheckReachability(ctx context.Context) error

func (NullConnectivityMonitor) IsConnected

type NullMockAPI

type NullMockAPI struct{}

func (*NullMockAPI) Delete

func (n *NullMockAPI) Delete(MetaContext, APIArg) (*APIRes, error)

func (*NullMockAPI) Get

func (n *NullMockAPI) Get(MetaContext, APIArg) (*APIRes, error)

func (*NullMockAPI) GetDecode

func (*NullMockAPI) GetDecodeCtx

func (*NullMockAPI) GetResp

func (n *NullMockAPI) GetResp(MetaContext, APIArg) (*http.Response, func(), error)

func (*NullMockAPI) Post

func (n *NullMockAPI) Post(MetaContext, APIArg) (*APIRes, error)

func (*NullMockAPI) PostDecode

func (*NullMockAPI) PostDecodeCtx

func (*NullMockAPI) PostJSON

func (n *NullMockAPI) PostJSON(MetaContext, APIArg) (*APIRes, error)

func (*NullMockAPI) PostRaw

type ObjType

type ObjType byte

type OfflineError

type OfflineError struct {
}

func (OfflineError) Error

func (e OfflineError) Error() string

func (OfflineError) ToStatus

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

type OuterLinkV2

type OuterLinkV2 struct {
	Version  SigVersion     `codec:"version"`
	Seqno    keybase1.Seqno `codec:"seqno"`
	Prev     LinkID         `codec:"prev"`
	Curr     LinkID         `codec:"curr"`
	LinkType SigchainV2Type `codec:"type"`
	// -- Links exist in the wild that are missing fields below this line (see Partial0)
	SeqType keybase1.SeqType `codec:"seqtype"`
	// -- Links exist in the wild that are missing fields below this line too (see Partial1)
	// Whether the link can be ignored by clients that do not support its link type.
	// This does _not_ mean the link can be ignored if the client supports the link type.
	// When it comes to stubbing, if the link is unsupported and this bit is set then
	// - it can be stubbed for non-admins
	// - it cannot be stubbed for admins
	IgnoreIfUnsupported SigIgnoreIfUnsupported `codec:"ignore_if_unsupported"`
	// -- Links exist in the wild that are missing fields below this line too (see Partial2)
	// If not provided, both of these are nil, and highSkip in the inner link is set to nil.
	// Note that a link providing HighSkipSeqno == 0 and HighSkipHash == nil is valid
	// (and mandatory) for an initial link.
	HighSkipSeqno *keybase1.Seqno `codec:"high_skip_seqno"`
	HighSkipHash  *LinkID         `codec:"high_skip_hash"`
	// contains filtered or unexported fields
}

OuterLinkV2 is the second version of Keybase sigchain signatures.

func (OuterLinkV2) AssertFields

func (o OuterLinkV2) AssertFields(
	version SigVersion,
	seqno keybase1.Seqno,
	prev LinkID,
	curr LinkID,
	linkType SigchainV2Type,
	seqType keybase1.SeqType,
	ignoreIfUnsupported SigIgnoreIfUnsupported,
	highSkip *HighSkip,
) (err error)

func (OuterLinkV2) AssertSomeFields

func (o OuterLinkV2) AssertSomeFields(
	version SigVersion,
	seqno keybase1.Seqno,
) (err error)

func (OuterLinkV2) Encode

func (o OuterLinkV2) Encode() ([]byte, error)

func (OuterLinkV2) EncodePartial

func (o OuterLinkV2) EncodePartial(numFields int) ([]byte, error)

func (OuterLinkV2) EncodeTruncateHighSkips

func (o OuterLinkV2) EncodeTruncateHighSkips() ([]byte, error)

type OuterLinkV2Partial0

type OuterLinkV2Partial0 struct {
	Version  SigVersion     `codec:"version"`
	Seqno    keybase1.Seqno `codec:"seqno"`
	Prev     LinkID         `codec:"prev"`
	Curr     LinkID         `codec:"curr"`
	LinkType SigchainV2Type `codec:"type"`
	// contains filtered or unexported fields
}

type OuterLinkV2Partial1

type OuterLinkV2Partial1 struct {
	Version  SigVersion       `codec:"version"`
	Seqno    keybase1.Seqno   `codec:"seqno"`
	Prev     LinkID           `codec:"prev"`
	Curr     LinkID           `codec:"curr"`
	LinkType SigchainV2Type   `codec:"type"`
	SeqType  keybase1.SeqType `codec:"seqtype"`
	// contains filtered or unexported fields
}

type OuterLinkV2Partial2

type OuterLinkV2Partial2 struct {
	Version             SigVersion             `codec:"version"`
	Seqno               keybase1.Seqno         `codec:"seqno"`
	Prev                LinkID                 `codec:"prev"`
	Curr                LinkID                 `codec:"curr"`
	LinkType            SigchainV2Type         `codec:"type"`
	SeqType             keybase1.SeqType       `codec:"seqtype"`
	IgnoreIfUnsupported SigIgnoreIfUnsupported `codec:"ignore_if_unsupported"`
	// contains filtered or unexported fields
}

type OuterLinkV2WithMetadata

type OuterLinkV2WithMetadata struct {
	OuterLinkV2
	// contains filtered or unexported fields
}

func DecodeOuterLinkV2

func DecodeOuterLinkV2(armored string) (*OuterLinkV2WithMetadata, error)

func DecodeStubbedOuterLinkV2

func DecodeStubbedOuterLinkV2(b64encoded string) (*OuterLinkV2WithMetadata, error)

func (*OuterLinkV2WithMetadata) CodecDecodeSelf

func (o *OuterLinkV2WithMetadata) CodecDecodeSelf(d *codec.Decoder)

func (*OuterLinkV2WithMetadata) CodecEncodeSelf

func (o *OuterLinkV2WithMetadata) CodecEncodeSelf(e *codec.Encoder)

func (OuterLinkV2WithMetadata) EncodeStubbed

func (o OuterLinkV2WithMetadata) EncodeStubbed() string

func (OuterLinkV2WithMetadata) LinkID

func (o OuterLinkV2WithMetadata) LinkID() LinkID

func (OuterLinkV2WithMetadata) Raw

func (o OuterLinkV2WithMetadata) Raw() []byte

func (OuterLinkV2WithMetadata) SigID

func (OuterLinkV2WithMetadata) Verify

func (o OuterLinkV2WithMetadata) Verify(ctx VerifyContext) (kid keybase1.KID, err error)

type OutputDescriptor

type OutputDescriptor int

type PDPKA

type PDPKA string

PDPKA is a "Passphrase-Derived Public Key Authentication". In this case, it's a armored, packed, signature that's been output by our signing interface.

func (PDPKA) String

func (p PDPKA) String() string

type PDPKALoginPackage

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

PDPKALoginPackage contains all relevant PDPKA versions in use at this time. For now, versions 4 and 5.

func ComputeLoginPackage2

func ComputeLoginPackage2(m MetaContext, pps *PassphraseStream) (ret PDPKALoginPackage, err error)

ComputeLoginPackage2 computes the login package for the given UID as dictated by the context. It assumes that a passphrase stream has already been loaded. A LoginSession is optional. If not available, a new one is requested. Eventually we will kill ComputeLoginPackage and rename this to that.

func (PDPKALoginPackage) PDPKA4

func (lp PDPKALoginPackage) PDPKA4() PDPKA

PDPKA4 gets the v4 of the PDPKA token for this login package

func (PDPKALoginPackage) PDPKA5

func (lp PDPKALoginPackage) PDPKA5() PDPKA

PDPKA5 gets the v4 of the PDPKA token for this login package

func (PDPKALoginPackage) PopulateArgs

func (lp PDPKALoginPackage) PopulateArgs(h *HTTPArgs)

PopulateArgs populates the given HTTP args with parameters in this PDPKA package. Right now that includes v4 and v5 of the PDPKA login system.

type PGPFingerprint

type PGPFingerprint [PGPFingerprintLen]byte

func GetPGPFingerprint

func GetPGPFingerprint(w *jsonw.Wrapper) (*PGPFingerprint, error)

func GetPGPFingerprintFromGenericKey

func GetPGPFingerprintFromGenericKey(k GenericKey) *PGPFingerprint

func ImportPGPFingerprint

func ImportPGPFingerprint(f keybase1.PGPFingerprint) PGPFingerprint

func ImportPGPFingerprintSlice

func ImportPGPFingerprintSlice(fp []byte) (ret *PGPFingerprint)

func PGPFingerprintFromHex

func PGPFingerprintFromHex(s string) (*PGPFingerprint, error)

func PGPFingerprintFromHexNoError

func PGPFingerprintFromHexNoError(s string) *PGPFingerprint

func PGPFingerprintFromSlice

func PGPFingerprintFromSlice(b []byte) (*PGPFingerprint, error)

func (PGPFingerprint) Eq

func (PGPFingerprint) GetProofState

func (p PGPFingerprint) GetProofState() keybase1.ProofState

func (PGPFingerprint) GetProofType

func (p PGPFingerprint) GetProofType() keybase1.ProofType

func (PGPFingerprint) LastWriterWins

func (p PGPFingerprint) LastWriterWins() bool

func (*PGPFingerprint) MarshalJSON

func (p *PGPFingerprint) MarshalJSON() ([]byte, error)

func (*PGPFingerprint) Match

func (p *PGPFingerprint) Match(q string, exact bool) bool

func (PGPFingerprint) String

func (p PGPFingerprint) String() string

func (PGPFingerprint) ToDisplayString

func (p PGPFingerprint) ToDisplayString(verbose bool) string

func (PGPFingerprint) ToIDString

func (p PGPFingerprint) ToIDString() string

func (PGPFingerprint) ToKeyID

func (p PGPFingerprint) ToKeyID() string

func (PGPFingerprint) ToKeyValuePair

func (p PGPFingerprint) ToKeyValuePair() (string, string)

func (PGPFingerprint) ToQuads

func (p PGPFingerprint) ToQuads() string

func (*PGPFingerprint) UnmarshalJSON

func (p *PGPFingerprint) UnmarshalJSON(b []byte) error

type PGPGenArg

type PGPGenArg struct {
	PrimaryBits     int
	SubkeyBits      int
	Ids             Identities
	Config          *packet.Config
	PGPUids         []string
	PrimaryLifetime int
	SubkeyLifetime  int
}

func ImportKeyGenArg

func ImportKeyGenArg(a keybase1.PGPKeyGenArg) (ret PGPGenArg)

func (*PGPGenArg) AddDefaultUID

func (a *PGPGenArg) AddDefaultUID(g *GlobalContext)

Just for testing

func (*PGPGenArg) CreatePGPIDs

func (a *PGPGenArg) CreatePGPIDs() error

CreateIDs creates identities for KeyGenArg.Ids if none exist. It uses PGPUids to determine the set of Ids. It does not set the default keybase.io uid. AddDefaultUid() does that.

func (PGPGenArg) ExportTo

func (a PGPGenArg) ExportTo(ret *keybase1.PGPKeyGenArg)

func (*PGPGenArg) Init

func (a *PGPGenArg) Init() (err error)

func (*PGPGenArg) MakeAllIds

func (a *PGPGenArg) MakeAllIds(g *GlobalContext) error

Just for testing

func (*PGPGenArg) PGPUserIDs

func (a *PGPGenArg) PGPUserIDs() ([]*packet.UserId, error)

func (*PGPGenArg) PreferredCompression

func (a *PGPGenArg) PreferredCompression() []uint8

func (*PGPGenArg) PreferredHash

func (a *PGPGenArg) PreferredHash() []uint8

func (*PGPGenArg) PreferredSymmetric

func (a *PGPGenArg) PreferredSymmetric() []uint8

type PGPKeyBundle

type PGPKeyBundle struct {
	*openpgp.Entity

	// GPGFallbackKey to be used as a fallback if given dummy a PrivateKey.
	GPGFallbackKey GenericKey

	// We make the (fairly dangerous) assumption that the key will never be
	// modified. This avoids the issue that encoding an openpgp.Entity is
	// nondeterministic due to Go's randomized iteration order (so different
	// exports of the same key may hash differently).
	//
	// If you're *sure* that you're creating a PGPKeyBundle from an armored
	// *public* key, you can prefill this field and Export() will use it.
	ArmoredPublicKey string

	// True if this key was generated by this program
	Generated bool
}

func GeneratePGPKeyBundle

func GeneratePGPKeyBundle(g *GlobalContext, arg PGPGenArg, logUI LogUI) (*PGPKeyBundle, error)

NewEntity returns an Entity that contains a fresh RSA/RSA keypair with a single identity composed of the given full name, comment and email, any of which may be empty but must not contain any of "()<>\x00". If config is nil, sensible defaults will be used.

Modification of: https://code.google.com/p/go/source/browse/openpgp/keys.go?repo=crypto&r=8fec09c61d5d66f460d227fd1df3473d7e015bc6#456

From golang.com/x/crypto/openpgp/keys.go

func LoadPGPKeyFromLocalDB

func LoadPGPKeyFromLocalDB(k keybase1.KID, g *GlobalContext) (*PGPKeyBundle, error)

func NewGeneratedPGPKeyBundle

func NewGeneratedPGPKeyBundle(entity *openpgp.Entity) *PGPKeyBundle

func NewPGPKeyBundle

func NewPGPKeyBundle(entity *openpgp.Entity) *PGPKeyBundle

func (*PGPKeyBundle) CanDecrypt

func (k *PGPKeyBundle) CanDecrypt() bool

CanDecrypt returns false for now, since we haven't implemented PGP encryption of packets for metadata operations

func (*PGPKeyBundle) CanEncrypt

func (k *PGPKeyBundle) CanEncrypt() bool

CanEncrypt returns false for now, since we haven't implemented PGP encryption of packets for metadata operations

func (*PGPKeyBundle) CanSign

func (k *PGPKeyBundle) CanSign() bool

func (*PGPKeyBundle) CheckFingerprint

func (k *PGPKeyBundle) CheckFingerprint(fp *PGPFingerprint) error

func (*PGPKeyBundle) CheckIdentity

func (k *PGPKeyBundle) CheckIdentity(kbid Identity) (match bool, ctime int64, etime int64)

CheckIdentity finds the foo_user@keybase.io PGP identity and figures out when it was created and when it's slated to expire. We plan to start phasing out use of PGP-specified Expiration times as far as sigchain walking is concerned. But for now, there are a few places where it's still used (see ComputedKeyInfos#InsertServerEldestKey).

func (*PGPKeyBundle) CheckSecretKey

func (k *PGPKeyBundle) CheckSecretKey() (err error)

func (*PGPKeyBundle) DecryptFromString

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

DecryptFromString fails for this type of key, since we haven't implemented it yet

func (PGPKeyBundle) DecryptionKeys

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

func (*PGPKeyBundle) Encode

func (k *PGPKeyBundle) Encode() (ret string, err error)

func (*PGPKeyBundle) EncodeToStream

func (k *PGPKeyBundle) EncodeToStream(wc io.WriteCloser, private bool) error

func (*PGPKeyBundle) EncryptToString

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

EncryptToString fails for this type of key, since we haven't implemented it yet

func (*PGPKeyBundle) Export

func (bundle *PGPKeyBundle) Export() keybase1.PublicKey

func (*PGPKeyBundle) ExportPublicAndPrivate

func (k *PGPKeyBundle) ExportPublicAndPrivate() (public RawPublicKey, private RawPrivateKey, err error)

func (*PGPKeyBundle) FindEmail

func (k *PGPKeyBundle) FindEmail(em string) bool

func (*PGPKeyBundle) FindKeybaseUsername

func (k *PGPKeyBundle) FindKeybaseUsername(un string) bool

XXX for now this is OK but probably we need a PGP uid parser as in pgp-utils

func (*PGPKeyBundle) FullHash

func (k *PGPKeyBundle) FullHash() (string, error)

func (PGPKeyBundle) GetAlgoType

func (k PGPKeyBundle) GetAlgoType() kbcrypto.AlgoType

func (*PGPKeyBundle) GetBinaryKID

func (k *PGPKeyBundle) GetBinaryKID() keybase1.BinaryKID

func (PGPKeyBundle) GetFingerprint

func (k PGPKeyBundle) GetFingerprint() PGPFingerprint

func (PGPKeyBundle) GetFingerprintP

func (k PGPKeyBundle) GetFingerprintP() *PGPFingerprint

func (*PGPKeyBundle) GetKID

func (k *PGPKeyBundle) GetKID() keybase1.KID

func (*PGPKeyBundle) GetPGPIdentities

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

func (PGPKeyBundle) GetPrimaryUID

func (k PGPKeyBundle) GetPrimaryUID() string

GetPrimaryUID gets the primary UID in the given key bundle, returned in the 'Max K (foo) <bar@baz.com>' convention.

func (*PGPKeyBundle) HasSecretKey

func (k *PGPKeyBundle) HasSecretKey() bool

HasSecretKey checks if the PGPKeyBundle contains secret key. This function returning true does not indicate that the key is functional - it may also be a key stub.

func (PGPKeyBundle) HumanDescription

func (k PGPKeyBundle) HumanDescription() string

func (*PGPKeyBundle) IdentityNames

func (k *PGPKeyBundle) IdentityNames() []string

func (*PGPKeyBundle) InitGPGKey

func (k *PGPKeyBundle) InitGPGKey()

func (PGPKeyBundle) KeyDescription

func (k PGPKeyBundle) KeyDescription() string

func (PGPKeyBundle) KeyInfo

func (k PGPKeyBundle) KeyInfo() (algorithm, kid, creation string)

func (PGPKeyBundle) KeysById

func (k PGPKeyBundle) KeysById(id uint64, fp []byte) []openpgp.Key

func (PGPKeyBundle) KeysByIdUsage

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

func (PGPKeyBundle) MatchesKey

func (k PGPKeyBundle) MatchesKey(key *openpgp.Key) bool

func (*PGPKeyBundle) MergeKey

func (to *PGPKeyBundle) MergeKey(from *PGPKeyBundle)

MergeKey adds the identities, revocations, and subkeys of another PGPKeyBundle to this key

func (PGPKeyBundle) SamePrimaryAs

func (k PGPKeyBundle) SamePrimaryAs(k2 PGPKeyBundle) bool

func (*PGPKeyBundle) SecretSymmetricKey

func (k *PGPKeyBundle) SecretSymmetricKey(reason EncryptionReason) (NaclSecretBoxKey, error)

func (PGPKeyBundle) SecurityWarnings

func (k PGPKeyBundle) SecurityWarnings(kind HashSecurityWarningType) (warnings HashSecurityWarnings)

Generates hash security warnings given a CKF

func (*PGPKeyBundle) SerializePrivate

func (k *PGPKeyBundle) SerializePrivate(w io.Writer) error

func (*PGPKeyBundle) SignToString

func (k *PGPKeyBundle) SignToString(msg []byte) (sig string, id keybase1.SigIDBase, err error)

func (*PGPKeyBundle) StoreToLocalDb

func (k *PGPKeyBundle) StoreToLocalDb(g *GlobalContext) error

func (*PGPKeyBundle) StripRevocations

func (k *PGPKeyBundle) StripRevocations() (strippedKey *PGPKeyBundle)

StripRevocations returns a copy of the key with revocations removed

func (*PGPKeyBundle) ToServerSKB

func (key *PGPKeyBundle) ToServerSKB(gc *GlobalContext, tsec Triplesec, gen PassphraseGeneration) (ret *SKB, err error)

func (*PGPKeyBundle) Unlock

func (k *PGPKeyBundle) Unlock(m MetaContext, reason string, secretUI SecretUI) error

func (PGPKeyBundle) UsersDescription

func (k PGPKeyBundle) UsersDescription() []string

func (PGPKeyBundle) VerboseDescription

func (k PGPKeyBundle) VerboseDescription() string

func (PGPKeyBundle) VerifyString

func (k PGPKeyBundle) VerifyString(ctx VerifyContext, sig string, msg []byte) (id keybase1.SigIDBase, err error)

func (PGPKeyBundle) VerifyStringAndExtract

func (k PGPKeyBundle) VerifyStringAndExtract(ctx VerifyContext, sig string) (msg []byte, id keybase1.SigIDBase, err error)

type PGPKeySet

type PGPKeySet struct {
	Contextified
	PermissivelyMergedKey *PGPKeyBundle
	KeysByHash            map[string]*PGPKeyBundle
}

PGPKeySet represents a collection of versions of a PGP key. It includes a merged version of the key without revocations, and each individual version of the key with revocations intact.

type PGPPullLoggedOutError

type PGPPullLoggedOutError struct{}

func (PGPPullLoggedOutError) Error

func (e PGPPullLoggedOutError) Error() string
type PGPUpdateChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}

PGPUpdateChainLink represents a chain link which marks a new version of a PGP key as current. The KID and a new full hash are included in the pgp_update section of the body.

func ParsePGPUpdateChainLink(b GenericChainLink) (ret *PGPUpdateChainLink, err error)

ParsePGPUpdateChainLink creates a PGPUpdateChainLink from a GenericChainLink and verifies that its pgp_update section contains a KID and full_hash

func (*PGPUpdateChainLink) GetPGPFullHash

func (l *PGPUpdateChainLink) GetPGPFullHash() string

func (*PGPUpdateChainLink) ToDisplayString

func (l *PGPUpdateChainLink) ToDisplayString() string

func (*PGPUpdateChainLink) Type

func (l *PGPUpdateChainLink) Type() string

type PIDFileLockError

type PIDFileLockError struct {
	Filename string
}

func (PIDFileLockError) Error

func (e PIDFileLockError) Error() string

type PaperChecker

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

PaperChecker implements PassphraseChecker for paper keys.

func (*PaperChecker) Automutate

func (p *PaperChecker) Automutate(m MetaContext, s string) (string, error)

func (*PaperChecker) Check

func (p *PaperChecker) Check(m MetaContext, s string) error

Check a paper key format. Will return a detailed error message specific to the problems found in s.

type PaperKeyError

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

func (PaperKeyError) Error

func (p PaperKeyError) Error() string

type PaperKeyPhrase

type PaperKeyPhrase string

PaperKeyPhrase is the string that can generate a paper key. It is versioned and forced to be lowercase. To make a new random phrase, use MakePaperKeyPhrase. To convert a string to a PaperKeyPhrase, use NewPaperKeyPhrase.

func MakePaperKeyPhrase

func MakePaperKeyPhrase(version uint8) (PaperKeyPhrase, error)

MakePaperKeyPhrase creates a new, random paper key phrase for the given version.

func NewPaperKeyPhrase

func NewPaperKeyPhrase(phrase string) PaperKeyPhrase

NewPaperKeyPhrase converts a string into a PaperKeyPhrase.

func NewPaperKeyPhraseCheckVersion

func NewPaperKeyPhraseCheckVersion(m MetaContext, passphrase string) (ret PaperKeyPhrase, err error)

func (PaperKeyPhrase) Bytes

func (p PaperKeyPhrase) Bytes() []byte

Bytes returns a byte slice of the phrase.

func (PaperKeyPhrase) InvalidWords

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

func (PaperKeyPhrase) NumWords

func (p PaperKeyPhrase) NumWords() int

func (PaperKeyPhrase) Prefix

func (p PaperKeyPhrase) Prefix() string

Prefix returns the first two words in the phrase.

func (PaperKeyPhrase) String

func (p PaperKeyPhrase) String() string

String returns a string representation of the phrase.

func (PaperKeyPhrase) Version

func (p PaperKeyPhrase) Version() (uint8, error)

Version calculates the phrase version. 0-15 are possible versions.

type ParsedSig

type ParsedSig struct {
	Block       *armor.Block
	SigBody     []byte
	MD          *openpgp.MessageDetails
	LiteralData []byte
}

func PGPOpenSig

func PGPOpenSig(armored string) (ps *ParsedSig, err error)

func (*ParsedSig) AssertPayload

func (ps *ParsedSig) AssertPayload(expected []byte) error

func (*ParsedSig) ExtractPayload

func (ps *ParsedSig) ExtractPayload() (payload []byte, err error)

func (*ParsedSig) ID

func (ps *ParsedSig) ID() keybase1.SigIDBase

func (*ParsedSig) Verify

func (ps *ParsedSig) Verify(k PGPKeyBundle) (err error)

type Parser

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

func NewParser

func NewParser(lexer *Lexer) *Parser

func (*Parser) Parse

type PassphraseChecker

type PassphraseChecker interface {
	Check(MetaContext, string) error
	Automutate(MetaContext, string) (string, error)
}

PassphraseChecker is an interface for checking the format of a passphrase. Returns nil if the format is ok, or a descriptive hint otherwise.

type PassphraseError

type PassphraseError struct {
	Msg string
}

func (PassphraseError) Error

func (p PassphraseError) Error() string

func (PassphraseError) ToStatus

func (p PassphraseError) ToStatus() (s keybase1.Status)

type PassphraseGeneration

type PassphraseGeneration int

PassphraseGeneration represents which generation of the passphrase is currently in use. It's used to guard against race conditions in which the passphrase is changed on one device which the other still has it cached.

func (PassphraseGeneration) IsNil

func (p PassphraseGeneration) IsNil() bool

IsNil returns true if this PassphraseGeneration isn't initialized.

type PassphrasePrompter

type PassphrasePrompter interface {
	Prompt(keybase1.GUIEntryArg) (keybase1.GetPassphraseRes, error)
}

type PassphraseProvisionImpossibleError

type PassphraseProvisionImpossibleError struct{}

func (PassphraseProvisionImpossibleError) Error

type PassphraseStream

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

func GetPassphraseStreamStored

func GetPassphraseStreamStored(m MetaContext) (pps *PassphraseStream, err error)

GetPassphraseStreamStored either returns a cached, verified passphrase stream from a previous login, the secret store, or generates a new one via login. NOTE: this function can return a partial passphrase stream if it reads from the secret store. It won't have the material used to decrypt server-synced keys or to generate PDPKA material in that case.

func GetPassphraseStreamViaPromptInLoginContext

func GetPassphraseStreamViaPromptInLoginContext(m MetaContext) (pps *PassphraseStream, err error)

GetFullPassphraseStreamViaPrompt gets the user's passphrase stream either cached from the LoginContext or from the prompt. It doesn't involve the secret store at all, since the full passphrase stream isn't stored in the secret store. And also it doesn't write the secret store because this function is called right before the user changes to a new passphrase, so what's the point. It's assumed that the login context is set to non-nil by the caller.

func NewPassphraseStream

func NewPassphraseStream(s []byte) *PassphraseStream

func NewPassphraseStreamLKSecOnly

func NewPassphraseStreamLKSecOnly(s *LKSec) (*PassphraseStream, error)

NewPassphraseStreamLKSecOnly creates a PassphraseStream only with the lks bytes (stream[lksIndex:]). The rest of the stream is zeros. This is used to create a passphrase stream from the information in the secret store, which only contains the lksec portion of the stream.

func RetrievePwhashEddsaPassphraseStream

func RetrievePwhashEddsaPassphraseStream(mctx MetaContext, username NormalizedUsername, uid keybase1.UID) (ret *PassphraseStream, err error)

func VerifyPassphraseForLoggedInUser

func VerifyPassphraseForLoggedInUser(m MetaContext, pp string) (pps *PassphraseStream, err error)

VerifyPassphraseForLoggedInUser verifies that the current passphrase is correct for the logged in user, returning nil if correct, and an error if not. Only used in tests right now, but it's fine to use in production code if it seems appropriate.

func VerifyPassphraseGetStreamInLoginContext

func VerifyPassphraseGetStreamInLoginContext(m MetaContext, passphrase string) (pps *PassphraseStream, err error)

VerifyPassphraseGetFullStream verifies the current passphrase is a correct login and if so, will return a full passphrase stream derived from it. Assumes the caller made a non-nil LoginContext for us to operate in.

func (*PassphraseStream) Clone

func (ps *PassphraseStream) Clone() *PassphraseStream

Clone a passphrase stream and return a copy.

func (PassphraseStream) DHSeed

func (ps PassphraseStream) DHSeed() []byte

func (PassphraseStream) EdDSASeed

func (ps PassphraseStream) EdDSASeed() []byte

func (PassphraseStream) Export

func (PassphraseStream) Generation

func (ps PassphraseStream) Generation() PassphraseGeneration

Generation returns the generation of this passphrase stream. It is >=0 for valid generation #. If 0, then we assume the passphrase has never been reset.

func (PassphraseStream) LksClientHalf

func (ps PassphraseStream) LksClientHalf() LKSecClientHalf

func (PassphraseStream) PDPKA5KID

func (ps PassphraseStream) PDPKA5KID() (keybase1.KID, error)

func (PassphraseStream) PWHash

func (ps PassphraseStream) PWHash() []byte

func (*PassphraseStream) SetGeneration

func (ps *PassphraseStream) SetGeneration(gen PassphraseGeneration)

func (PassphraseStream) String

func (ps PassphraseStream) String() string

func (PassphraseStream) SyncAndCheckIfOutdated

func (ps PassphraseStream) SyncAndCheckIfOutdated(mctx MetaContext) (bool, error)

func (PassphraseStream) ToLKSec

func (ps PassphraseStream) ToLKSec(uid keybase1.UID) (*LKSec, error)

type PassphraseStreamCache

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

func NewPassphraseStreamCache

func NewPassphraseStreamCache(tsec Triplesec, ps *PassphraseStream) *PassphraseStreamCache

func (*PassphraseStreamCache) Clear

func (s *PassphraseStreamCache) Clear()

func (*PassphraseStreamCache) Dump

func (s *PassphraseStreamCache) Dump()

func (*PassphraseStreamCache) MutatePassphraseStream

func (s *PassphraseStreamCache) MutatePassphraseStream(f func(*PassphraseStream)) bool

func (*PassphraseStreamCache) PassphraseStream

func (s *PassphraseStreamCache) PassphraseStream() *PassphraseStream

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

func (*PassphraseStreamCache) PassphraseStreamAndTriplesec

func (s *PassphraseStreamCache) PassphraseStreamAndTriplesec() (pps *PassphraseStream, tsec Triplesec)

func (*PassphraseStreamCache) TriplesecAndGeneration

func (s *PassphraseStreamCache) TriplesecAndGeneration() (Triplesec, PassphraseGeneration)

func (*PassphraseStreamCache) Valid

func (s *PassphraseStreamCache) Valid() bool

func (*PassphraseStreamCache) ValidPassphraseStream

func (s *PassphraseStreamCache) ValidPassphraseStream() bool

func (*PassphraseStreamCache) ValidTsec

func (s *PassphraseStreamCache) ValidTsec() bool

type PassphraseType

type PassphraseType string
const (
	PassphraseTypeKeybase PassphraseType = "Keybase"
	PassphraseTypePGP     PassphraseType = "PGP"
)

type PathStep

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

type PathSteps

type PathSteps []*PathStep

func (PathSteps) VerifyPath

func (path PathSteps) VerifyPath(curr NodeHash, uidS string) (juser *jsonw.Wrapper, err error)

type PayloadCache

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

func NewPayloadCache

func NewPayloadCache(g *GlobalContext, maxNumElements int) *PayloadCache

func (*PayloadCache) GetOrPrime

func (p *PayloadCache) GetOrPrime(link *ChainLink) (*jsonw.Wrapper, error)

type Peg

type Peg struct {
	UID         keybase1.UID
	EldestSeqno keybase1.Seqno
}

type Pegboard

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

Pegboard keeps track of automatic private follows. When the logged-in user interacts with another user, that other user gets pegged to their incarnation. After the target resets, the logged-in user will be alerted even if there's no explicit following. CORE-10522 For now, pegboard is disabled by default and when enabled

only has in-memory storage.

func NewPegboard

func NewPegboard() *Pegboard

func (*Pegboard) CheckUV

func (p *Pegboard) CheckUV(mctx MetaContext, uv keybase1.UserVersion) error

Returns an error if this user has reset since their peg was last udpated. Pegs users that haven't been seen before.

func (*Pegboard) ObserveUV

func (p *Pegboard) ObserveUV(mctx MetaContext, uv keybase1.UserVersion)

Pegs users that haven't been seen before.

func (*Pegboard) OnLogout

func (p *Pegboard) OnLogout(mctx MetaContext)

func (*Pegboard) TrackUPAK

func (p *Pegboard) TrackUPAK(mctx MetaContext, upak keybase1.UserPlusKeysV2) (err error)

Update a peg. The logged-in user has purposefully interacted with this version of the user.

type PerUserKeyChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParsePerUserKeyChainLink(b GenericChainLink) (ret *PerUserKeyChainLink, err error)

func (*PerUserKeyChainLink) GetDelegatedKid

func (s *PerUserKeyChainLink) GetDelegatedKid() (res keybase1.KID)

func (*PerUserKeyChainLink) GetRole

func (s *PerUserKeyChainLink) GetRole() KeyRole

Don't consider per-user-keys as normal delegations. Because they have multiple kids and initially can't delegate further. They are handled separately by the sigchain loader.

func (*PerUserKeyChainLink) ToDisplayString

func (s *PerUserKeyChainLink) ToDisplayString() string

func (*PerUserKeyChainLink) ToPerUserKey

func (s *PerUserKeyChainLink) ToPerUserKey() keybase1.PerUserKey

func (*PerUserKeyChainLink) Type

func (s *PerUserKeyChainLink) Type() string

func (*PerUserKeyChainLink) VerifyReverseSig

func (s *PerUserKeyChainLink) VerifyReverseSig(_ ComputedKeyFamily) (err error)

VerifyReverseSig checks a SibkeyChainLink's reverse signature using the ComputedKeyFamily provided.

type PerUserKeyImportError

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

func NewPerUserKeyImportError

func NewPerUserKeyImportError(format string, args ...interface{}) PerUserKeyImportError

func (PerUserKeyImportError) Error

func (e PerUserKeyImportError) Error() string

type PerUserKeyPrev

type PerUserKeyPrev string

A secretbox containg a seed encrypted for its successor generation

type PerUserKeySeed

type PerUserKeySeed [PerUserKeySeedSize]byte

func GeneratePerUserKeySeed

func GeneratePerUserKeySeed() (res PerUserKeySeed, err error)

func (*PerUserKeySeed) DeriveDHKey

func (s *PerUserKeySeed) DeriveDHKey() (*NaclDHKeyPair, error)

func (*PerUserKeySeed) DeriveSigningKey

func (s *PerUserKeySeed) DeriveSigningKey() (*NaclSigningKeyPair, error)

func (*PerUserKeySeed) DeriveSymmetricKey

func (s *PerUserKeySeed) DeriveSymmetricKey(reason DeriveReason) (res NaclSecretBoxKey, err error)

func (*PerUserKeySeed) IsBlank

func (s *PerUserKeySeed) IsBlank() bool

type PerUserKeyring

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

PerUserKeyring holds on to all versions of the per user key. Generation=0 should be nil, but all others should be present.

func NewPerUserKeyring

func NewPerUserKeyring(g *GlobalContext, uid keybase1.UID) (*PerUserKeyring, error)

NewPerUserKeyring makes a new per-user-key keyring for a given UID.

func (*PerUserKeyring) AddKey

AddKey registers a full key locally.

func (*PerUserKeyring) CurrentGeneration

func (s *PerUserKeyring) CurrentGeneration() keybase1.PerUserKeyGeneration

CurrentGeneration returns what generation we're on. The version possible Version is 1. Version 0 implies no keys are available.

func (*PerUserKeyring) GetEncryptionKeyByGeneration

func (s *PerUserKeyring) GetEncryptionKeyByGeneration(m MetaContext, gen keybase1.PerUserKeyGeneration) (*NaclDHKeyPair, error)

Get the encryption key of a generation.

func (*PerUserKeyring) GetEncryptionKeyByGenerationOrSync

func (s *PerUserKeyring) GetEncryptionKeyByGenerationOrSync(m MetaContext, gen keybase1.PerUserKeyGeneration) (*NaclDHKeyPair, error)

func (*PerUserKeyring) GetEncryptionKeyByKID

func (s *PerUserKeyring) GetEncryptionKeyByKID(m MetaContext, kid keybase1.KID) (*NaclDHKeyPair, error)

GetEncryptionKeyByKID finds an encryption key that matches kid.

func (*PerUserKeyring) GetEncryptionKeyBySeqno

func (s *PerUserKeyring) GetEncryptionKeyBySeqno(m MetaContext, seqno keybase1.Seqno) (*NaclDHKeyPair, error)

Get the encryption key at the user sigchain seqno.

func (*PerUserKeyring) GetEncryptionKeyBySeqnoOrSync

func (s *PerUserKeyring) GetEncryptionKeyBySeqnoOrSync(m MetaContext, seqno keybase1.Seqno) (*NaclDHKeyPair, error)

func (*PerUserKeyring) GetLatestSigningKey

func (s *PerUserKeyring) GetLatestSigningKey(m MetaContext) (*NaclSigningKeyPair, error)

func (*PerUserKeyring) GetSeedByGeneration

func (s *PerUserKeyring) GetSeedByGeneration(m MetaContext, gen keybase1.PerUserKeyGeneration) (res PerUserKeySeed, err error)

func (*PerUserKeyring) GetSeedByGenerationOrSync

func (s *PerUserKeyring) GetSeedByGenerationOrSync(m MetaContext, gen keybase1.PerUserKeyGeneration) (res PerUserKeySeed, err error)

func (*PerUserKeyring) GetUID

func (s *PerUserKeyring) GetUID() keybase1.UID

func (*PerUserKeyring) HasAnyKeys

func (s *PerUserKeyring) HasAnyKeys() bool

func (*PerUserKeyring) PrepareBoxForNewDevice

func (s *PerUserKeyring) PrepareBoxForNewDevice(m MetaContext, receiverKey NaclDHKeyPair,
	senderKey NaclDHKeyPair) (box keybase1.PerUserKeyBox, err error)

PrepareBoxForNewDevice encrypts the latest shared key seed for a new device. The returned box should be pushed to the server.

func (*PerUserKeyring) PrepareBoxesForDevices

func (s *PerUserKeyring) PrepareBoxesForDevices(m MetaContext, contents PerUserKeySeed,
	generation keybase1.PerUserKeyGeneration, receiverKeys []NaclDHKeyPair,
	senderKey GenericKey) (boxes []keybase1.PerUserKeyBox, err error)

Encrypt seed for receiverKeys. Use senderKey to encrypt. Does not use the keyring at all. Attached for organizational purposes. Used when creating a new seed.

func (*PerUserKeyring) PreparePrev

func (s *PerUserKeyring) PreparePrev(m MetaContext, newSeed PerUserKeySeed,
	newGeneration keybase1.PerUserKeyGeneration) (PerUserKeyPrev, error)

Prepares a prev secretbox containing generation n-1 encrypted for generation n. Asserts that the current generation is n-1. The `generation` parameter is n.

func (*PerUserKeyring) Sync

func (s *PerUserKeyring) Sync(m MetaContext) (err error)

Sync our PerUserKeyring with the server. It will either add all new keys since our last update, or not at all if there was an error. Pass it a standard Go network context.

func (*PerUserKeyring) SyncAsProvisioningKey

func (s *PerUserKeyring) SyncAsProvisioningKey(m MetaContext, upak *keybase1.UserPlusAllKeys, deviceID keybase1.DeviceID, decryptionKey GenericKey) (err error)

`m.LoginContext` and `upak` are optional

func (*PerUserKeyring) SyncWithExtras

func (s *PerUserKeyring) SyncWithExtras(m MetaContext, upak *keybase1.UserPlusAllKeys) (err error)

`m.LoginContext` and `upak` are optional

type PerUserKeysList

type PerUserKeysList []keybase1.PerUserKey

func (PerUserKeysList) Len

func (p PerUserKeysList) Len() int

func (PerUserKeysList) Less

func (p PerUserKeysList) Less(i, j int) bool

func (PerUserKeysList) Swap

func (p PerUserKeysList) Swap(i, j int)

type PgpUI

type PgpUI interface {
	keybase1.PGPUiInterface
}

type PostAuthProofArg

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

type PostAuthProofRes

type PostAuthProofRes struct {
	SessionID string `json:"session"`
	AuthID    string `json:"auth_id"`
	CSRFToken string `json:"csrf_token"`
	UIDHex    string `json:"uid"`
	Username  string `json:"username"`
	PPGen     int    `json:"passphrase_generation"`
}

func PostAuthProof

func PostAuthProof(m MetaContext, arg PostAuthProofArg) (*PostAuthProofRes, error)

type PostProofArg

type PostProofArg struct {
	UID               keybase1.UID
	Seqno             keybase1.Seqno
	Sig               string
	SigInner          []byte
	RemoteServiceType string
	SigID             keybase1.SigID
	LinkID            LinkID
	RemoteUsername    string
	ProofType         string
	Supersede         bool
	RemoteKey         string
	SigningKey        GenericKey
}

type PostProofRes

type PostProofRes struct {
	Text     string
	ID       string
	Metadata *jsonw.Wrapper
}

func PostProof

func PostProof(m MetaContext, arg PostProofArg) (*PostProofRes, error)

type ProcessHiddenRespFunc

type ProcessHiddenRespFunc func(m MetaContext, teamID keybase1.TeamID, apiRes *APIRes, blindRootHash string) (*MerkleHiddenResponse, error)

type ProfileNotPublicError

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

func NewProfileNotPublicError

func NewProfileNotPublicError(s string) ProfileNotPublicError

func (ProfileNotPublicError) Error

func (p ProfileNotPublicError) Error() string

func (ProfileNotPublicError) ToStatus

func (e ProfileNotPublicError) ToStatus() keybase1.Status

type PromptArg

type PromptArg struct {
	TerminalPrompt string
	PinentryDesc   string
	PinentryPrompt string
	Checker        *Checker
	RetryMessage   string
	UseSecretStore bool
	ShowTyping     bool
}

type PromptDefault

type PromptDefault int
const (
	PromptDefaultNo PromptDefault = iota
	PromptDefaultYes
	PromptDefaultNeither
)

type PromptDescriptor

type PromptDescriptor int

type Proof

type Proof struct {
	Key, Value string
}

func RemoteProofChainLinkToProof

func RemoteProofChainLinkToProof(r RemoteProofChainLink) Proof

type ProofAPIError

type ProofAPIError struct {
	ProofErrorImpl
	// contains filtered or unexported fields
}

func NewProofAPIError

func NewProofAPIError(s keybase1.ProofStatus, u string, d string, a ...interface{}) *ProofAPIError

func XapiError

func XapiError(err error, u string) *ProofAPIError

type ProofCache

type ProofCache struct {
	Contextified

	sync.RWMutex
	// contains filtered or unexported fields
}

func NewProofCache

func NewProofCache(g *GlobalContext, capac int) *ProofCache

func (*ProofCache) Delete

func (pc *ProofCache) Delete(sid keybase1.SigID) error

func (*ProofCache) DisableDisk

func (pc *ProofCache) DisableDisk()

func (*ProofCache) Get

func (*ProofCache) Put

func (*ProofCache) Reset

func (pc *ProofCache) Reset() error

type ProofChecker

type ProofChecker interface {
	// `h` is the server provided sigHint. If the client can provide validated
	// information it returns this. The verifiedSigHint is preferred over the
	// server-trust one when displaying to users.
	CheckStatus(m MetaContext, h SigHint, pcm ProofCheckerMode, pvlU keybase1.MerkleStoreEntry) (*SigHint, ProofError)
	GetTorError() ProofError
}

type ProofCheckerMode

type ProofCheckerMode int
const (
	ProofCheckerModePassive ProofCheckerMode = iota
	ProofCheckerModeActive  ProofCheckerMode = iota
)

type ProofError

type ProofError interface {
	error
	GetProofStatus() keybase1.ProofStatus
	GetDesc() string
}

func ImportProofError

func ImportProofError(e keybase1.ProofResult) ProofError

type ProofErrorImpl

type ProofErrorImpl struct {
	Status keybase1.ProofStatus
	Desc   string
}

func NewProofError

func NewProofError(s keybase1.ProofStatus, d string, a ...interface{}) *ProofErrorImpl

func (*ProofErrorImpl) Error

func (e *ProofErrorImpl) Error() string

func (*ProofErrorImpl) GetDesc

func (e *ProofErrorImpl) GetDesc() string

func (*ProofErrorImpl) GetProofStatus

func (e *ProofErrorImpl) GetProofStatus() keybase1.ProofStatus

type ProofLinkWithState

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

ProofLinkWithState contains a RemoteProofChainLink and the proof state. In addition, it satisfies the TrackIdComponent interface.

func (ProofLinkWithState) GetProofState

func (p ProofLinkWithState) GetProofState() keybase1.ProofState

func (ProofLinkWithState) GetProofType

func (p ProofLinkWithState) GetProofType() keybase1.ProofType

func (ProofLinkWithState) LastWriterWins

func (p ProofLinkWithState) LastWriterWins() bool

func (ProofLinkWithState) ToIDString

func (p ProofLinkWithState) ToIDString() string

func (ProofLinkWithState) ToKeyValuePair

func (p ProofLinkWithState) ToKeyValuePair() (string, string)

type ProofMetadata

type ProofMetadata struct {
	Me                  *User
	SigningUser         UserBasic
	Seqno               keybase1.Seqno
	PrevLinkID          LinkID
	LinkType            LinkType
	SigningKey          GenericKey
	Eldest              keybase1.KID
	CreationTime        int64
	ExpireIn            int
	IncludePGPHash      bool
	SigVersion          SigVersion
	SeqType             keybase1.SeqType
	MerkleRoot          *MerkleRoot
	IgnoreIfUnsupported SigIgnoreIfUnsupported
	// HighSkipFallback is used for teams to provide for a KEX-provisisonee to
	// provide the provisioner's information as the latest high link.
	HighSkipFallback *HighSkip
}

func (ProofMetadata) ToJSON

func (arg ProofMetadata) ToJSON(m MetaContext) (*jsonw.Wrapper, error)

func (ProofMetadata) ToJSON2

func (arg ProofMetadata) ToJSON2(m MetaContext) (ret *ProofMetadataRes, err error)

type ProofMetadataRes

type ProofMetadataRes struct {
	J     *jsonw.Wrapper
	Seqno keybase1.Seqno
}

func KeyProof2

func KeyProof2(m MetaContext, arg Delegator) (ret *ProofMetadataRes, err error)

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

func PerUserKeyProof

func PerUserKeyProof(m MetaContext,
	me *User,
	pukSigKID keybase1.KID,
	pukEncKID keybase1.KID,
	generation keybase1.PerUserKeyGeneration,
	signingKey GenericKey) (*ProofMetadataRes, error)

PerUserKeyProof creates a proof introducing a new per-user-key generation. `signingKey` is the key signing in this new key. Not to be confused with the derived per-user-key signing key.

func StellarProof

func StellarProof(m MetaContext, me *User, walletAddress stellar1.AccountID,
	signingKey GenericKey) (*ProofMetadataRes, error)

StellarProof creates a proof of a stellar wallet.

type ProofNotFoundForServiceError

type ProofNotFoundForServiceError struct {
	Service string
}

func (ProofNotFoundForServiceError) Error

func (ProofNotFoundForServiceError) ToStatus

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

type ProofNotFoundForUsernameError

type ProofNotFoundForUsernameError struct {
	Service  string
	Username string
}

func (ProofNotFoundForUsernameError) Error

func (ProofNotFoundForUsernameError) ToStatus

type ProofNotYetAvailableError

type ProofNotYetAvailableError struct{}

func (ProofNotYetAvailableError) Error

type ProofSet

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

func BaseProofSet

BaseProofSet creates a basic proof set for a user with their keybase and uid proofs and any pgp fingerprint proofs.

func NewProofSet

func NewProofSet(proofs []Proof) *ProofSet

func (*ProofSet) Add

func (ps *ProofSet) Add(p Proof)

func (ProofSet) Get

func (ps ProofSet) Get(keys []string) (ret []Proof)

type ProtocolDowngradeError

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

=============================================================================

func NewProtocolDowngradeError

func NewProtocolDowngradeError(msg string) ProtocolDowngradeError

func (ProtocolDowngradeError) Error

func (h ProtocolDowngradeError) Error() string

type ProtocolSchemeMismatch

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

func NewProtocolSchemeMismatch

func NewProtocolSchemeMismatch(msg string) ProtocolSchemeMismatch

func (ProtocolSchemeMismatch) Error

func (h ProtocolSchemeMismatch) Error() string

type ProvisionFailedOfflineError

type ProvisionFailedOfflineError struct{}

func (ProvisionFailedOfflineError) Error

func (ProvisionFailedOfflineError) ToStatus

type ProvisionUI

type ProvisionUI interface {
	keybase1.ProvisionUiInterface
}

type ProvisionUnavailableError

type ProvisionUnavailableError struct{}

func (ProvisionUnavailableError) Error

func (ProvisionUnavailableError) ToStatus

type ProvisionViaDeviceRequiredError

type ProvisionViaDeviceRequiredError struct{}

func (ProvisionViaDeviceRequiredError) Error

func (ProvisionViaDeviceRequiredError) ToStatus

type ProvisionalLoginContext

type ProvisionalLoginContext struct {
	MetaContextified
	// contains filtered or unexported fields
}

func (*ProvisionalLoginContext) ClearKeyring

func (p *ProvisionalLoginContext) ClearKeyring()

func (*ProvisionalLoginContext) CreateLoginSessionWithSalt

func (p *ProvisionalLoginContext) CreateLoginSessionWithSalt(emailOrUsername string, salt []byte) error

func (*ProvisionalLoginContext) CreateStreamCache

func (p *ProvisionalLoginContext) CreateStreamCache(tsec Triplesec, pps *PassphraseStream)

func (*ProvisionalLoginContext) Dump

func (p *ProvisionalLoginContext) Dump(m MetaContext, prefix string)

func (*ProvisionalLoginContext) GetUID

func (p *ProvisionalLoginContext) GetUID() keybase1.UID

func (*ProvisionalLoginContext) GetUnlockedPaperEncKey

func (p *ProvisionalLoginContext) GetUnlockedPaperEncKey() GenericKey

func (*ProvisionalLoginContext) GetUnlockedPaperSigKey

func (p *ProvisionalLoginContext) GetUnlockedPaperSigKey() GenericKey

func (*ProvisionalLoginContext) GetUserVersion

func (p *ProvisionalLoginContext) GetUserVersion() keybase1.UserVersion

func (*ProvisionalLoginContext) GetUsername

func (*ProvisionalLoginContext) Keyring

func (p *ProvisionalLoginContext) Keyring(m MetaContext) (ret *SKBKeyringFile, err error)

func (*ProvisionalLoginContext) LocalSession

func (p *ProvisionalLoginContext) LocalSession() *Session

func (*ProvisionalLoginContext) LoggedInLoad

func (p *ProvisionalLoginContext) LoggedInLoad() (bool, error)

func (*ProvisionalLoginContext) LoginSession

func (p *ProvisionalLoginContext) LoginSession() *LoginSession

func (*ProvisionalLoginContext) PassphraseStream

func (p *ProvisionalLoginContext) PassphraseStream() *PassphraseStream

func (*ProvisionalLoginContext) PassphraseStreamCache

func (p *ProvisionalLoginContext) PassphraseStreamCache() *PassphraseStreamCache

func (*ProvisionalLoginContext) RunSecretSyncer

func (p *ProvisionalLoginContext) RunSecretSyncer(m MetaContext, uid keybase1.UID) error

func (*ProvisionalLoginContext) Salt

func (p *ProvisionalLoginContext) Salt() []byte

func (*ProvisionalLoginContext) SaveState

func (p *ProvisionalLoginContext) SaveState(sessionID, csrf string, username NormalizedUsername, uv keybase1.UserVersion, deviceID keybase1.DeviceID) (err error)

func (*ProvisionalLoginContext) SecretSyncer

func (p *ProvisionalLoginContext) SecretSyncer() *SecretSyncer

func (*ProvisionalLoginContext) SetLoginSession

func (p *ProvisionalLoginContext) SetLoginSession(l *LoginSession)

func (*ProvisionalLoginContext) SetStreamCache

func (p *ProvisionalLoginContext) SetStreamCache(c *PassphraseStreamCache)

func (*ProvisionalLoginContext) SetUsernameUserVersion

func (p *ProvisionalLoginContext) SetUsernameUserVersion(username NormalizedUsername, uv keybase1.UserVersion) error

type ProxyDialOpts

type ProxyDialOpts struct {
	Timeout   time.Duration
	KeepAlive time.Duration
}

type ProxyDialable

type ProxyDialable struct {
	Timeout   time.Duration
	KeepAlive time.Duration
	// contains filtered or unexported fields
}

A struct that implements rpc.Dialable from go-framed-msgpack-rpc

func NewProxyDialable

func NewProxyDialable(env *Env) *ProxyDialable

func (*ProxyDialable) Dial

func (pd *ProxyDialable) Dial(ctx context.Context, network string, addr string) (net.Conn, error)

func (*ProxyDialable) SetOpts

func (pd *ProxyDialable) SetOpts(timeout time.Duration, keepAlive time.Duration)

type ProxyType

type ProxyType int

Represents the different types of supported proxies

const (
	NoProxy ProxyType = iota
	Socks
	HTTPConnect
)

func ProxyTypeStrToEnumFunc

func ProxyTypeStrToEnumFunc(proxyTypeStr string) ProxyType

type PseudonymGetError

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

PseudonymGetError is sometimes written by unmarshaling (no fields of) a server response.

func (PseudonymGetError) Error

func (e PseudonymGetError) Error() string

type PublicKeyList

type PublicKeyList []keybase1.PublicKey

func (PublicKeyList) Len

func (l PublicKeyList) Len() int

func (PublicKeyList) Less

func (l PublicKeyList) Less(i, j int) bool

func (PublicKeyList) Swap

func (l PublicKeyList) Swap(i, j int)

type PushSecretWithoutPasswordError

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

func (PushSecretWithoutPasswordError) Error

type RPCCanceler

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

func NewRPCCanceler

func NewRPCCanceler() *RPCCanceler

func (*RPCCanceler) CancelLiveContexts

func (r *RPCCanceler) CancelLiveContexts(reason RPCCancelerReason)

func (*RPCCanceler) RegisterContext

func (r *RPCCanceler) RegisterContext(ctx context.Context, reason RPCCancelerReason) (context.Context, RPCCancelerKey)

func (*RPCCanceler) UnregisterContext

func (r *RPCCanceler) UnregisterContext(id RPCCancelerKey)

type RPCCancelerKey

type RPCCancelerKey string

func NewRPCCancelerKey

func NewRPCCancelerKey() RPCCancelerKey

type RPCCancelerReason

type RPCCancelerReason uint
const (
	RPCCancelerReasonLogout RPCCancelerReason = 1 << iota
	RPCCancelerReasonBackground
	RPCCancelerReasonMax
)

type RPCLogFactory

type RPCLogFactory struct {
	Contextified
}

func NewRPCLogFactory

func NewRPCLogFactory(g *GlobalContext) *RPCLogFactory

func (*RPCLogFactory) NewLog

func (r *RPCLogFactory) NewLog(a net.Addr) rpc.LogInterface

type Random

type Random interface {
	// RndRange returns a uniformly random integer between low and high inclusive
	RndRange(low, high int64) (res int64, err error)
}

type RateLimitCategory

type RateLimitCategory string
const (
	CheckTrackingRateLimit RateLimitCategory = "CheckTrackingRateLimit"
	TestEventRateLimit     RateLimitCategory = "TestEventRateLimit"
)

type RateLimits

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

func NewRateLimits

func NewRateLimits(g *GlobalContext) *RateLimits

func (*RateLimits) GetPermission

func (r *RateLimits) GetPermission(category RateLimitCategory, interval time.Duration) bool

type RawKeyFamily

type RawKeyFamily struct {
	AllBundles []string `json:"all_bundles"`
}

As returned by user/lookup.json

type RawPrivateKey

type RawPrivateKey []byte

type RawPublicKey

type RawPublicKey []byte

type ReadCloseSeeker

type ReadCloseSeeker interface {
	io.ReadCloser
	io.Seeker
}

type ReadCloser

type ReadCloser struct{}

type ReceiverDeviceError

type ReceiverDeviceError struct {
	Msg string
}

func NewReceiverDeviceError

func NewReceiverDeviceError(expected, received keybase1.DeviceID) ReceiverDeviceError

func (ReceiverDeviceError) Error

func (e ReceiverDeviceError) Error() string

func (ReceiverDeviceError) ToStatus

func (e ReceiverDeviceError) ToStatus() keybase1.Status

type RecipientNotFoundError

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

type ReloginRequiredError

type ReloginRequiredError struct{}

func (ReloginRequiredError) Error

func (e ReloginRequiredError) Error() string

func (ReloginRequiredError) ToStatus

func (e ReloginRequiredError) ToStatus() keybase1.Status
type RemoteProofChainLink interface {
	TypedChainLink
	DisplayPriorityKey() string
	TableKey() string
	LastWriterWins() bool
	GetRemoteUsername() string
	GetHostname() string
	GetProtocol() string
	DisplayCheck(m MetaContext, ui IdentifyUI, lcr LinkCheckResult) error
	ToTrackingStatement(keybase1.ProofState) (*jsonw.Wrapper, error)
	CheckDataJSON() *jsonw.Wrapper
	ToIDString() string
	ToKeyValuePair() (string, string)
	ComputeTrackDiff(tl *TrackLookup) TrackDiff
	GetProofType() keybase1.ProofType
	ProofText() string
}

========================================================================= Remote, Web and Social

func ParseWebServiceBinding

func ParseWebServiceBinding(base GenericChainLink) (ret RemoteProofChainLink, err error)

To be used for signatures in a user's signature chain.

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

RemoteProofLinks holds a set of RemoteProofChainLinks, organized by service.

func NewRemoteProofLinks(g *GlobalContext) *RemoteProofLinks

NewRemoteProofLinks creates a new empty collection of proof links.

func (*RemoteProofLinks) Active

func (r *RemoteProofLinks) Active() []RemoteProofChainLink

Active returns all the active proof links, deduplicating any and honoring the LastWriterWins option.

func (*RemoteProofLinks) AddProofsToSet

func (r *RemoteProofLinks) AddProofsToSet(existing *ProofSet, okStates []keybase1.ProofState)

AddProofsToSet adds the active proofs to an existing ProofSet, if they're one of the given OkStates. If okStates is nil, then we check only against keybase1.ProofState_OK.

func (*RemoteProofLinks) ForService

ForService returns all the active proof links for a service.

func (*RemoteProofLinks) Insert

func (r *RemoteProofLinks) Insert(link RemoteProofChainLink, err ProofError)

Insert adds a link to the collection of proof links.

func (*RemoteProofLinks) TrackSet

func (r *RemoteProofLinks) TrackSet() *TrackSet

TrackSet creates a new TrackSet with all the active proofs.

func (*RemoteProofLinks) TrackingStatement

func (r *RemoteProofLinks) TrackingStatement() *jsonw.Wrapper

TrackingStatement generates the remote proofs portions of the tracking statement from the active proofs.

type RemoteStream

type RemoteStream struct {
	Stream    keybase1.Stream
	Cli       *keybase1.StreamUiClient
	SessionID int
}

func (RemoteStream) Close

func (ewc RemoteStream) Close() (err error)

func (RemoteStream) Read

func (ewc RemoteStream) Read(buf []byte) (n int, err error)

func (RemoteStream) Reset

func (ewc RemoteStream) Reset() (err error)

func (RemoteStream) Write

func (ewc RemoteStream) Write(buf []byte) (n int, err error)

type RemoteStreamBuffered

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

func NewRemoteStreamBuffered

func NewRemoteStreamBuffered(s keybase1.Stream, c *keybase1.StreamUiClient, sessionID int) *RemoteStreamBuffered

func (*RemoteStreamBuffered) Close

func (x *RemoteStreamBuffered) Close() error

func (*RemoteStreamBuffered) Read

func (x *RemoteStreamBuffered) Read(p []byte) (int, error)

func (*RemoteStreamBuffered) Reset

func (x *RemoteStreamBuffered) Reset() (err error)

func (*RemoteStreamBuffered) Write

func (x *RemoteStreamBuffered) Write(p []byte) (int, error)

type RepoAlreadyExistsError

type RepoAlreadyExistsError struct {
	DesiredName  string
	ExistingName string
	ExistingID   string
}

RepoAlreadyCreatedError is returned when trying to create a repo that already exists.

func (RepoAlreadyExistsError) Error

func (e RepoAlreadyExistsError) Error() string

func (RepoAlreadyExistsError) ToStatus

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

type RepoDoesntExistError

type RepoDoesntExistError struct {
	Name string
}

RepoDoesntExistError is returned when trying to delete a repo that doesn't exist.

func (RepoDoesntExistError) Error

func (e RepoDoesntExistError) Error() string

func (RepoDoesntExistError) ToStatus

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

type ReportingTimer

type ReportingTimer interface {
	Report(prefix string)
}

ReportingTimer is an interface shared between ReportingTimerReal and ReportingTimerDummy, to allow for convenient disabling of timer features.

type ReportingTimerDummy

type ReportingTimerDummy struct{}

ReportingTimerDummy fulfills the ReportingTimer interface but doesn't do anything when done.

func (ReportingTimerDummy) Report

func (r ReportingTimerDummy) Report(prefix string)

Report is a noop.

type ReportingTimerReal

type ReportingTimerReal struct {
	SimpleTimer
	Contextified
}

ReportingTimerReal is a SimpleTimer that reports after the timing measurement is done.

func NewReportingTimerReal

func NewReportingTimerReal(ctx Contextified) *ReportingTimerReal

NewReportingTimerReal returns an initialized reporting timer that actually reports timing information.

func (*ReportingTimerReal) Report

func (r *ReportingTimerReal) Report(prefix string)

Report stops and resets the timer, then logs to Info what the duration was.

type Requester

type Requester interface {
	// contains filtered or unexported methods
}

Internal and External APIs both implement these methods, allowing us to share the request-making code below in doRequest

type ResetMissingParamsError

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

func (ResetMissingParamsError) Error

func (e ResetMissingParamsError) Error() string

type ResetWithActiveDeviceError

type ResetWithActiveDeviceError struct {
}

func (ResetWithActiveDeviceError) Error

type ResolutionError

type ResolutionError struct {
	Input string
	Msg   string
	Kind  ResolutionErrorKind
}

func (ResolutionError) Error

func (e ResolutionError) Error() string

func (ResolutionError) ToStatus

func (e ResolutionError) ToStatus() keybase1.Status

type ResolutionErrorKind

type ResolutionErrorKind int
const (
	ResolutionErrorGeneral ResolutionErrorKind = iota
	ResolutionErrorNotFound
	ResolutionErrorAmbiguous
	ResolutionErrorRateLimited
	ResolutionErrorInvalidInput
	ResolutionErrorRequestFailed
)

type ResolveCacheStats

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

func (*ResolveCacheStats) Eq

func (s *ResolveCacheStats) Eq(m, t, mt, et, h int) bool

func (*ResolveCacheStats) EqWithDiskHits

func (s *ResolveCacheStats) EqWithDiskHits(m, t, mt, et, h, dh int) bool

func (*ResolveCacheStats) IncDiskGetHits

func (s *ResolveCacheStats) IncDiskGetHits()

func (*ResolveCacheStats) IncDiskGetMisses

func (s *ResolveCacheStats) IncDiskGetMisses()

func (*ResolveCacheStats) IncDiskGets

func (s *ResolveCacheStats) IncDiskGets()

func (*ResolveCacheStats) IncDiskPuts

func (s *ResolveCacheStats) IncDiskPuts()

func (*ResolveCacheStats) IncErrorTimeouts

func (s *ResolveCacheStats) IncErrorTimeouts()

func (*ResolveCacheStats) IncHits

func (s *ResolveCacheStats) IncHits()

func (*ResolveCacheStats) IncMisses

func (s *ResolveCacheStats) IncMisses()

func (*ResolveCacheStats) IncMutableTimeouts

func (s *ResolveCacheStats) IncMutableTimeouts()

func (*ResolveCacheStats) IncTimeouts

func (s *ResolveCacheStats) IncTimeouts()

type ResolveResult

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

func (ResolveResult) FailOnDeleted

func (res ResolveResult) FailOnDeleted() ResolveResult

func (*ResolveResult) GetBody

func (res *ResolveResult) GetBody() *jsonw.Wrapper

func (*ResolveResult) GetDeleted

func (res *ResolveResult) GetDeleted() bool

func (*ResolveResult) GetError

func (res *ResolveResult) GetError() error

func (*ResolveResult) GetNormalizedQueriedUsername

func (res *ResolveResult) GetNormalizedQueriedUsername() NormalizedUsername

func (*ResolveResult) GetNormalizedUsername

func (res *ResolveResult) GetNormalizedUsername() NormalizedUsername

func (*ResolveResult) GetTeamID

func (res *ResolveResult) GetTeamID() keybase1.TeamID

func (*ResolveResult) GetTeamName

func (res *ResolveResult) GetTeamName() keybase1.TeamName

func (*ResolveResult) GetUID

func (res *ResolveResult) GetUID() keybase1.UID

func (*ResolveResult) GetUsername

func (res *ResolveResult) GetUsername() string

func (ResolveResult) HasPrimaryKey

func (res ResolveResult) HasPrimaryKey() bool

func (ResolveResult) IsServerTrust

func (res ResolveResult) IsServerTrust() bool

func (*ResolveResult) SetUIDForTesting

func (res *ResolveResult) SetUIDForTesting(u keybase1.UID)

func (ResolveResult) String

func (res ResolveResult) String() string

func (*ResolveResult) User

func (res *ResolveResult) User() keybase1.User

func (*ResolveResult) UserOrTeam

func (res *ResolveResult) UserOrTeam() keybase1.UserOrTeamLite

func (*ResolveResult) WasKBAssertion

func (res *ResolveResult) WasKBAssertion() bool

func (*ResolveResult) WasTeamIDAssertion

func (res *ResolveResult) WasTeamIDAssertion() bool

type ResolvedAssertion

type ResolvedAssertion struct {
	UID           keybase1.UID
	Assertion     AssertionExpression
	ResolveResult ResolveResult
}

type Resolver

type Resolver interface {
	EnableCaching(m MetaContext)
	Shutdown(m MetaContext)
	ResolveFullExpression(m MetaContext, input string) (res ResolveResult)
	ResolveFullExpressionNeedUsername(m MetaContext, input string) (res ResolveResult)
	ResolveFullExpressionWithBody(m MetaContext, input string) (res ResolveResult)
	ResolveUser(m MetaContext, assertion string) (u keybase1.User, res ResolveResult, err error)
	ResolveWithBody(m MetaContext, input string) ResolveResult
	Resolve(m MetaContext, input string) ResolveResult
	PurgeResolveCache(m MetaContext, input string) error
	CacheTeamResolution(m MetaContext, id keybase1.TeamID, name keybase1.TeamName)
}

Resolver resolves human-readable usernames (joe) and user asssertions (joe+joe@github) into UIDs. It is based on sever-trust. All results are unverified. So you should check its answer if used in a security-sensitive setting. (See engine.ResolveAndCheck)

type ResolverImpl

type ResolverImpl struct {
	Stats *ResolveCacheStats
	// contains filtered or unexported fields
}

func NewResolverImpl

func NewResolverImpl() *ResolverImpl

func (*ResolverImpl) CacheTeamResolution

func (r *ResolverImpl) CacheTeamResolution(m MetaContext, id keybase1.TeamID, name keybase1.TeamName)

func (*ResolverImpl) EnableCaching

func (r *ResolverImpl) EnableCaching(m MetaContext)

func (*ResolverImpl) PurgeResolveCache

func (r *ResolverImpl) PurgeResolveCache(m MetaContext, input string) (err error)

func (*ResolverImpl) Resolve

func (r *ResolverImpl) Resolve(m MetaContext, input string) ResolveResult

func (*ResolverImpl) ResolveFullExpression

func (r *ResolverImpl) ResolveFullExpression(m MetaContext, input string) (res ResolveResult)

func (*ResolverImpl) ResolveFullExpressionNeedUsername

func (r *ResolverImpl) ResolveFullExpressionNeedUsername(m MetaContext, input string) (res ResolveResult)

func (*ResolverImpl) ResolveFullExpressionWithBody

func (r *ResolverImpl) ResolveFullExpressionWithBody(m MetaContext, input string) (res ResolveResult)

func (*ResolverImpl) ResolveUser

func (r *ResolverImpl) ResolveUser(m MetaContext, assertion string) (u keybase1.User, res ResolveResult, err error)

func (*ResolverImpl) ResolveWithBody

func (r *ResolverImpl) ResolveWithBody(m MetaContext, input string) ResolveResult

func (*ResolverImpl) Shutdown

func (r *ResolverImpl) Shutdown(m MetaContext)

type RetryExhaustedError

type RetryExhaustedError struct {
}

func (RetryExhaustedError) Error

func (e RetryExhaustedError) Error() string

type ReverseSigError

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

func NewReverseSigError

func NewReverseSigError(msgf string, a ...interface{}) ReverseSigError

func (ReverseSigError) Error

func (r ReverseSigError) Error() string
type RevokeChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseRevokeChainLink(b GenericChainLink) (ret *RevokeChainLink, err error)

func (*RevokeChainLink) GetDevice

func (r *RevokeChainLink) GetDevice() *Device

func (*RevokeChainLink) IsRevocationIsh

func (r *RevokeChainLink) IsRevocationIsh() bool

func (*RevokeChainLink) ToDisplayString

func (r *RevokeChainLink) ToDisplayString() string

func (*RevokeChainLink) Type

func (r *RevokeChainLink) Type() string

type RevokeCurrentDeviceError

type RevokeCurrentDeviceError struct{}

func (RevokeCurrentDeviceError) Error

func (e RevokeCurrentDeviceError) Error() string

func (RevokeCurrentDeviceError) ToStatus

type RevokeLastDeviceError

type RevokeLastDeviceError struct{ NoPassphrase bool }

func (RevokeLastDeviceError) Error

func (e RevokeLastDeviceError) Error() string

func (RevokeLastDeviceError) ToStatus

func (e RevokeLastDeviceError) ToStatus() keybase1.Status

type RevokeLastDevicePGPError

type RevokeLastDevicePGPError struct{}

users with PGP keys who try to revoke last device get this:

func (RevokeLastDevicePGPError) Error

func (e RevokeLastDevicePGPError) Error() string

func (RevokeLastDevicePGPError) ToStatus

type RevokedKey

type RevokedKey struct {
	Key       GenericKey
	RevokedAt *KeybaseTime
	RevokedBy keybase1.KID
}

type RunGpg2Arg

type RunGpg2Arg struct {
	Arguments []string
	Stdin     bool
	Stderr    bool
	Stdout    bool
	TTY       string
}

type RunGpg2Res

type RunGpg2Res struct {
	Stdin  io.WriteCloser
	Stdout io.ReadCloser
	Stderr io.ReadCloser
	Wait   func() error
	Err    error
}

type RunMode

type RunMode = kbconst.RunMode
const (
	DevelRunMode      RunMode = kbconst.DevelRunMode
	StagingRunMode    RunMode = kbconst.StagingRunMode
	ProductionRunMode RunMode = kbconst.ProductionRunMode
	RunModeError      RunMode = kbconst.RunModeError
	NoRunMode         RunMode = kbconst.NoRunMode
)

func StringToRunMode

func StringToRunMode(s string) (RunMode, error)

StringToRunMode turns a string into a run-mode

type RunModeGetter

type RunModeGetter func() RunMode

type RuntimeStats

type RuntimeStats interface {
	Start(context.Context)
	Stop(context.Context) chan struct{}
	PushPerfEvent(keybase1.PerfEvent)
}

type S

type S struct {
	Val string
}

func B64Arg

func B64Arg(b []byte) S

func HexArg

func HexArg(b []byte) S

func (S) String

func (s S) String() string

type SKB

type SKB struct {
	Priv SKBPriv           `codec:"priv"`
	Pub  []byte            `codec:"pub"`
	Type kbcrypto.AlgoType `codec:"type,omitempty"`

	Contextified

	sync.Mutex // currently only for uid
	// contains filtered or unexported fields
}

func DecodeArmoredSKBPacket

func DecodeArmoredSKBPacket(s string) (*SKB, error)

func DecodeSKBPacket

func DecodeSKBPacket(data []byte) (*SKB, error)

func LockedLocalSecretKey

func LockedLocalSecretKey(m MetaContext, ska SecretKeyArg) (*SKB, error)

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

func NewSKB

func NewSKB() *SKB

func NewSKBWithGlobalContext

func NewSKBWithGlobalContext(g *GlobalContext) *SKB

func ToServerSKB

func ToServerSKB(gc *GlobalContext, key GenericKey, tsec Triplesec, gen PassphraseGeneration) (ret *SKB, err error)

func WriteLksSKBToKeyring

func WriteLksSKBToKeyring(m MetaContext, k GenericKey, lks *LKSec) (skb *SKB, err error)

func (*SKB) ArmoredEncode

func (s *SKB) ArmoredEncode() (ret string, err error)

func (*SKB) Dump

func (s *SKB) Dump()

func (*SKB) GetPubKey

func (s *SKB) GetPubKey() (key GenericKey, err error)

func (*SKB) GetTagAndVersion

func (s *SKB) GetTagAndVersion() (kbcrypto.PacketTag, kbcrypto.PacketVersion)

func (*SKB) HumanDescription

func (s *SKB) HumanDescription(owner *User) (string, error)

func (*SKB) PromptAndUnlock

func (s *SKB) PromptAndUnlock(m MetaContext, arg SecretKeyPromptArg, secretStore SecretStore, me *User) (ret GenericKey, err error)

func (*SKB) RawUnlockedKey

func (s *SKB) RawUnlockedKey() []byte

func (*SKB) ReadKey

func (s *SKB) ReadKey() (g GenericKey, err error)

func (*SKB) SetUID

func (s *SKB) SetUID(uid keybase1.UID)

func (*SKB) UnlockNoPrompt

func (s *SKB) UnlockNoPrompt(m MetaContext, secretStore SecretStore) (ret GenericKey, err error)

func (*SKB) UnlockSecretKey

func (s *SKB) UnlockSecretKey(m MetaContext, passphrase string, tsec Triplesec, pps *PassphraseStream, secretStorer SecretStorer) (key GenericKey, err error)

func (*SKB) UnlockWithStoredSecret

func (s *SKB) UnlockWithStoredSecret(m MetaContext, secretRetriever SecretRetriever) (ret GenericKey, err error)

func (*SKB) VerboseDescription

func (s *SKB) VerboseDescription() (ret string, err error)

type SKBKeyringFile

type SKBKeyringFile struct {
	Contextified
	sync.Mutex

	Blocks []*SKB
	// contains filtered or unexported fields
}

func LoadSKBKeyring

func LoadSKBKeyring(m MetaContext, un NormalizedUsername) (*SKBKeyringFile, error)

func LoadSKBKeyringFromMetaContext

func LoadSKBKeyringFromMetaContext(m MetaContext) (*SKBKeyringFile, error)

func NewSKBKeyringFile

func NewSKBKeyringFile(g *GlobalContext, un NormalizedUsername) *SKBKeyringFile

func (*SKBKeyringFile) AllPGPBlocks

func (k *SKBKeyringFile) AllPGPBlocks() ([]*SKB, error)

func (*SKBKeyringFile) Bug3964Repair

func (k *SKBKeyringFile) Bug3964Repair(m MetaContext, lks *LKSec, dkm DeviceKeyMap) (ret *SKBKeyringFile, serverHalfSet *LKSecServerHalfSet, err error)

func (*SKBKeyringFile) FindSecretKey

func (k *SKBKeyringFile) FindSecretKey(kids []keybase1.KID) (ret *SKB)

FindSecretKey will, given a list of KIDs, find the first one in the list that has a corresponding secret key in the keyring file.

func (*SKBKeyringFile) GetFilename

func (k *SKBKeyringFile) GetFilename() string

GetFilename is only called from within Save(), so it's called with a lock. Needs to be called GetFilename() to meet the interface required by SafeSaveToFile

func (*SKBKeyringFile) HasPGPKeys

func (k *SKBKeyringFile) HasPGPKeys() bool

func (*SKBKeyringFile) Index

func (k *SKBKeyringFile) Index() (err error)

func (*SKBKeyringFile) IsForUsername

func (k *SKBKeyringFile) IsForUsername(un NormalizedUsername) bool

func (*SKBKeyringFile) Load

func (k *SKBKeyringFile) Load(ctx context.Context) (err error)

func (*SKBKeyringFile) LoadAndIndex

func (k *SKBKeyringFile) LoadAndIndex(ctx context.Context) error

func (*SKBKeyringFile) LookupByFingerprint

func (k *SKBKeyringFile) LookupByFingerprint(fp PGPFingerprint) *SKB

func (*SKBKeyringFile) LookupByKid

func (k *SKBKeyringFile) LookupByKid(kid keybase1.KID) *SKB

func (*SKBKeyringFile) MTime

func (k *SKBKeyringFile) MTime() (mtime time.Time, err error)

func (*SKBKeyringFile) MarkDirty

func (k *SKBKeyringFile) MarkDirty()

func (*SKBKeyringFile) Push

func (k *SKBKeyringFile) Push(skb *SKB) error

func (*SKBKeyringFile) PushAndSave

func (k *SKBKeyringFile) PushAndSave(skb *SKB) error

func (*SKBKeyringFile) RemoveAllPGPBlocks

func (k *SKBKeyringFile) RemoveAllPGPBlocks() error

func (*SKBKeyringFile) Save

func (k *SKBKeyringFile) Save() error

func (*SKBKeyringFile) SearchWithComputedKeyFamily

func (k *SKBKeyringFile) SearchWithComputedKeyFamily(ckf *ComputedKeyFamily, ska SecretKeyArg) []*SKB

func (*SKBKeyringFile) Username

func (k *SKBKeyringFile) Username() NormalizedUsername

func (*SKBKeyringFile) WriteTo

func (k *SKBKeyringFile) WriteTo(w io.Writer) (n int64, err error)

WriteTo is similar to GetFilename described just above in terms of locking discipline.

type SKBPriv

type SKBPriv struct {
	Data                 []byte `codec:"data"`
	Encryption           int    `codec:"encryption"`
	PassphraseGeneration int    `codec:"passphrase_generation,omitempty"`
}

type SafeWriteLogger

type SafeWriteLogger interface {
	Debug(format string, args ...interface{})
	Errorf(format string, args ...interface{})
}

type SafeWriter

type SafeWriter interface {
	GetFilename() string
	WriteTo(io.Writer) (int64, error)
}

type SaltpackEncryptArg

type SaltpackEncryptArg struct {
	Source             io.Reader
	Sink               io.WriteCloser
	Receivers          []NaclDHKeyPublic
	Sender             NaclDHKeyPair
	SenderSigning      NaclSigningKeyPair
	Binary             bool
	EncryptionOnlyMode bool
	SymmetricReceivers []saltpack.ReceiverSymmetricKey
	SaltpackVersion    saltpack.Version

	VisibleRecipientsForTesting bool
}

type SaltpackReceiverSymmetricKey

type SaltpackReceiverSymmetricKey struct {
	Key        [32]byte
	Identifier []byte
}

type SaltpackRecipientKeyfinderArg

type SaltpackRecipientKeyfinderArg struct {
	Recipients        []string // usernames or user assertions
	TeamRecipients    []string // team names
	NoSelfEncrypt     bool
	UseEntityKeys     bool // Both per user and per team keys (and implicit teams for non existing users)
	UsePaperKeys      bool
	UseDeviceKeys     bool // Does not include Paper Keys
	UseRepudiableAuth bool // This is needed as team keys (implicit or not) are not compatible with repudiable authentication, so we can error out.
	NoForcePoll       bool // if we want to stop forcepolling, which is on by default, but should be off for GUI
}

type SaltpackRecipientKeyfinderEngineInterface

type SaltpackRecipientKeyfinderEngineInterface interface {
	Engine2
	GetPublicKIDs() []keybase1.KID
	GetSymmetricKeys() []SaltpackReceiverSymmetricKey
	UsedUnresolvedSBSAssertion() (bool, string)
}

type SaltpackUI

type SaltpackUI interface {
	SaltpackPromptForDecrypt(context.Context, keybase1.SaltpackPromptForDecryptArg, bool) error
	SaltpackVerifySuccess(context.Context, keybase1.SaltpackVerifySuccessArg) error
	SaltpackVerifyBadSender(context.Context, keybase1.SaltpackVerifyBadSenderArg) error
}

type SaltpackVerifyContext

type SaltpackVerifyContext interface {
	GetLog() logger.Logger
}

SaltpackVerifyContext is context for engine calls

type SecretKeyArg

type SecretKeyArg struct {
	// Whose keys to use. Must be non-nil.
	Me *User

	// The allowed key types.
	KeyType SecretKeyType

	// For non-device keys, a string that the key has to match. If
	// empty, any valid key is allowed.
	KeyQuery   string
	ExactMatch bool // if set, full equality required
}

type SecretKeyPromptArg

type SecretKeyPromptArg struct {
	Ska            SecretKeyArg
	SecretUI       SecretUI
	Reason         string
	UseCancelCache bool /* if true, when user cancels prompt, don't prompt again for 5m */
}

type SecretKeyType

type SecretKeyType int
const (
	// The current device signing key.
	DeviceSigningKeyType SecretKeyType = iota
	// The current device encryption key.
	DeviceEncryptionKeyType
	// A PGP key (including the synced PGP key, if there is one).
	PGPKeyType
)

func (SecretKeyType) String

func (t SecretKeyType) String() string

type SecretRetriever

type SecretRetriever interface {
	RetrieveSecret(m MetaContext) (LKSecFullSecret, error)
}

type SecretStore

type SecretStore interface {
	SecretRetriever
	SecretStorer
	GetOptions(mctx MetaContext) *SecretStoreOptions
	SetOptions(mctx MetaContext, options *SecretStoreOptions)
}

SecretStore stores/retreives the keyring-resident secrets for a given user.

func NewSecretStore

func NewSecretStore(m MetaContext, username NormalizedUsername) SecretStore

NewSecretStore returns a SecretStore interface that is only used for a short period of time (i.e. one function block). Multiple calls to RetrieveSecret() will only call the underlying store.RetrieveSecret once.

type SecretStoreAll

type SecretStoreAll interface {
	RetrieveSecret(mctx MetaContext, username NormalizedUsername) (LKSecFullSecret, error)
	StoreSecret(mctx MetaContext, username NormalizedUsername, secret LKSecFullSecret) error
	GetOptions(mctx MetaContext) *SecretStoreOptions
	SetOptions(mctx MetaContext, options *SecretStoreOptions)
	ClearSecret(mctx MetaContext, username NormalizedUsername) error
	GetUsersWithStoredSecrets(mctx MetaContext) ([]string, error)
}

SecretStoreall stores/retreives the keyring-resider secrets for **all** users on this system.

func NewSecretStoreAll

func NewSecretStoreAll(mctx MetaContext) SecretStoreAll

type SecretStoreError

type SecretStoreError struct {
	Msg string
}

func NewErrSecretForUserNotFound

func NewErrSecretForUserNotFound(username NormalizedUsername) SecretStoreError

func (SecretStoreError) Error

func (e SecretStoreError) Error() string

type SecretStoreFallbackBehavior

type SecretStoreFallbackBehavior int
const (
	SecretStoreFallbackBehaviorOnError SecretStoreFallbackBehavior = iota
	SecretStoreFallbackBehaviorAlways
	SecretStoreFallbackBehaviorNever
)

type SecretStoreFile

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

func NewSecretStoreFile

func NewSecretStoreFile(dir string) *SecretStoreFile

func (*SecretStoreFile) ClearSecret

func (s *SecretStoreFile) ClearSecret(mctx MetaContext, username NormalizedUsername) (err error)

func (*SecretStoreFile) GetOptions

func (*SecretStoreFile) GetUsersWithStoredSecrets

func (s *SecretStoreFile) GetUsersWithStoredSecrets(mctx MetaContext) (users []string, err error)

func (*SecretStoreFile) RetrieveSecret

func (s *SecretStoreFile) RetrieveSecret(mctx MetaContext, username NormalizedUsername) (secret LKSecFullSecret, err error)

func (*SecretStoreFile) SetOptions

func (*SecretStoreFile) StoreSecret

func (s *SecretStoreFile) StoreSecret(mctx MetaContext, username NormalizedUsername, secret LKSecFullSecret) (err error)

type SecretStoreImp

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

SecretStoreImp is a specialization of a SecretStoreAll for just one username. You specify that username at the time on construction and then it doesn't change.

func (*SecretStoreImp) GetOptions

func (s *SecretStoreImp) GetOptions(mctx MetaContext) *SecretStoreOptions

func (*SecretStoreImp) RetrieveSecret

func (s *SecretStoreImp) RetrieveSecret(m MetaContext) (LKSecFullSecret, error)

func (*SecretStoreImp) SetOptions

func (s *SecretStoreImp) SetOptions(mctx MetaContext, options *SecretStoreOptions)

func (*SecretStoreImp) StoreSecret

func (s *SecretStoreImp) StoreSecret(m MetaContext, secret LKSecFullSecret) error

type SecretStoreLocked

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

SecretStoreLocked protects a SecretStoreAll with a mutex. It wraps two different SecretStoreAlls: one in memory and one in disk. In all cases, we always have a memory backing. If the OS and options provide one, we can additionally have a disk-backed secret store. It's a write-through cache, so on RetrieveSecret, the memory store will be checked first, and then the disk store.

func NewSecretStoreLocked

func NewSecretStoreLocked(m MetaContext) *SecretStoreLocked

func (*SecretStoreLocked) ClearMem

func (s *SecretStoreLocked) ClearMem()

func (*SecretStoreLocked) ClearSecret

func (s *SecretStoreLocked) ClearSecret(m MetaContext, username NormalizedUsername) error

func (*SecretStoreLocked) GetOptions

func (s *SecretStoreLocked) GetOptions(mctx MetaContext) *SecretStoreOptions

func (*SecretStoreLocked) GetUsersWithStoredSecrets

func (s *SecretStoreLocked) GetUsersWithStoredSecrets(m MetaContext) ([]string, error)

func (*SecretStoreLocked) IsPersistent

func (s *SecretStoreLocked) IsPersistent() bool

func (*SecretStoreLocked) PrimeSecretStores

func (s *SecretStoreLocked) PrimeSecretStores(mctx MetaContext) (err error)

func (*SecretStoreLocked) RetrieveSecret

func (s *SecretStoreLocked) RetrieveSecret(m MetaContext, username NormalizedUsername) (LKSecFullSecret, error)

func (*SecretStoreLocked) SetOptions

func (s *SecretStoreLocked) SetOptions(mctx MetaContext, options *SecretStoreOptions)

func (*SecretStoreLocked) StoreSecret

func (s *SecretStoreLocked) StoreSecret(m MetaContext, username NormalizedUsername, secret LKSecFullSecret) error

type SecretStoreMem

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

func NewSecretStoreMem

func NewSecretStoreMem() *SecretStoreMem

func (*SecretStoreMem) ClearSecret

func (s *SecretStoreMem) ClearSecret(m MetaContext, username NormalizedUsername) error

func (*SecretStoreMem) GetOptions

func (*SecretStoreMem) GetUsersWithStoredSecrets

func (s *SecretStoreMem) GetUsersWithStoredSecrets(m MetaContext) ([]string, error)

func (*SecretStoreMem) RetrieveSecret

func (s *SecretStoreMem) RetrieveSecret(m MetaContext, username NormalizedUsername) (LKSecFullSecret, error)

func (*SecretStoreMem) SetOptions

func (*SecretStoreMem) StoreSecret

func (s *SecretStoreMem) StoreSecret(m MetaContext, username NormalizedUsername, secret LKSecFullSecret) error

type SecretStoreOptions

type SecretStoreOptions struct {
	RandomPw bool
}

func DefaultSecretStoreOptions

func DefaultSecretStoreOptions() SecretStoreOptions

func LoadAdvisorySecretStoreOptionsFromRemote

func LoadAdvisorySecretStoreOptionsFromRemote(mctx MetaContext) (options SecretStoreOptions)

type SecretStoreRevokableSecretService

type SecretStoreRevokableSecretService struct{}

func NewSecretStoreRevokableSecretService

func NewSecretStoreRevokableSecretService() *SecretStoreRevokableSecretService

func (*SecretStoreRevokableSecretService) ClearSecret

func (s *SecretStoreRevokableSecretService) ClearSecret(mctx MetaContext, username NormalizedUsername) (err error)

func (*SecretStoreRevokableSecretService) GetOptions

func (*SecretStoreRevokableSecretService) GetUsersWithStoredSecrets

func (s *SecretStoreRevokableSecretService) GetUsersWithStoredSecrets(mctx MetaContext) (usernames []string, err error)

Note that in the case of corruption, not all of these usernames may actually be able to be logged in as due to the noise file being corrupted, the keyring being uninstalled, etc.

func (*SecretStoreRevokableSecretService) RetrieveSecret

func (s *SecretStoreRevokableSecretService) RetrieveSecret(mctx MetaContext, username NormalizedUsername) (secret LKSecFullSecret, err error)

func (*SecretStoreRevokableSecretService) SetOptions

func (*SecretStoreRevokableSecretService) StoreSecret

func (s *SecretStoreRevokableSecretService) StoreSecret(mctx MetaContext, username NormalizedUsername, secret LKSecFullSecret) (err error)

type SecretStoreUpgradeable

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

func NewSecretStoreUpgradeable

func NewSecretStoreUpgradeable(a, b SecretStoreAll, labelA, labelB string, shouldUpgradeOpportunistically func() bool, shouldStoreInFallback func(*SecretStoreOptions) SecretStoreFallbackBehavior) *SecretStoreUpgradeable

func (*SecretStoreUpgradeable) ClearSecret

func (s *SecretStoreUpgradeable) ClearSecret(mctx MetaContext, username NormalizedUsername) (err error)

func (*SecretStoreUpgradeable) GetOptions

func (*SecretStoreUpgradeable) GetUsersWithStoredSecrets

func (s *SecretStoreUpgradeable) GetUsersWithStoredSecrets(mctx MetaContext) (usernames []string, err error)

func (*SecretStoreUpgradeable) RetrieveSecret

func (s *SecretStoreUpgradeable) RetrieveSecret(mctx MetaContext, username NormalizedUsername) (secret LKSecFullSecret, err error)

func (*SecretStoreUpgradeable) SetOptions

func (s *SecretStoreUpgradeable) SetOptions(_ MetaContext, options *SecretStoreOptions)

func (*SecretStoreUpgradeable) StoreSecret

func (s *SecretStoreUpgradeable) StoreSecret(mctx MetaContext, username NormalizedUsername, secret LKSecFullSecret) (err error)

type SecretStorer

type SecretStorer interface {
	StoreSecret(m MetaContext, secret LKSecFullSecret) error
}

type SecretSyncer

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

func NewSecretSyncer

func NewSecretSyncer(g *GlobalContext) *SecretSyncer

func (*SecretSyncer) ActiveDevices

func (ss *SecretSyncer) ActiveDevices(includeTypesSet DeviceTypeSet) (DeviceKeyMap, error)

ActiveDevices returns all the active desktop and mobile devices.

func (*SecretSyncer) AllActiveKeys

func (ss *SecretSyncer) AllActiveKeys(ckf *ComputedKeyFamily) []*SKB

AllActiveKeys returns all the active synced PGP keys.

func (*SecretSyncer) AllDevices

func (ss *SecretSyncer) AllDevices() DeviceKeyMap

func (*SecretSyncer) Clear

func (ss *SecretSyncer) Clear() error

func (*SecretSyncer) Devices

func (ss *SecretSyncer) Devices() (DeviceKeyMap, error)

func (*SecretSyncer) DumpPrivateKeys

func (ss *SecretSyncer) DumpPrivateKeys()

func (*SecretSyncer) FindActiveKey

func (ss *SecretSyncer) FindActiveKey(ckf *ComputedKeyFamily) (ret *SKB, err error)

FindActiveKey examines the synced keys, looking for one that's currently active. The key will be chosen at random due to non-deterministic order of FindActiveKeys output. Returns ret=nil if none was found.

func (*SecretSyncer) FindActiveKeys

func (ss *SecretSyncer) FindActiveKeys(ckf *ComputedKeyFamily) (ret []*SKB, err error)

FindActiveKey examines the synced keys, and returns keys that are currently active.

func (*SecretSyncer) FindDevice

func (ss *SecretSyncer) FindDevice(id keybase1.DeviceID) (DeviceKey, error)

func (*SecretSyncer) FindPrivateKey

func (ss *SecretSyncer) FindPrivateKey(kid string) (ServerPrivateKey, bool)

func (*SecretSyncer) HasActiveDevice

func (ss *SecretSyncer) HasActiveDevice(includeTypesSet DeviceTypeSet) (bool, error)

HasActiveDevice returns true if there is an active desktop or mobile device available.

func (*SecretSyncer) HasDevices

func (ss *SecretSyncer) HasDevices() bool

func (*SecretSyncer) IsDeviceNameTaken

func (ss *SecretSyncer) IsDeviceNameTaken(name string, includeTypesSet DeviceTypeSet) bool

IsDeviceNameTaken returns true if a desktop or mobile device is using a name already.

type SecretUI

type SecretUI interface {
	GetPassphrase(pinentry keybase1.GUIEntryArg, terminal *keybase1.SecretEntryArg) (keybase1.GetPassphraseRes, error)
}

type SecretlessErasableKVStore

type SecretlessErasableKVStore interface {
	Erase(mctx MetaContext, key string) error
	AllKeys(mctx MetaContext, keySuffix string) ([]string, error)
}

func NewSecretlessFileErasableKVStore

func NewSecretlessFileErasableKVStore(mctx MetaContext, subDir string) SecretlessErasableKVStore

type SecureRandom

type SecureRandom struct{}

SecureRandom internally uses the cryptographically secure crypto/rand as a source of randomness.

func (*SecureRandom) RndRange

func (r *SecureRandom) RndRange(low, high int64) (res int64, err error)

type SelfDestructingDeviceWithKeys

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

func (*SelfDestructingDeviceWithKeys) DeviceWithKeys

func (s *SelfDestructingDeviceWithKeys) DeviceWithKeys() *DeviceWithKeys

func (*SelfDestructingDeviceWithKeys) SetTestPostCleanHook

func (s *SelfDestructingDeviceWithKeys) SetTestPostCleanHook(f func())

type SelfNotFoundError

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

func (SelfNotFoundError) Error

func (e SelfNotFoundError) Error() string

func (SelfNotFoundError) ToStatus

func (e SelfNotFoundError) ToStatus() keybase1.Status
type SelfSigChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseSelfSigChainLink(base GenericChainLink) (ret *SelfSigChainLink, err error)

func (*SelfSigChainLink) CheckDataJSON

func (s *SelfSigChainLink) CheckDataJSON() *jsonw.Wrapper

func (*SelfSigChainLink) ComputeTrackDiff

func (s *SelfSigChainLink) ComputeTrackDiff(tl *TrackLookup) TrackDiff

func (*SelfSigChainLink) DisplayCheck

func (s *SelfSigChainLink) DisplayCheck(m MetaContext, ui IdentifyUI, lcr LinkCheckResult) error

func (*SelfSigChainLink) DisplayPriorityKey

func (s *SelfSigChainLink) DisplayPriorityKey() string

func (*SelfSigChainLink) GetDevice

func (s *SelfSigChainLink) GetDevice() *Device

func (*SelfSigChainLink) GetHostname

func (s *SelfSigChainLink) GetHostname() string

func (*SelfSigChainLink) GetPGPFullHash

func (s *SelfSigChainLink) GetPGPFullHash() string

func (*SelfSigChainLink) GetProofType

func (s *SelfSigChainLink) GetProofType() keybase1.ProofType

func (*SelfSigChainLink) GetProtocol

func (s *SelfSigChainLink) GetProtocol() string

func (*SelfSigChainLink) GetRemoteUsername

func (s *SelfSigChainLink) GetRemoteUsername() string

func (*SelfSigChainLink) LastWriterWins

func (s *SelfSigChainLink) LastWriterWins() bool

func (*SelfSigChainLink) ParseDevice

func (s *SelfSigChainLink) ParseDevice() (err error)

func (*SelfSigChainLink) ProofText

func (s *SelfSigChainLink) ProofText() string

func (*SelfSigChainLink) TableKey

func (s *SelfSigChainLink) TableKey() string

func (*SelfSigChainLink) ToDisplayString

func (s *SelfSigChainLink) ToDisplayString() string

func (*SelfSigChainLink) ToIDString

func (s *SelfSigChainLink) ToIDString() string

func (*SelfSigChainLink) ToKeyValuePair

func (s *SelfSigChainLink) ToKeyValuePair() (string, string)

func (*SelfSigChainLink) ToTrackingStatement

func (s *SelfSigChainLink) ToTrackingStatement(keybase1.ProofState) (*jsonw.Wrapper, error)

func (*SelfSigChainLink) Type

func (s *SelfSigChainLink) Type() string

type SelfTrackError

type SelfTrackError struct{}

func (SelfTrackError) Error

func (e SelfTrackError) Error() string

type Server

type Server interface {
}

type ServerChainError

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

func NewServerChainError

func NewServerChainError(d string, a ...interface{}) ServerChainError

func (ServerChainError) Error

func (e ServerChainError) Error() string

type ServerPrivateKey

type ServerPrivateKey struct {
	Kid     string  `json:"kid"`
	KeyType KeyType `json:"key_type"`
	Bundle  string  `json:"bundle"`
	Mtime   int     `json:"mtime"`
	Ctime   int     `json:"ctime"`
	KeyBits int     `json:"key_bits"`
	KeyAlgo int     `json:"key_algo"`
}

func (*ServerPrivateKey) FindActiveKey

func (k *ServerPrivateKey) FindActiveKey(g *GlobalContext, ckf *ComputedKeyFamily) (ret *SKB, err error)

func (ServerPrivateKey) ToSKB

func (k ServerPrivateKey) ToSKB(gc *GlobalContext) (*SKB, error)

type ServerPrivateKeyMap

type ServerPrivateKeyMap map[string]ServerPrivateKey

type ServerPrivateKeys

type ServerPrivateKeys struct {
	Status      APIStatus           `json:"status"`
	Version     int                 `json:"version"`
	Mtime       *int                `json:"mtime"`
	PrivateKeys ServerPrivateKeyMap `json:"private_keys"` // note these are only PGP keys
	Devices     DeviceKeyMap        `json:"devices"`
}

type ServertrustTrackerSyncer

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

func NewServertrustTrackerSyncer

func NewServertrustTrackerSyncer(g *GlobalContext, callerUID keybase1.UID, direction FollowDirection) *ServertrustTrackerSyncer

func (*ServertrustTrackerSyncer) Block

func (t *ServertrustTrackerSyncer) Block(m MetaContext, badUIDs map[keybase1.UID]bool) (err error)

func (*ServertrustTrackerSyncer) Result

type ServiceBlock

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

Can be used to either parse a proof `service` JSON block, or a `remote_key_proof` JSON block in a tracking statement.

func ParseServiceBlock

func ParseServiceBlock(jw *jsonw.Wrapper, pt keybase1.ProofType) (sb *ServiceBlock, err error)

func (ServiceBlock) GetProofState

func (sb ServiceBlock) GetProofState() keybase1.ProofState

func (ServiceBlock) GetProofType

func (sb ServiceBlock) GetProofType() keybase1.ProofType

func (ServiceBlock) IsSocial

func (sb ServiceBlock) IsSocial() bool

func (ServiceBlock) LastWriterWins

func (sb ServiceBlock) LastWriterWins() bool

func (ServiceBlock) ToIDString

func (sb ServiceBlock) ToIDString() string

func (ServiceBlock) ToKeyValuePair

func (sb ServiceBlock) ToKeyValuePair() (string, string)

type ServiceDoesNotSupportNewProofsError

type ServiceDoesNotSupportNewProofsError struct {
	Service string
}

func (ServiceDoesNotSupportNewProofsError) Error

func (ServiceDoesNotSupportNewProofsError) ToStatus

type ServiceInfo

type ServiceInfo struct {
	Version string `json:"version,omitempty"`
	Label   string `json:"label,omitempty"`
	Pid     int    `json:"pid,omitempty"`
}

ServiceInfo describes runtime info for a service. This is primarily used to detect service updates.

func KeybaseServiceInfo

func KeybaseServiceInfo(g *GlobalContext) ServiceInfo

KeybaseServiceInfo is runtime info for the Keybase service.

func LoadServiceInfo

func LoadServiceInfo(path string) (*ServiceInfo, error)

func NewServiceInfo

func NewServiceInfo(version string, prerelease string, label string, pid int) ServiceInfo

NewServiceInfo generates service info for other services (like KBFS).

func WaitForServiceInfoFile

func WaitForServiceInfoFile(path string, label string, pid string, timeout time.Duration, log serviceLog) (*ServiceInfo, error)

WaitForServiceInfoFile tries to wait for a service info file, which should be written on successful service startup.

func (ServiceInfo) WriteFile

func (s ServiceInfo) WriteFile(path string, log logger.Logger) error

WriteFile writes service info as JSON in runtimeDir.

type ServiceSummaryMapper

type ServiceSummaryMapper interface {
	MapUIDsToServiceSummaries(ctx context.Context, g UIDMapperContext, uids []keybase1.UID, freshness time.Duration,
		networkTimeBudget time.Duration) map[keybase1.UID]UserServiceSummaryPackage
	InformOfServiceSummary(ctx context.Context, g UIDMapperContext, uid keybase1.UID, summary UserServiceSummary) error
}

type ServiceType

type ServiceType interface {
	Key() string

	// NormalizeUsername normalizes the given username, assuming
	// that it's free of any leading strings like '@' or 'dns://'.
	NormalizeUsername(string) (string, error)

	// NormalizeRemote normalizes the given remote username, which
	// is usually but not always the same as the username. It also
	// allows leaders like '@' and 'dns://'.
	//
	// In the case of Facebook, this version does the standard downcasing, but
	// leaves the dots in (that NormalizeUsername above would strip out). This
	// lets us keep the dots in the proof text, and display them on your
	// profile page, even though we ignore them for proof checking.
	NormalizeRemoteName(m MetaContext, name string) (string, error)

	GetPrompt() string
	LastWriterWins() bool
	PreProofCheck(m MetaContext, remotename string) (*Markup, error)
	PreProofWarning(remotename string) *Markup
	ToServiceJSON(remotename string) *jsonw.Wrapper
	PostInstructions(remotename string) *Markup
	DisplayName() string
	RecheckProofPosting(tryNumber int, status keybase1.ProofStatus, remotename string) (warning *Markup, err error)
	GetProofType() string
	GetTypeName() string
	PickerSubtext() string
	CheckProofText(text string, id keybase1.SigID, sig string) error
	FormatProofText(mctx MetaContext, ppr *PostProofRes,
		kbUsername, remoteUsername string, sigID keybase1.SigID) (string, error)
	GetAPIArgKey() string
	IsDevelOnly() bool
	GetLogoKey() string

	MakeProofChecker(l RemoteProofChainLink) ProofChecker
	SetDisplayConfig(*keybase1.ServiceDisplayConfig)
	CanMakeNewProofs(mctx MetaContext) bool
	CanMakeNewProofsSkipFeatureFlag(mctx MetaContext) bool
	DisplayPriority() int
	DisplayGroup() string
	IsNew(MetaContext) bool
}

ServiceType is an interface for describing an external proof service, like 'Twitter' or 'GitHub', etc.

type Session

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

func NewSessionThin

func NewSessionThin(uid keybase1.UID, username NormalizedUsername, token string) *Session

NewSessionThin creates a minimal (thin) session of just the uid and username. Clients of the daemon that use the session protocol need this.

func (*Session) APIArgs

func (s *Session) APIArgs() (token, csrf string)

func (*Session) Clone

func (s *Session) Clone() *Session

func (*Session) GetCsrf

func (s *Session) GetCsrf() string

func (*Session) GetDeviceID

func (s *Session) GetDeviceID() keybase1.DeviceID

func (*Session) GetToken

func (s *Session) GetToken() string

func (*Session) GetUID

func (s *Session) GetUID() keybase1.UID

func (*Session) GetUsername

func (s *Session) GetUsername() *NormalizedUsername

func (*Session) HasSessionToken

func (s *Session) HasSessionToken() bool

func (*Session) Invalidate

func (s *Session) Invalidate()

Invalidate marks the session as invalid and posts a logout notification.

func (*Session) IsLoggedIn

func (s *Session) IsLoggedIn() bool

func (*Session) IsRecent

func (s *Session) IsRecent() bool

func (*Session) IsValid

func (s *Session) IsValid() bool

func (*Session) SetDeviceProvisioned

func (s *Session) SetDeviceProvisioned(devid keybase1.DeviceID) error

func (*Session) SetLoggedIn

func (s *Session) SetLoggedIn(sessionID, csrfToken string, username NormalizedUsername, uid keybase1.UID, deviceID keybase1.DeviceID) error

func (*Session) SetUsername

func (s *Session) SetUsername(username NormalizedUsername)

type SessionTokener

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

func NewSessionTokener

func NewSessionTokener(mctx MetaContext) (*SessionTokener, error)

func (*SessionTokener) Tokens

func (s *SessionTokener) Tokens() (session, csrf string)

type ShutdownHook

type ShutdownHook func(mctx MetaContext) error

type SibkeyAlreadyExistsError

type SibkeyAlreadyExistsError struct{}

func (SibkeyAlreadyExistsError) Error

func (e SibkeyAlreadyExistsError) Error() string

func (SibkeyAlreadyExistsError) ToStatus

type SibkeyChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseSibkeyChainLink(b GenericChainLink) (ret *SibkeyChainLink, err error)

func (*SibkeyChainLink) GetDelegatedKid

func (s *SibkeyChainLink) GetDelegatedKid() keybase1.KID

func (*SibkeyChainLink) GetDevice

func (s *SibkeyChainLink) GetDevice() *Device

func (*SibkeyChainLink) GetPGPFullHash

func (s *SibkeyChainLink) GetPGPFullHash() string

func (*SibkeyChainLink) GetRole

func (s *SibkeyChainLink) GetRole() KeyRole

func (*SibkeyChainLink) ToDisplayString

func (s *SibkeyChainLink) ToDisplayString() string

func (*SibkeyChainLink) Type

func (s *SibkeyChainLink) Type() string

func (*SibkeyChainLink) VerifyReverseSig

func (s *SibkeyChainLink) VerifyReverseSig(ckf ComputedKeyFamily) (err error)

VerifyReverseSig checks a SibkeyChainLink's reverse signature using the ComputedKeyFamily provided.

type Sig3

type Sig3 struct {
	Inner string `json:"i,omitempty"`
	Outer string `json:"o,omitempty"`
	Sig   string `json:"s,omitempty"`
}

type SigChain

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

func (*SigChain) Bump

func (sc *SigChain) Bump(mt MerkleTriple, isHighDelegator bool)

Bump updates the latest seqno and high skip pointers during multisig posts. isHighDelegator is true iff the sig making causing the bump is high (e.g., for a sibkey).

func (*SigChain) CheckFreshness

func (sc *SigChain) CheckFreshness(srv *MerkleTriple) (current bool, err error)

func (*SigChain) Dump

func (sc *SigChain) Dump(w io.Writer)

Dump prints the sigchain to the writer arg.

func (*SigChain) EldestSeqno

func (sc *SigChain) EldestSeqno() keybase1.Seqno

func (SigChain) GetComputedKeyInfos

func (sc SigChain) GetComputedKeyInfos() (cki *ComputedKeyInfos)

func (SigChain) GetComputedKeyInfosWithVersionBust

func (sc SigChain) GetComputedKeyInfosWithVersionBust() (cki *ComputedKeyInfos)

func (*SigChain) GetCurrentSubchain

func (sc *SigChain) GetCurrentSubchain(m MetaContext, eldest keybase1.KID) (ChainLinks, error)

GetCurrentSubchain takes the given sigchain and walks backward until it finds the start of the current subchain, returning all the links in the subchain. See isSubchainStart for the details of the logic here.

func (SigChain) GetCurrentTailTriple

func (sc SigChain) GetCurrentTailTriple() (ret *MerkleTriple)

func (SigChain) GetExpectedNextHighSkip

func (sc SigChain) GetExpectedNextHighSkip(mctx MetaContext, uid keybase1.UID) (HighSkip, error)

GetExpectedNextHighSkip returns the HighSkip expected for a new link to be added to the chain. It can only be called after VerifyChain is completed.

func (sc SigChain) GetFirstLink() *ChainLink

func (SigChain) GetFutureChainTail

func (sc SigChain) GetFutureChainTail() (ret *MerkleTriple)

func (SigChain) GetLastKnownID

func (sc SigChain) GetLastKnownID() (ret LinkID)

func (SigChain) GetLastKnownSeqno

func (sc SigChain) GetLastKnownSeqno() (ret keybase1.Seqno)
func (sc SigChain) GetLastLink() *ChainLink

func (SigChain) GetLastLoadedID

func (sc SigChain) GetLastLoadedID() (ret LinkID)

func (SigChain) GetLastLoadedSeqno

func (sc SigChain) GetLastLoadedSeqno() (ret keybase1.Seqno)

func (*SigChain) GetLinkFromSeqno

func (sc *SigChain) GetLinkFromSeqno(seqno keybase1.Seqno) *ChainLink

func (*SigChain) GetLinkFromSigID

func (sc *SigChain) GetLinkFromSigID(id keybase1.SigID) *ChainLink

func (*SigChain) GetLinkFromSigIDQuery

func (sc *SigChain) GetLinkFromSigIDQuery(query string) *ChainLink

GetLinkFromSigIDQuery will return true if it finds a ChainLink with a SigID that starts with query.

func (*SigChain) HasStubs

func (sc *SigChain) HasStubs() bool

func (SigChain) Len

func (sc SigChain) Len() int

func (*SigChain) LoadFromServer

func (sc *SigChain) LoadFromServer(m MetaContext, t *MerkleTriple, selfUID keybase1.UID, stubMode StubMode, unstubs map[keybase1.Seqno]LinkID) (dirtyTail *MerkleTriple, err error)

func (*SigChain) LoadServerBody

func (sc *SigChain) LoadServerBody(m MetaContext, body []byte, low keybase1.Seqno, t *MerkleTriple, selfUID keybase1.UID) (dirtyTail *MerkleTriple, err error)

func (*SigChain) LocalDelegate

func (sc *SigChain) LocalDelegate(kf *KeyFamily, key GenericKey, sigID keybase1.SigID, signingKid keybase1.KID, isSibkey bool, mhm keybase1.HashMeta, fau keybase1.Seqno) (err error)

func (*SigChain) LocalDelegatePerUserKey

func (sc *SigChain) LocalDelegatePerUserKey(perUserKey keybase1.PerUserKey) error

func (*SigChain) SetUIDUsername

func (sc *SigChain) SetUIDUsername(uid keybase1.UID, username string)

func (*SigChain) Store

func (sc *SigChain) Store(m MetaContext) (err error)
func (sc *SigChain) VerifiedChainLinks(fp PGPFingerprint) (ret ChainLinks)

func (*SigChain) VerifyChain

func (sc *SigChain) VerifyChain(mctx MetaContext, uid keybase1.UID) (err error)

func (*SigChain) VerifySigsAndComputeKeys

func (sc *SigChain) VerifySigsAndComputeKeys(m MetaContext, eldest keybase1.KID, ckf *ComputedKeyFamily, uid keybase1.UID) (bool, error)

VerifySigsAndComputeKeys iterates over all potentially all incarnations of the user, trying to compute multiple subchains. It returns (bool, error), where bool is true if the load hit the cache, and false otherwise.

type SigChainLoader

type SigChainLoader struct {
	MetaContextified
	// contains filtered or unexported fields
}

func (*SigChainLoader) AccessPreload

func (l *SigChainLoader) AccessPreload() bool

func (*SigChainLoader) CheckFreshness

func (l *SigChainLoader) CheckFreshness() (current bool, err error)

func (*SigChainLoader) GetKeyFamily

func (l *SigChainLoader) GetKeyFamily() (err error)

func (*SigChainLoader) GetMerkleTriple

func (l *SigChainLoader) GetMerkleTriple() (ret *MerkleTriple)

func (*SigChainLoader) HasStubs

func (l *SigChainLoader) HasStubs() bool

func (*SigChainLoader) Load

func (l *SigChainLoader) Load() (ret *SigChain, err error)

Load is the main entry point into the SigChain loader. It runs through all of the steps to load a chain in from storage, to refresh it against the server, and to verify its integrity.

func (*SigChainLoader) LoadFromServer

func (l *SigChainLoader) LoadFromServer() (err error)

func (*SigChainLoader) LoadLastLinkIDFromStorage

func (l *SigChainLoader) LoadLastLinkIDFromStorage() (mt *MerkleTriple, err error)

func (*SigChainLoader) LoadLinksFromStorage

func (l *SigChainLoader) LoadLinksFromStorage() (err error)

func (*SigChainLoader) MakeSigChain

func (l *SigChainLoader) MakeSigChain() error

func (*SigChainLoader) Store

func (l *SigChainLoader) Store() (err error)

Store a SigChain to local storage as a result of having loaded it. We eagerly write loaded chain links to storage if they verify properly.

func (*SigChainLoader) StoreTail

func (l *SigChainLoader) StoreTail() (err error)

func (*SigChainLoader) VerifySigsAndComputeKeys

func (l *SigChainLoader) VerifySigsAndComputeKeys() (err error)

type SigHasRevokes

type SigHasRevokes bool

type SigHint

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

func NewSigHint

func NewSigHint(jw *jsonw.Wrapper) (sh *SigHint, err error)

func NewVerifiedSigHint

func NewVerifiedSigHint(sigID keybase1.SigID, remoteID, apiURL, humanURL, checkText string) *SigHint

func (SigHint) Export

func (sh SigHint) Export() *keybase1.SigHint

func (SigHint) GetAPIURL

func (sh SigHint) GetAPIURL() string

func (SigHint) GetCheckText

func (sh SigHint) GetCheckText() string

func (SigHint) GetHumanURL

func (sh SigHint) GetHumanURL() string

func (SigHint) MarshalToJSON

func (sh SigHint) MarshalToJSON() *jsonw.Wrapper

type SigHints

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

func LoadAndRefreshSigHints

func LoadAndRefreshSigHints(m MetaContext, uid keybase1.UID) (*SigHints, error)

func LoadSigHints

func LoadSigHints(m MetaContext, uid keybase1.UID) (sh *SigHints, err error)

func NewSigHints

func NewSigHints(jw *jsonw.Wrapper, uid keybase1.UID, dirty bool, g *GlobalContext) (sh *SigHints, err error)

func (SigHints) Lookup

func (sh SigHints) Lookup(i keybase1.SigID) *SigHint

func (SigHints) MarshalToJSON

func (sh SigHints) MarshalToJSON() *jsonw.Wrapper

func (*SigHints) PopulateWith

func (sh *SigHints) PopulateWith(jw *jsonw.Wrapper) (err error)

func (*SigHints) Refresh

func (sh *SigHints) Refresh(m MetaContext) (err error)

func (*SigHints) RefreshWith

func (sh *SigHints) RefreshWith(m MetaContext, jw *jsonw.Wrapper) (err error)

func (*SigHints) Store

func (sh *SigHints) Store(m MetaContext) (err error)

type SigIgnoreIfUnsupported

type SigIgnoreIfUnsupported bool

func (SigIgnoreIfUnsupported) Bool

func (b SigIgnoreIfUnsupported) Bool() bool

type SigMultiItem

type SigMultiItem struct {
	Sig3       *Sig3                   `json:"sig3,omitempty"`
	Sig        string                  `json:"sig,omitempty"`
	SigningKID keybase1.KID            `json:"signing_kid"`
	Type       string                  `json:"type"`
	SeqType    keybase1.SeqType        `json:"seq_type"`
	SigInner   string                  `json:"sig_inner"`
	TeamID     keybase1.TeamID         `json:"team_id,omitempty"`
	PublicKeys *SigMultiItemPublicKeys `json:"public_keys,omitempty"`
	Version    SigVersion              `json:"version"`
	Expansions *jsonw.Wrapper          `json:"expansions,omitempty"`
}

type SigMultiItemPublicKeys

type SigMultiItemPublicKeys struct {
	Encryption keybase1.KID `json:"encryption"`
	Signing    keybase1.KID `json:"signing"`
}

type SigVersion

type SigVersion int

SigVersion describes how the signature is computed. In signatures v1, the payload is a JSON blob. In Signature V2, it's a Msgpack wrapper that points via SHA256 to the V1 blob. V2 sigs allow for bandwidth-saving eliding of signature bodies that aren't relevant to clients.

const (
	KeybaseNullSigVersion SigVersion = 0
	KeybaseSignatureV1    SigVersion = 1
	KeybaseSignatureV2    SigVersion = 2
	KeybaseSignatureV3    SigVersion = 3
)

func GetDefaultSigVersion

func GetDefaultSigVersion(g *GlobalContext) SigVersion

type SigchainV2Error

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

func (SigchainV2Error) Error

func (s SigchainV2Error) Error() string

type SigchainV2MismatchedFieldError

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

func (SigchainV2MismatchedFieldError) Error

type SigchainV2MismatchedHashError

type SigchainV2MismatchedHashError struct{}

func (SigchainV2MismatchedHashError) Error

type SigchainV2Required

type SigchainV2Required struct{}

func (SigchainV2Required) Error

func (s SigchainV2Required) Error() string

type SigchainV2StubbedDisallowed

type SigchainV2StubbedDisallowed struct{}

func (SigchainV2StubbedDisallowed) Error

type SigchainV2StubbedFirstLinkError

type SigchainV2StubbedFirstLinkError struct{}

func (SigchainV2StubbedFirstLinkError) Error

type SigchainV2StubbedSignatureNeededError

type SigchainV2StubbedSignatureNeededError struct{}

func (SigchainV2StubbedSignatureNeededError) Error

type SigchainV2Type

type SigchainV2Type int
const (
	SigchainV2TypeNone                        SigchainV2Type = 0
	SigchainV2TypeEldest                      SigchainV2Type = 1
	SigchainV2TypeWebServiceBinding           SigchainV2Type = 2
	SigchainV2TypeTrack                       SigchainV2Type = 3
	SigchainV2TypeUntrack                     SigchainV2Type = 4
	SigchainV2TypeRevoke                      SigchainV2Type = 5
	SigchainV2TypeCryptocurrency              SigchainV2Type = 6
	SigchainV2TypeAnnouncement                SigchainV2Type = 7
	SigchainV2TypeDevice                      SigchainV2Type = 8
	SigchainV2TypeWebServiceBindingWithRevoke SigchainV2Type = 9
	SigchainV2TypeCryptocurrencyWithRevoke    SigchainV2Type = 10
	SigchainV2TypeSibkey                      SigchainV2Type = 11
	SigchainV2TypeSubkey                      SigchainV2Type = 12
	SigchainV2TypePGPUpdate                   SigchainV2Type = 13
	SigchainV2TypePerUserKey                  SigchainV2Type = 14
	SigchainV2TypeWalletStellar               SigchainV2Type = 15
	SigchainV2TypeWotVouch                    SigchainV2Type = 16
	SigchainV2TypeWotVouchWithRevoke          SigchainV2Type = 17
	SigchainV2TypeWotReact                    SigchainV2Type = 18

	// Team link types
	// If you add a new one be sure to get all of these too:
	// - A corresponding libkb.LinkType in constants.go
	// - SigchainV2TypeFromV1TypeTeams
	// - SigChainV2Type.IsSupportedTeamType
	// - SigChainV2Type.TeamAllowStubWithAdminFlag
	// - TeamSigChainPlayer.addInnerLink (add a case)
	SigchainV2TypeTeamRoot             SigchainV2Type = 33
	SigchainV2TypeTeamNewSubteam       SigchainV2Type = 34
	SigchainV2TypeTeamChangeMembership SigchainV2Type = 35
	SigchainV2TypeTeamRotateKey        SigchainV2Type = 36
	SigchainV2TypeTeamLeave            SigchainV2Type = 37
	SigchainV2TypeTeamSubteamHead      SigchainV2Type = 38
	SigchainV2TypeTeamRenameSubteam    SigchainV2Type = 39
	SigchainV2TypeTeamInvite           SigchainV2Type = 40
	SigchainV2TypeTeamRenameUpPointer  SigchainV2Type = 41
	SigchainV2TypeTeamDeleteRoot       SigchainV2Type = 42
	SigchainV2TypeTeamDeleteSubteam    SigchainV2Type = 43
	SigchainV2TypeTeamDeleteUpPointer  SigchainV2Type = 44
	// Note that 45 is skipped, since it's retired; used to be LegacyTLFUpgrade
	SigchainV2TypeTeamSettings     SigchainV2Type = 46
	SigchainV2TypeTeamKBFSSettings SigchainV2Type = 47
	SigchainV2TypeTeamBotSettings  SigchainV2Type = 48
)

These values must match constants.iced in the proofs library.

func SigchainV2TypeFromV1TypeAndRevocations

func SigchainV2TypeFromV1TypeAndRevocations(s string, hasRevocations SigHasRevokes, ignoreIfUnsupported SigIgnoreIfUnsupported) (ret SigchainV2Type, err error)

func SigchainV2TypeFromV1TypeTeams

func SigchainV2TypeFromV1TypeTeams(s string) (ret SigchainV2Type, err error)

func (SigchainV2Type) AllowStubbing

func (t SigchainV2Type) AllowStubbing() bool

NeedsSignature is untrue of most supported link types. If a link can be stubbed, that means we potentially won't get to verify its signature, since we need the full link to verify signatures. However, in some cases, signature verification is required, and hence stubbing is disallowed. NOTE when modifying this function ensure that web/sig.iced#_allow_stubbing is updated as well.

func (SigchainV2Type) IsSupportedTeamType

func (t SigchainV2Type) IsSupportedTeamType() bool

Whether a type is for team sigchains. Also the list of which types are supported by this client.

func (SigchainV2Type) IsSupportedType

func (t SigchainV2Type) IsSupportedType() bool

func (SigchainV2Type) IsSupportedUserType

func (t SigchainV2Type) IsSupportedUserType() bool

NOTE when modifying this function ensure that web/sig.iced#_is_supported_user_type is updated as well.

func (SigchainV2Type) RequiresAtLeastRole

func (t SigchainV2Type) RequiresAtLeastRole() keybase1.TeamRole

func (SigchainV2Type) SigIDSuffixParams

func (SigchainV2Type) TeamAllowStubWithAdminFlag

func (t SigchainV2Type) TeamAllowStubWithAdminFlag(isAdmin bool) bool

type SignatureStatus

type SignatureStatus struct {
	IsSigned        bool
	Verified        bool
	SignatureError  error
	KeyID           uint64
	Entity          *openpgp.Entity
	SignatureTime   time.Time
	RecipientKeyIDs []uint64
	Warnings        HashSecurityWarnings
}

func PGPDecrypt

func PGPDecrypt(g *GlobalContext, source io.Reader, sink io.Writer, kr openpgp.KeyRing) (*SignatureStatus, error)

PGPDecrypt only generates warnings about insecure _message_ signatures, not _key_ signatures - that is handled by engine.PGPDecrypt.

func PGPDecryptWithBundles

func PGPDecryptWithBundles(g *GlobalContext, source io.Reader, sink io.Writer, keys []*PGPKeyBundle) (*SignatureStatus, error)

type SimpleTimer

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

SimpleTimer keeps track of how long something is taking, like a network API call. Meant to be very simple. It is not meant to be goroutine safe and should only be called from one Goroutine.

func (*SimpleTimer) GetTotal

func (s *SimpleTimer) GetTotal() time.Duration

GetTotal gets the total duration spent in the timer.

func (*SimpleTimer) Reset

func (s *SimpleTimer) Reset()

Reset the internal duration counter.

func (*SimpleTimer) Start

func (s *SimpleTimer) Start()

Start the timer running, if it's not already started.

func (*SimpleTimer) Stop

func (s *SimpleTimer) Stop() time.Duration

Stop the timer; panic if it hasn't been previously started. Return the total duration spent in the timer.

type SkinnyLogger

type SkinnyLogger interface {
	// Error logs a message at error level, with formatting args
	Errorf(format string, args ...interface{})
	// Debug logs a message at debug level, with formatting args.
	Debug(format string, args ...interface{})
}

type SkipSecretPromptError

type SkipSecretPromptError struct{}

func (SkipSecretPromptError) Error

func (e SkipSecretPromptError) Error() string

func (SkipSecretPromptError) ToStatus

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

type SkipSequence

type SkipSequence []MerkleRootPayload

type SkipTable

type SkipTable map[keybase1.Seqno]NodeHashAny
type SocialProofChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func NewSocialProofChainLink(b GenericChainLink, s, u, proofText string) *SocialProofChainLink

func (*SocialProofChainLink) CheckDataJSON

func (s *SocialProofChainLink) CheckDataJSON() *jsonw.Wrapper

func (*SocialProofChainLink) ComputeTrackDiff

func (s *SocialProofChainLink) ComputeTrackDiff(tl *TrackLookup) TrackDiff

func (*SocialProofChainLink) DisplayCheck

func (s *SocialProofChainLink) DisplayCheck(m MetaContext, ui IdentifyUI, lcr LinkCheckResult) error

func (*SocialProofChainLink) DisplayPriorityKey

func (s *SocialProofChainLink) DisplayPriorityKey() string

func (*SocialProofChainLink) GetHostname

func (s *SocialProofChainLink) GetHostname() string

func (*SocialProofChainLink) GetProofType

func (s *SocialProofChainLink) GetProofType() keybase1.ProofType

func (*SocialProofChainLink) GetProtocol

func (s *SocialProofChainLink) GetProtocol() string

func (*SocialProofChainLink) GetRemoteUsername

func (s *SocialProofChainLink) GetRemoteUsername() string

func (*SocialProofChainLink) GetService

func (s *SocialProofChainLink) GetService() string

func (*SocialProofChainLink) LastWriterWins

func (s *SocialProofChainLink) LastWriterWins() bool

func (*SocialProofChainLink) ProofText

func (s *SocialProofChainLink) ProofText() string

func (*SocialProofChainLink) TableKey

func (s *SocialProofChainLink) TableKey() string

func (*SocialProofChainLink) ToDisplayString

func (s *SocialProofChainLink) ToDisplayString() string

func (*SocialProofChainLink) ToIDString

func (s *SocialProofChainLink) ToIDString() string

func (*SocialProofChainLink) ToKeyValuePair

func (s *SocialProofChainLink) ToKeyValuePair() (string, string)

func (*SocialProofChainLink) ToTrackingStatement

func (s *SocialProofChainLink) ToTrackingStatement(state keybase1.ProofState) (*jsonw.Wrapper, error)

func (*SocialProofChainLink) Type

func (s *SocialProofChainLink) Type() string

type Socket

type Socket interface {
	BindToSocket() (net.Listener, error)
	DialSocket() (net.Conn, error)
}

NewSocket() (Socket, err) is defined in the various platform-specific socket_*.go files.

func NewSocket

func NewSocket(g *GlobalContext) (ret Socket, err error)

func NewSocketWithFiles

func NewSocketWithFiles(
	log logger.Logger, bindFile string, dialFiles []string) Socket

type SocketInfo

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

func (SocketInfo) BindToSocket

func (s SocketInfo) BindToSocket() (ret net.Listener, err error)

func (SocketInfo) DialSocket

func (s SocketInfo) DialSocket() (net.Conn, error)

func (SocketInfo) GetBindFile

func (s SocketInfo) GetBindFile() string

func (SocketInfo) GetDialFiles

func (s SocketInfo) GetDialFiles() []string

type SocketWrapper

type SocketWrapper struct {
	Conn        net.Conn
	Transporter rpc.Transporter
	Err         error
}
type SpecialChainLink struct {
	UID    keybase1.UID
	Seqno  keybase1.Seqno
	Reason string
}

type SpecialKeyRing

type SpecialKeyRing struct {
	Contextified

	sync.Mutex
	// contains filtered or unexported fields
}

SpecialKeyRing holds blessed keys, like the one Keybase uses to sign its Merkle Root.

func NewSpecialKeyRing

func NewSpecialKeyRing(v []keybase1.KID, g *GlobalContext) *SpecialKeyRing

NewSpecialKeyRing allocates a new SpecialKeyRing with the given vector of KIDs. For NaCl keys, it will actually import those keys into the Keyring.

func (*SpecialKeyRing) IsValidKID

func (sk *SpecialKeyRing) IsValidKID(kid keybase1.KID) bool

IsValidKID returns if this KID is valid (blessed) according to this Keyring

func (*SpecialKeyRing) Load

func (sk *SpecialKeyRing) Load(m MetaContext, kid keybase1.KID) (GenericKey, error)

Load takes a blessed KID and returns, if possible, the GenericKey associated with that KID, for signature verification. If the key isn't found in memory or on disk (in the case of PGP), then it will attempt to fetch the key from the keybase server.

type StandaloneChatConnector

type StandaloneChatConnector interface {
	StartStandaloneChat(g *GlobalContext) error
}

type Stellar

type Stellar interface {
	CreateWalletSoft(context.Context)
	Upkeep(context.Context) error
	GetServerDefinitions(context.Context) (stellar1.StellarServerDefinitions, error)
	KickAutoClaimRunner(MetaContext, gregor.MsgID)
	UpdateUnreadCount(ctx context.Context, accountID stellar1.AccountID, unread int) error
	SpecMiniChatPayments(mctx MetaContext, payments []MiniChatPayment) (*MiniChatPaymentSummary, error)
	SendMiniChatPayments(mctx MetaContext, convID chat1.ConversationID, payments []MiniChatPayment) ([]MiniChatPaymentResult, error)
	HandleOobm(context.Context, gregor.OutOfBandMessage) (bool, error)
	RemovePendingTx(mctx MetaContext, accountID stellar1.AccountID, txID stellar1.TransactionID) error
	KnownCurrencyCodeInstant(ctx context.Context, code string) (known, ok bool)
	InformBundle(MetaContext, stellar1.BundleRevision, []stellar1.BundleEntry)
	InformDefaultCurrencyChange(MetaContext)
	Refresh(mctx MetaContext, reason string)
}

type StreamClassification

type StreamClassification struct {
	Format  CryptoMessageFormat
	Type    CryptoMessageType
	Armored bool
}

StreamClassification tells what Format the stream is, if it's a Public signature or a Private Message, if it's a detached or attached signature in the public case, and if it's armored or binary.

func ClassifyStream

func ClassifyStream(r io.Reader) (sc StreamClassification, out io.Reader, err error)

ClassifyStream takes a stream reader in, and returns a likely classification of that stream without consuming any data from it. It returns a reader that you should read from instead, in addition to the classification. If classification fails, there will be a `UnknownStreamError`, or additional EOF errors if the stream ended before classification could go.

type StreamExistsError

type StreamExistsError struct{}

func (StreamExistsError) Error

func (s StreamExistsError) Error() string

func (StreamExistsError) ToStatus

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

type StreamNotFoundError

type StreamNotFoundError struct{}

func (StreamNotFoundError) Error

func (s StreamNotFoundError) Error() string

func (StreamNotFoundError) ToStatus

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

type StreamWrongKindError

type StreamWrongKindError struct{}

func (StreamWrongKindError) Error

func (s StreamWrongKindError) Error() string

func (StreamWrongKindError) ToStatus

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

type StringWarning

type StringWarning string

func (StringWarning) Warn

func (s StringWarning) Warn(g *GlobalContext)

func (StringWarning) Warning

func (s StringWarning) Warning() string

type StubAPIEngine

type StubAPIEngine struct {
	*ExternalAPIEngine
}

func NewStubAPIEngine

func NewStubAPIEngine(g *GlobalContext) *StubAPIEngine

func (*StubAPIEngine) Get

func (e *StubAPIEngine) Get(m MetaContext, arg APIArg) (res *ExternalAPIRes, err error)

func (*StubAPIEngine) GetHTML

func (e *StubAPIEngine) GetHTML(m MetaContext, arg APIArg) (res *ExternalHTMLRes, err error)

func (*StubAPIEngine) GetText

func (e *StubAPIEngine) GetText(m MetaContext, arg APIArg) (*ExternalTextRes, error)

type StubMode

type StubMode int
const (
	StubModeStubbed   StubMode = 0
	StubModeUnstubbed StubMode = 1
)

func StubModeFromUnstubbedBool

func StubModeFromUnstubbedBool(unstubbed bool) StubMode

func (StubMode) String

func (s StubMode) String() string
type SubkeyChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseSubkeyChainLink(b GenericChainLink) (ret *SubkeyChainLink, err error)

func (*SubkeyChainLink) GetDelegatedKid

func (s *SubkeyChainLink) GetDelegatedKid() keybase1.KID

func (*SubkeyChainLink) GetParentKid

func (s *SubkeyChainLink) GetParentKid() keybase1.KID

func (*SubkeyChainLink) GetRole

func (s *SubkeyChainLink) GetRole() KeyRole

func (*SubkeyChainLink) ToDisplayString

func (s *SubkeyChainLink) ToDisplayString() string

func (*SubkeyChainLink) Type

func (s *SubkeyChainLink) Type() string

type SyncedContactListProvider

type SyncedContactListProvider interface {
	SaveProcessedContacts(MetaContext, []keybase1.ProcessedContact) error
	RetrieveContacts(MetaContext) ([]keybase1.ProcessedContact, error)
	RetrieveAssertionToName(MetaContext) (map[string]string, error)
	UnresolveContactsWithComponent(MetaContext, *keybase1.PhoneNumber, *keybase1.EmailAddress)
}

type Syncer

type Syncer interface {
	Contextifier
	sync.Locker
	// contains filtered or unexported methods
}

type TeamAuditParams

type TeamAuditParams struct {
	RootFreshness time.Duration
	// After this many new Merkle updates, another audit is triggered.
	MerkleMovementTrigger keybase1.Seqno
	NumPreProbes          int
	NumPostProbes         int
	Parallelism           int
	LRUSize               int
}

type TeamAuditor

type TeamAuditor interface {
	AuditTeam(m MetaContext, id keybase1.TeamID, isPublic bool, headMerkleSeqno keybase1.Seqno,
		chain map[keybase1.Seqno]keybase1.LinkID, hiddenChain map[keybase1.Seqno]keybase1.LinkID,
		maxSeqno keybase1.Seqno, maxHiddenSeqno keybase1.Seqno, lastMerkleRoot *MerkleRoot, auditMode keybase1.AuditMode) (err error)
}

type TeamBadMembershipError

type TeamBadMembershipError struct{}

func (TeamBadMembershipError) Error

func (e TeamBadMembershipError) Error() string

func (TeamBadMembershipError) ToStatus

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

type TeamBoxAuditor

type TeamBoxAuditor interface {
	AssertUnjailedOrReaudit(m MetaContext, id keybase1.TeamID) (didReaudit bool, err error)
	IsInJail(m MetaContext, id keybase1.TeamID) (bool, error)
	RetryNextBoxAudit(m MetaContext) (attempt *keybase1.BoxAuditAttempt, err error)
	BoxAuditRandomTeam(m MetaContext) (attempt *keybase1.BoxAuditAttempt, err error)
	BoxAuditTeam(m MetaContext, id keybase1.TeamID) (attempt *keybase1.BoxAuditAttempt, err error)
	MaybeScheduleDelayedBoxAuditTeam(m MetaContext, id keybase1.TeamID)
	Attempt(m MetaContext, id keybase1.TeamID, rotateBeforeAudit bool) keybase1.BoxAuditAttempt
}

type TeamContactSettingsBlockError

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

func NewTeamContactSettingsBlockError

func NewTeamContactSettingsBlockError(s *AppStatus) TeamContactSettingsBlockError

func (TeamContactSettingsBlockError) BlockedUIDs

func (e TeamContactSettingsBlockError) BlockedUIDs() []keybase1.UID

func (TeamContactSettingsBlockError) BlockedUsernames

func (e TeamContactSettingsBlockError) BlockedUsernames() []NormalizedUsername

func (TeamContactSettingsBlockError) Error

func (TeamContactSettingsBlockError) ToStatus

func (e TeamContactSettingsBlockError) ToStatus() (ret keybase1.Status)

type TeamEKBoxStorage

type TeamEKBoxStorage interface {
	Put(mctx MetaContext, teamID keybase1.TeamID, generation keybase1.EkGeneration, teamEKBoxed keybase1.TeamEphemeralKeyBoxed) error
	Get(mctx MetaContext, teamID keybase1.TeamID, generation keybase1.EkGeneration, contentCtime *gregor1.Time) (keybase1.TeamEphemeralKey, error)
	MaxGeneration(mctx MetaContext, teamID keybase1.TeamID, includeErrs bool) (keybase1.EkGeneration, error)
	DeleteExpired(mctx MetaContext, teamID keybase1.TeamID, merkleRoot MerkleRoot) ([]keybase1.EkGeneration, error)
	PurgeCacheForTeamID(mctx MetaContext, teamID keybase1.TeamID) error
	Delete(mctx MetaContext, teamID keybase1.TeamID, generation keybase1.EkGeneration) error
	ClearCache()
}

type TeamInviteBadTokenError

type TeamInviteBadTokenError struct{}

func (TeamInviteBadTokenError) Error

func (e TeamInviteBadTokenError) Error() string

func (TeamInviteBadTokenError) ToStatus

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

type TeamInviteTokenReusedError

type TeamInviteTokenReusedError struct{}

func (TeamInviteTokenReusedError) Error

func (TeamInviteTokenReusedError) ToStatus

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

type TeamLoader

type TeamLoader interface {
	VerifyTeamName(ctx context.Context, id keybase1.TeamID, name keybase1.TeamName) error
	ImplicitAdmins(ctx context.Context, teamID keybase1.TeamID) (impAdmins []keybase1.UserVersion, err error)
	// MapTeamAncestors runs `f` for each of a team's ancestors, excluding the team itself.
	// `f` is an arbitrary function. if it returns an error, the load halts.
	// `teamID` is the team whose ancestors we are mapping over.
	// `reason` is a context string used for logging.
	// `forceFullReloadOnceToAssert` is a predicate that will cause a force full reload if it is
	//		false. It can be used when a new field is added to keybase1.SigChainState that requires
	//		a full reload to obtain.
	MapTeamAncestors(ctx context.Context, f func(t keybase1.TeamSigChainState, n keybase1.TeamName) error, teamID keybase1.TeamID, reason string, forceFullReloadOnceToAssert func(t keybase1.TeamSigChainState) bool) error
	NotifyTeamRename(ctx context.Context, id keybase1.TeamID, newName string) error
	Load(context.Context, keybase1.LoadTeamArg) (*keybase1.TeamData, *keybase1.HiddenTeamChain, error)
	// Freezing a team clears most data and forces a full reload when the team
	// is loaded again. The team loader checks that the previous tail is
	// contained within the new chain post-freeze. In particular, since we load
	// a team before deleting it in response to the server-driven delete gregor
	// notifications, the server can't roll-back to a state where the team is
	// undeleted, so we don't have to special-case team deletion.
	Freeze(ctx context.Context, teamID keybase1.TeamID) error
	// Tombstoning a team prevents it from being loaded ever again, as long as
	// that cache entry exists. Used to prevent server from "undeleting" a
	// team. While a team is tombstoned, most data is cleared.
	Tombstone(ctx context.Context, teamID keybase1.TeamID) error
	// Untrusted hint of what a team's latest seqno is
	HintLatestSeqno(ctx context.Context, id keybase1.TeamID, seqno keybase1.Seqno) error
	ResolveNameToIDUntrusted(ctx context.Context, teamName keybase1.TeamName, public bool, allowCache bool) (id keybase1.TeamID, err error)
	ForceRepollUntil(ctx context.Context, t gregor.TimeOrOffset) error
	IsOpenCached(ctx context.Context, teamID keybase1.TeamID) (bool, error)
	// Clear the in-memory cache. Does not affect the disk cache.
	ClearMem()
}

type TeamMemberCountCache

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

func (*TeamMemberCountCache) Get

func (c *TeamMemberCountCache) Get(teamID keybase1.TeamID) (count int, ok bool)

func (*TeamMemberCountCache) GetWithFallback

func (c *TeamMemberCountCache) GetWithFallback(teamID keybase1.TeamID, fallback int) (count int)

func (*TeamMemberCountCache) OnLogout

func (c *TeamMemberCountCache) OnLogout(mctx MetaContext) error

func (*TeamMemberCountCache) Set

func (c *TeamMemberCountCache) Set(teamID keybase1.TeamID, count int)

type TeamProvisionalError

type TeamProvisionalError struct {
	CanKey                bool
	IsPublic              bool
	PreResolveDisplayName string
}

func (TeamProvisionalError) Error

func (e TeamProvisionalError) Error() string

func (TeamProvisionalError) ToStatus

func (e TeamProvisionalError) ToStatus() keybase1.Status

type TeamRoleMapManager

type TeamRoleMapManager interface {
	Get(m MetaContext, retryOnFail bool) (res keybase1.TeamRoleMapAndVersion, err error)
	Update(m MetaContext, version keybase1.UserTeamVersion) (err error)
	FlushCache()
}

type TeamVisibilityError

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

func NewTeamVisibilityError

func NewTeamVisibilityError(wantedPublic, gotPublic bool) TeamVisibilityError

func (TeamVisibilityError) Error

func (e TeamVisibilityError) Error() string

type TeamWritePermDeniedError

type TeamWritePermDeniedError struct{}

func (TeamWritePermDeniedError) Error

func (e TeamWritePermDeniedError) Error() string

type TeambotBotKeyer

type TeambotBotKeyer interface {
	GetLatestTeambotKey(mctx MetaContext, teamID keybase1.TeamID, app keybase1.TeamApplication) (keybase1.TeambotKey, error)
	GetTeambotKeyAtGeneration(mctx MetaContext, teamID keybase1.TeamID, app keybase1.TeamApplication,
		generation keybase1.TeambotKeyGeneration) (keybase1.TeambotKey, error)

	DeleteTeambotKeyForTest(mctx MetaContext, teamID keybase1.TeamID, app keybase1.TeamApplication,
		generation keybase1.TeambotKeyGeneration) error
}

type TeambotMemberKeyer

type TeambotMemberKeyer interface {
	GetOrCreateTeambotKey(mctx MetaContext, teamID keybase1.TeamID, botUID gregor1.UID,
		appKey keybase1.TeamApplicationKey) (keybase1.TeambotKey, bool, error)
	PurgeCache(mctx MetaContext)
	PurgeCacheAtGeneration(mctx MetaContext, teamID keybase1.TeamID, botUID keybase1.UID,
		app keybase1.TeamApplication, generation keybase1.TeambotKeyGeneration)
}

type TerminalUI

type TerminalUI interface {
	// The ErrorWriter is not escaped: it should not be used to show unescaped user-originated data.
	ErrorWriter() io.Writer
	Output(string) error
	OutputDesc(OutputDescriptor, string) error
	OutputWriter() io.Writer
	UnescapedOutputWriter() io.Writer
	Printf(fmt string, args ...interface{}) (int, error)
	PrintfUnescaped(fmt string, args ...interface{}) (int, error)
	// Prompt strings are not escaped: they should not be used to show unescaped user-originated data.
	Prompt(PromptDescriptor, string) (string, error)
	PromptForConfirmation(prompt string) error
	PromptPassword(PromptDescriptor, string) (string, error)
	PromptPasswordMaybeScripted(PromptDescriptor, string) (string, error)
	PromptYesNo(PromptDescriptor, string, PromptDefault) (bool, error)
	TerminalSize() (width int, height int)
}

type TestCancelSecretUI

type TestCancelSecretUI struct {
	CallCount int
}

func (*TestCancelSecretUI) GetPassphrase

type TestConfig

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

TestConfig tracks libkb config during a test

func (*TestConfig) CleanTest

func (c *TestConfig) CleanTest()

func (*TestConfig) GetConfigFileName

func (c *TestConfig) GetConfigFileName() string

type TestContext

type TestContext struct {
	G          *GlobalContext
	PrevGlobal *GlobalContext
	Tp         *TestParameters
	// TODO: Rename this to TB.
	T TestingTB
	// contains filtered or unexported fields
}

func SetupTest

func SetupTest(tb TestingTB, name string, depth int) (tc TestContext)

The depth argument is now ignored.

func (*TestContext) Cleanup

func (tc *TestContext) Cleanup()

func (TestContext) ClearAllStoredSecrets

func (tc TestContext) ClearAllStoredSecrets() error

func (TestContext) Clone

func (tc TestContext) Clone() (ret TestContext)

func (TestContext) Context

func (tc TestContext) Context() context.Context

func (*TestContext) GenerateGPGKeyring

func (tc *TestContext) GenerateGPGKeyring(ids ...string) error

func (*TestContext) Logout

func (tc *TestContext) Logout() error

func (*TestContext) MakePGPKey

func (tc *TestContext) MakePGPKey(id string) (*PGPKeyBundle, error)

func (TestContext) MetaContext

func (tc TestContext) MetaContext() MetaContext

func (TestContext) MoveGpgKeyringTo

func (tc TestContext) MoveGpgKeyringTo(dst TestContext) error

func (*TestContext) SetRuntimeDir

func (tc *TestContext) SetRuntimeDir(s string)

func (*TestContext) SimulateServiceRestart

func (tc *TestContext) SimulateServiceRestart()

SimulatServiceRestart simulates a shutdown and restart (for client state). Used by tests that need to clear out cached login state without logging out.

type TestCountSecretUI

type TestCountSecretUI struct {
	Passphrase  string
	StoreSecret bool
	CallCount   int
}

func (*TestCountSecretUI) GetPassphrase

type TestLoginCancelUI

type TestLoginCancelUI struct {
	TestLoginUI
}

func (*TestLoginCancelUI) GetEmailOrUsername

func (t *TestLoginCancelUI) GetEmailOrUsername(_ context.Context, _ int) (string, error)

type TestLoginUI

type TestLoginUI struct {
	Username                 string
	RevokeBackup             bool
	CalledGetEmailOrUsername int
	ResetAccount             keybase1.ResetPromptResponse
	PassphraseRecovery       bool
}

func (*TestLoginUI) ChooseDeviceToRecoverWith

func (t *TestLoginUI) ChooseDeviceToRecoverWith(_ context.Context, arg keybase1.ChooseDeviceToRecoverWithArg) (keybase1.DeviceID, error)

func (*TestLoginUI) DisplayPaperKeyPhrase

func (t *TestLoginUI) DisplayPaperKeyPhrase(_ context.Context, arg keybase1.DisplayPaperKeyPhraseArg) error

func (*TestLoginUI) DisplayPrimaryPaperKey

func (t *TestLoginUI) DisplayPrimaryPaperKey(_ context.Context, arg keybase1.DisplayPrimaryPaperKeyArg) error

func (*TestLoginUI) DisplayResetMessage

func (t *TestLoginUI) DisplayResetMessage(_ context.Context, arg keybase1.DisplayResetMessageArg) error

func (*TestLoginUI) DisplayResetProgress

func (t *TestLoginUI) DisplayResetProgress(_ context.Context, arg keybase1.DisplayResetProgressArg) error

func (*TestLoginUI) ExplainDeviceRecovery

func (t *TestLoginUI) ExplainDeviceRecovery(_ context.Context, arg keybase1.ExplainDeviceRecoveryArg) error

func (*TestLoginUI) GetEmailOrUsername

func (t *TestLoginUI) GetEmailOrUsername(_ context.Context, _ int) (string, error)

func (*TestLoginUI) PromptPassphraseRecovery

func (t *TestLoginUI) PromptPassphraseRecovery(_ context.Context, arg keybase1.PromptPassphraseRecoveryArg) (bool, error)

func (*TestLoginUI) PromptResetAccount

func (*TestLoginUI) PromptRevokePaperKeys

func (t *TestLoginUI) PromptRevokePaperKeys(_ context.Context, arg keybase1.PromptRevokePaperKeysArg) (bool, error)

type TestOutput

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

TestOutput is a mock interface for capturing and testing output

func NewTestOutput

func NewTestOutput(e string, t TestingTB, c *bool) TestOutput

func (TestOutput) Write

func (to TestOutput) Write(p []byte) (n int, err error)

type TestParameters

type TestParameters struct {
	ConfigFilename   string
	Home             string
	MobileSharedHome string
	GPG              string
	GPGHome          string
	GPGOptions       []string
	Debug            bool
	// Whether we are in Devel Mode
	Devel bool
	// If we're in dev mode, the name for this test, with a random
	// suffix.
	DevelName                string
	DevelPrefix              string // when in test - name for the test without suffix.
	RuntimeDir               string
	DisableUpgradePerUserKey bool
	EnvironmentFeatureFlags  FeatureFlags

	// set to true to use production run mode in tests
	UseProductionRunMode bool

	// whether LogoutIfRevoked check should be skipped to avoid races
	// during resets.
	SkipLogoutIfRevokedCheck bool

	// On if, in test, we want to skip sending system chat messages
	SkipSendingSystemChatMessages bool

	// If we need to use the real clock for NIST generation (as in really
	// whacky tests liks TestRekey).
	UseTimeClockForNISTs bool

	// TeamNoHeadMerkleStore is used for testing to emulate older clients
	// that didn't store the head merkle sequence to team chain state. We
	// have an upgrade path in the code that we'd like to test.
	TeamNoHeadMerkleStore bool

	// TeamSkipAudit is on because some team chains are "canned" and therefore
	// might point off of the merkle sequence in the database. So it's just
	// easiest to skip the audit in those cases.
	TeamSkipAudit bool

	// NoGregor is on if we want to test the service without any gregor conection
	NoGregor bool

	// TeamAuditParams can be customized if we want to control the behavior
	// of audits deep in a test
	TeamAuditParams *TeamAuditParams

	// Toggle if we want to try to 'prime' the secret store before using it.
	SecretStorePrimingDisabled bool

	// Extra headers for API
	APIHeaders map[string]string
}

func (TestParameters) GetDebug

func (tp TestParameters) GetDebug() (bool, bool)

func (TestParameters) GetNoGregor

func (tp TestParameters) GetNoGregor() (bool, bool)

func (TestParameters) GetSecretStorePrimingDisabled

func (tp TestParameters) GetSecretStorePrimingDisabled() (bool, bool)

type TestSecretUI

type TestSecretUI struct {
	Passphrase          string
	StoreSecret         bool
	CalledGetPassphrase bool
}

func (*TestSecretUI) GetPassphrase

type TestUIDMapper

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

func NewTestUIDMapper

func NewTestUIDMapper(ul UPAKLoader) TestUIDMapper

func (TestUIDMapper) CheckUIDAgainstUsername

func (t TestUIDMapper) CheckUIDAgainstUsername(uid keybase1.UID, un NormalizedUsername) bool

func (TestUIDMapper) ClearUIDAtEldestSeqno

func (t TestUIDMapper) ClearUIDAtEldestSeqno(_ context.Context, _ UIDMapperContext, _ keybase1.UID, _ keybase1.Seqno) error

func (TestUIDMapper) ClearUIDFullName

func (t TestUIDMapper) ClearUIDFullName(_ context.Context, _ UIDMapperContext, _ keybase1.UID) error

func (TestUIDMapper) InformOfEldestSeqno

func (t TestUIDMapper) InformOfEldestSeqno(ctx context.Context, g UIDMapperContext, uv keybase1.UserVersion) (bool, error)

func (TestUIDMapper) MapHardcodedUsernameToUID

func (t TestUIDMapper) MapHardcodedUsernameToUID(un NormalizedUsername) keybase1.UID

func (TestUIDMapper) MapUIDsToUsernamePackages

func (t TestUIDMapper) MapUIDsToUsernamePackages(ctx context.Context, g UIDMapperContext, uids []keybase1.UID, fullNameFreshness time.Duration, networkTimeBudget time.Duration, forceNetworkForFullNames bool) ([]UsernamePackage, error)

func (TestUIDMapper) MapUIDsToUsernamePackagesOffline

func (t TestUIDMapper) MapUIDsToUsernamePackagesOffline(ctx context.Context, g UIDMapperContext, uids []keybase1.UID, fullNameFreshness time.Duration) ([]UsernamePackage, error)

func (TestUIDMapper) SetTestingNoCachingMode

func (t TestUIDMapper) SetTestingNoCachingMode(enabled bool)

type TestingTB

type TestingTB interface {
	Error(args ...interface{})
	Errorf(format string, args ...interface{})
	Fail()
	FailNow()
	Failed() bool
	Fatal(args ...interface{})
	Fatalf(format string, args ...interface{})
	Log(args ...interface{})
	Logf(format string, args ...interface{})
	Name() string
	Skip(args ...interface{})
	SkipNow()
	Skipf(format string, args ...interface{})
	Skipped() bool
	Helper()
}

TestingTB is a copy of the exported parts of testing.TB. We define this in order to avoid pulling in the "testing" package in exported code.

type TimeoutError

type TimeoutError struct{}

func (TimeoutError) Error

func (e TimeoutError) Error() string

func (TimeoutError) ToStatus

func (e TimeoutError) ToStatus() keybase1.Status

type TimerSelector

type TimerSelector int

TimerSelector allows us to select which timers we want on.

const (
	// TimerNone means Timers Disabled
	TimerNone TimerSelector = 0
	// TimerAPI enables API timers
	TimerAPI TimerSelector = 1 << iota
	// TimerXAPI enables External API timers
	TimerXAPI
	// TimerRPC enables RPC timers
	TimerRPC
)

type TimerSet

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

TimerSet is the set of currently active timers

func NewTimerSet

func NewTimerSet(g *GlobalContext) *TimerSet

NewTimerSet looks into the given context for configuration information about how to set up timers. It then returns the corresponding TimerSet.

func (TimerSet) Start

func (s TimerSet) Start(sel TimerSelector) ReportingTimer

Start allocates and starts a new timer if the passed TimerSelector is currently enabled. Otherwise, it just returns a Dummy timer.

type TlfPseudonym

type TlfPseudonym [32]byte

TLFPseudonym is an identifier for a key in a tlf

func MakePseudonym

func MakePseudonym(info TlfPseudonymInfo) (TlfPseudonym, error)

MakePseudonym makes a TLF pseudonym from the given input.

func PostTlfPseudonyms

func PostTlfPseudonyms(ctx context.Context, g *GlobalContext, pnymInfos []TlfPseudonymInfo) ([]TlfPseudonym, error)

func (TlfPseudonym) Eq

func (t TlfPseudonym) Eq(r TlfPseudonym) bool

func (TlfPseudonym) String

func (t TlfPseudonym) String() string

type TlfPseudonymInfo

type TlfPseudonymInfo struct {
	// TLF name like: /keybase/private/a,b
	Name string
	// TLF id
	ID      tlfID
	KeyGen  KeyGen
	HmacKey [32]byte
}

TlfPseudonymInfo is what a pseudonym represents

type TlfPseudonymServerInfo

type TlfPseudonymServerInfo struct {
	TlfPseudonymInfo

	// Using untrusted data during decryption is safe because we don't rely on
	// TLF keys for sender authenticity. (Note however that senders must not
	// use untrusted keys, or else they'd lose all privacy.)
	UntrustedCurrentName string
}

The server returns the current full name of the TLF, in addition to the TlfPseudonymInfo above.

type Token

type Token struct {
	Typ int
	// contains filtered or unexported fields
}

func NewToken

func NewToken(typ int) Token

func (Token) Eq

func (t Token) Eq(t2 Token) bool

type TooManyKeysError

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

func (TooManyKeysError) Error

func (e TooManyKeysError) Error() string

type TorMode

type TorMode int
const (
	TorNone TorMode = iota
	TorStrict
	TorLeaky
)

func StringToTorMode

func StringToTorMode(s string) (ret TorMode, err error)

func (TorMode) Enabled

func (m TorMode) Enabled() bool

func (TorMode) UseCSRF

func (m TorMode) UseCSRF() bool

func (TorMode) UseCookies

func (m TorMode) UseCookies() bool

func (TorMode) UseHeaders

func (m TorMode) UseHeaders() bool

func (TorMode) UseSession

func (m TorMode) UseSession() bool

type TorSessionRequiredError

type TorSessionRequiredError struct{}

func (TorSessionRequiredError) Error

func (t TorSessionRequiredError) Error() string

type TrackBrokenError

type TrackBrokenError struct{}

func (TrackBrokenError) Error

func (e TrackBrokenError) Error() string

type TrackCache

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

func NewTrackCache

func NewTrackCache() *TrackCache

func (*TrackCache) Delete

func (c *TrackCache) Delete(key keybase1.TrackToken) error

func (*TrackCache) Get

func (*TrackCache) Insert

func (c *TrackCache) Insert(outcome *IdentifyOutcome) (keybase1.TrackToken, error)

func (*TrackCache) Shutdown

func (c *TrackCache) Shutdown()
type TrackChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}

========================================================================= TrackChainLink

func GetRemoteChainLinkFor

func GetRemoteChainLinkFor(m MetaContext, follower *keybase1.UserPlusKeysV2AllIncarnations, followeeUsername NormalizedUsername, followeeUID keybase1.UID) (ret *TrackChainLink, err error)

func LocalTmpTrackChainLinkFor

func LocalTmpTrackChainLinkFor(m MetaContext, tracker, trackee keybase1.UID) (ret *TrackChainLink, err error)

func LocalTrackChainLinkFor

func LocalTrackChainLinkFor(m MetaContext, tracker, trackee keybase1.UID) (ret *TrackChainLink, err error)
func ParseTrackChainLink(b GenericChainLink) (ret *TrackChainLink, err error)

func TmpTrackChainLinkFor

func TmpTrackChainLinkFor(m MetaContext, me keybase1.UID, them keybase1.UID) (tcl *TrackChainLink, err error)

func TrackChainLinkFor

func TrackChainLinkFor(m MetaContext, me keybase1.UID, them keybase1.UID, remote *TrackChainLink, remoteErr error) (*TrackChainLink, error)

func TrackChainLinkFromUPK2AI

func TrackChainLinkFromUPK2AI(m MetaContext, follower *keybase1.UserPlusKeysV2AllIncarnations, followeeUsername NormalizedUsername, followeeUID keybase1.UID) (*TrackChainLink, error)

func (*TrackChainLink) DoOwnNewLinkFromServerNotifications

func (l *TrackChainLink) DoOwnNewLinkFromServerNotifications(g *GlobalContext)

func (TrackChainLink) Export

func (t TrackChainLink) Export() keybase1.RemoteTrack

func (*TrackChainLink) GetEldestKID

func (l *TrackChainLink) GetEldestKID() (kid keybase1.KID, err error)

func (*TrackChainLink) GetTmpExpireTime

func (l *TrackChainLink) GetTmpExpireTime() (ret time.Time)

func (*TrackChainLink) GetTrackedKeys

func (l *TrackChainLink) GetTrackedKeys() ([]TrackedKey, error)

func (*TrackChainLink) GetTrackedLinkSeqno

func (l *TrackChainLink) GetTrackedLinkSeqno() (seqno keybase1.Seqno, err error)

Get the tail of the trackee's sigchain.

func (*TrackChainLink) GetTrackedUID

func (l *TrackChainLink) GetTrackedUID() (keybase1.UID, error)

func (*TrackChainLink) GetTrackedUsername

func (l *TrackChainLink) GetTrackedUsername() (NormalizedUsername, error)

func (TrackChainLink) IsRemote

func (l TrackChainLink) IsRemote() bool

func (*TrackChainLink) IsRevoked

func (l *TrackChainLink) IsRevoked() bool

func (*TrackChainLink) RemoteKeyProofs

func (l *TrackChainLink) RemoteKeyProofs() *jsonw.Wrapper

func (*TrackChainLink) ToDisplayString

func (l *TrackChainLink) ToDisplayString() string

func (*TrackChainLink) ToServiceBlocks

func (l *TrackChainLink) ToServiceBlocks() (ret []*ServiceBlock)

func (*TrackChainLink) Type

func (l *TrackChainLink) Type() string

type TrackDiff

type TrackDiff interface {
	BreaksTracking() bool
	ToDisplayString() string
	ToDisplayMarkup() *Markup
	IsSameAsTracked() bool
	GetTrackDiffType() keybase1.TrackDiffType
}

type TrackDiffClash

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

func (TrackDiffClash) BreaksTracking

func (t TrackDiffClash) BreaksTracking() bool

func (TrackDiffClash) GetTrackDiffType

func (t TrackDiffClash) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffClash) IsSameAsTracked

func (t TrackDiffClash) IsSameAsTracked() bool

func (TrackDiffClash) ToDisplayMarkup

func (t TrackDiffClash) ToDisplayMarkup() *Markup

func (TrackDiffClash) ToDisplayString

func (t TrackDiffClash) ToDisplayString() string

type TrackDiffNew

type TrackDiffNew struct{}

func (TrackDiffNew) BreaksTracking

func (t TrackDiffNew) BreaksTracking() bool

func (TrackDiffNew) GetTrackDiffType

func (t TrackDiffNew) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffNew) IsSameAsTracked

func (t TrackDiffNew) IsSameAsTracked() bool

func (TrackDiffNew) ToDisplayMarkup

func (t TrackDiffNew) ToDisplayMarkup() *Markup

func (TrackDiffNew) ToDisplayString

func (t TrackDiffNew) ToDisplayString() string

type TrackDiffNewEldest

type TrackDiffNewEldest struct {
	// contains filtered or unexported fields
}

func (TrackDiffNewEldest) BreaksTracking

func (t TrackDiffNewEldest) BreaksTracking() bool

func (TrackDiffNewEldest) GetTrackDiffType

func (t TrackDiffNewEldest) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffNewEldest) IsSameAsTracked

func (t TrackDiffNewEldest) IsSameAsTracked() bool

func (TrackDiffNewEldest) ToDisplayMarkup

func (t TrackDiffNewEldest) ToDisplayMarkup() *Markup

func (TrackDiffNewEldest) ToDisplayString

func (t TrackDiffNewEldest) ToDisplayString() string

type TrackDiffNone

type TrackDiffNone struct{}

func (TrackDiffNone) BreaksTracking

func (t TrackDiffNone) BreaksTracking() bool

func (TrackDiffNone) GetTrackDiffType

func (t TrackDiffNone) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffNone) IsSameAsTracked

func (t TrackDiffNone) IsSameAsTracked() bool

func (TrackDiffNone) ToDisplayMarkup

func (t TrackDiffNone) ToDisplayMarkup() *Markup

func (TrackDiffNone) ToDisplayString

func (t TrackDiffNone) ToDisplayString() string

type TrackDiffNoneViaTemporary

type TrackDiffNoneViaTemporary struct{}

func (TrackDiffNoneViaTemporary) BreaksTracking

func (t TrackDiffNoneViaTemporary) BreaksTracking() bool

func (TrackDiffNoneViaTemporary) GetTrackDiffType

func (t TrackDiffNoneViaTemporary) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffNoneViaTemporary) IsSameAsTracked

func (t TrackDiffNoneViaTemporary) IsSameAsTracked() bool

func (TrackDiffNoneViaTemporary) ToDisplayMarkup

func (t TrackDiffNoneViaTemporary) ToDisplayMarkup() *Markup

func (TrackDiffNoneViaTemporary) ToDisplayString

func (t TrackDiffNoneViaTemporary) ToDisplayString() string

type TrackDiffRemoteChanged

type TrackDiffRemoteChanged struct {
	// contains filtered or unexported fields
}

func (TrackDiffRemoteChanged) BreaksTracking

func (t TrackDiffRemoteChanged) BreaksTracking() bool

func (TrackDiffRemoteChanged) GetTrackDiffType

func (t TrackDiffRemoteChanged) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffRemoteChanged) IsSameAsTracked

func (t TrackDiffRemoteChanged) IsSameAsTracked() bool

func (TrackDiffRemoteChanged) ToDisplayMarkup

func (t TrackDiffRemoteChanged) ToDisplayMarkup() *Markup

func (TrackDiffRemoteChanged) ToDisplayString

func (t TrackDiffRemoteChanged) ToDisplayString() string

type TrackDiffRemoteFail

type TrackDiffRemoteFail struct {
	// contains filtered or unexported fields
}

func (TrackDiffRemoteFail) BreaksTracking

func (t TrackDiffRemoteFail) BreaksTracking() bool

func (TrackDiffRemoteFail) GetTrackDiffType

func (t TrackDiffRemoteFail) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffRemoteFail) IsSameAsTracked

func (t TrackDiffRemoteFail) IsSameAsTracked() bool

func (TrackDiffRemoteFail) ToDisplayMarkup

func (t TrackDiffRemoteFail) ToDisplayMarkup() *Markup

func (TrackDiffRemoteFail) ToDisplayString

func (t TrackDiffRemoteFail) ToDisplayString() string

type TrackDiffRemoteWorking

type TrackDiffRemoteWorking struct {
	// contains filtered or unexported fields
}

func (TrackDiffRemoteWorking) BreaksTracking

func (t TrackDiffRemoteWorking) BreaksTracking() bool

func (TrackDiffRemoteWorking) GetTrackDiffType

func (t TrackDiffRemoteWorking) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffRemoteWorking) IsSameAsTracked

func (t TrackDiffRemoteWorking) IsSameAsTracked() bool

func (TrackDiffRemoteWorking) ToDisplayMarkup

func (t TrackDiffRemoteWorking) ToDisplayMarkup() *Markup

func (TrackDiffRemoteWorking) ToDisplayString

func (t TrackDiffRemoteWorking) ToDisplayString() string

type TrackDiffRevoked

type TrackDiffRevoked struct {
	// contains filtered or unexported fields
}

func (TrackDiffRevoked) BreaksTracking

func (t TrackDiffRevoked) BreaksTracking() bool

func (TrackDiffRevoked) GetTrackDiffType

func (t TrackDiffRevoked) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffRevoked) IsSameAsTracked

func (t TrackDiffRevoked) IsSameAsTracked() bool

func (TrackDiffRevoked) ToDisplayMarkup

func (t TrackDiffRevoked) ToDisplayMarkup() *Markup

func (TrackDiffRevoked) ToDisplayString

func (t TrackDiffRevoked) ToDisplayString() string

type TrackDiffSnoozedRevoked

type TrackDiffSnoozedRevoked struct {
	// contains filtered or unexported fields
}

func (TrackDiffSnoozedRevoked) BreaksTracking

func (t TrackDiffSnoozedRevoked) BreaksTracking() bool

func (TrackDiffSnoozedRevoked) GetTrackDiffType

func (t TrackDiffSnoozedRevoked) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffSnoozedRevoked) IsSameAsTracked

func (t TrackDiffSnoozedRevoked) IsSameAsTracked() bool

func (TrackDiffSnoozedRevoked) ToDisplayMarkup

func (t TrackDiffSnoozedRevoked) ToDisplayMarkup() *Markup

func (TrackDiffSnoozedRevoked) ToDisplayString

func (t TrackDiffSnoozedRevoked) ToDisplayString() string

type TrackDiffUpgraded

type TrackDiffUpgraded struct {
	// contains filtered or unexported fields
}

func (TrackDiffUpgraded) BreaksTracking

func (t TrackDiffUpgraded) BreaksTracking() bool

func (TrackDiffUpgraded) GetCurr

func (t TrackDiffUpgraded) GetCurr() string

func (TrackDiffUpgraded) GetPrev

func (t TrackDiffUpgraded) GetPrev() string

func (TrackDiffUpgraded) GetTrackDiffType

func (t TrackDiffUpgraded) GetTrackDiffType() keybase1.TrackDiffType

func (TrackDiffUpgraded) IsSameAsTracked

func (t TrackDiffUpgraded) IsSameAsTracked() bool

func (TrackDiffUpgraded) ToDisplayMarkup

func (t TrackDiffUpgraded) ToDisplayMarkup() *Markup

func (TrackDiffUpgraded) ToDisplayString

func (t TrackDiffUpgraded) ToDisplayString() string

type TrackIDComponent

type TrackIDComponent interface {
	ToIDString() string
	ToKeyValuePair() (string, string)
	GetProofState() keybase1.ProofState
	LastWriterWins() bool
	GetProofType() keybase1.ProofType
}

Can be a ProofLinkWithState, one of the identities listed in a tracking statement, or a PGP Fingerprint!

type TrackInstructions

type TrackInstructions struct {
	Local  bool
	Remote bool
}

type TrackLookup

type TrackLookup struct {
	Contextified
	// contains filtered or unexported fields
}

func NewTrackLookup

func NewTrackLookup(g *GlobalContext, link *TrackChainLink) *TrackLookup

func (*TrackLookup) GetCTime

func (l *TrackLookup) GetCTime() time.Time

func (TrackLookup) GetEldestKID

func (l TrackLookup) GetEldestKID() keybase1.KID

func (TrackLookup) GetProofState

func (l TrackLookup) GetProofState(id string) keybase1.ProofState

func (TrackLookup) GetTmpExpireTime

func (l TrackLookup) GetTmpExpireTime() (ret time.Time)

func (TrackLookup) GetTrackedKeys

func (l TrackLookup) GetTrackedKeys() []TrackedKey

func (TrackLookup) GetTrackedLinkSeqno

func (l TrackLookup) GetTrackedLinkSeqno() keybase1.Seqno

func (TrackLookup) GetTrackerSeqno

func (l TrackLookup) GetTrackerSeqno() keybase1.Seqno

func (TrackLookup) IsRemote

func (l TrackLookup) IsRemote() bool

func (TrackLookup) ToSummary

func (l TrackLookup) ToSummary() TrackSummary

type TrackSet

type TrackSet struct {
	// contains filtered or unexported fields
}

func NewTrackSet

func NewTrackSet() *TrackSet

func (TrackSet) Add

func (ts TrackSet) Add(t TrackIDComponent)

func (TrackSet) GetProofState

func (ts TrackSet) GetProofState(id string) keybase1.ProofState

func (TrackSet) HasMember

func (ts TrackSet) HasMember(t TrackIDComponent) bool

func (TrackSet) LenEq

func (ts TrackSet) LenEq(b TrackSet) bool

func (TrackSet) Subtract

func (ts TrackSet) Subtract(b TrackSet) (out []TrackIDComponent)

type TrackStaleError

type TrackStaleError struct {
	FirstTrack bool
}

func (TrackStaleError) Error

func (e TrackStaleError) Error() string

type TrackSummary

type TrackSummary struct {
	// contains filtered or unexported fields
}

func ImportTrackSummary

func ImportTrackSummary(s *keybase1.TrackSummary) *TrackSummary

func (TrackSummary) Export

func (s TrackSummary) Export(username string) (ret keybase1.TrackSummary)

func (TrackSummary) GetCTime

func (s TrackSummary) GetCTime() time.Time

func (TrackSummary) IsRemote

func (s TrackSummary) IsRemote() bool

func (TrackSummary) Username

func (s TrackSummary) Username() string

type TrackedKey

type TrackedKey struct {
	KID         keybase1.KID
	Fingerprint *PGPFingerprint
}

type TrackingBrokeError

type TrackingBrokeError struct{}

func (TrackingBrokeError) Error

func (e TrackingBrokeError) Error() string

func (TrackingBrokeError) ToStatus

func (e TrackingBrokeError) ToStatus() keybase1.Status

type Triplesec

type Triplesec interface {
	DeriveKey(l int) ([]byte, []byte, error)
	Decrypt([]byte) ([]byte, error)
	Encrypt([]byte) ([]byte, error)
	Scrub()
}

func NewSecureTriplesec

func NewSecureTriplesec(passphrase []byte, salt []byte) (Triplesec, error)
type TypedChainLink interface {
	GetRevocations() []keybase1.SigID
	GetRevokeKids() []keybase1.KID

	GetSigID() keybase1.SigID
	GetArmoredSig() string

	ToDebugString() string
	Type() string
	ToDisplayString() string
	IsRevocationIsh() bool
	IsRevoked() bool
	IsDirectlyRevoked() bool
	GetRole() KeyRole
	GetSeqno() keybase1.Seqno
	GetCTime() time.Time
	GetETime() time.Time
	GetPGPFingerprint() *PGPFingerprint
	GetPGPFullHash() string
	GetKID() keybase1.KID
	IsInCurrentFamily(u *User) bool
	GetUsername() string
	GetUID() keybase1.UID
	GetDelegatedKid() keybase1.KID
	GetMerkleHashMeta() (keybase1.HashMeta, error)
	GetParentKid() keybase1.KID
	VerifyReverseSig(ckf ComputedKeyFamily) error
	GetMerkleSeqno() keybase1.Seqno
	GetFirstAppearedMerkleSeqnoUnverified() keybase1.Seqno
	GetDevice() *Device
	DoOwnNewLinkFromServerNotifications(g *GlobalContext)
	ToSigChainLocation() keybase1.SigChainLocation
	// contains filtered or unexported methods
}

type U

type U struct {
	Val uint64
}

func (U) String

func (u U) String() string

type UHex

type UHex struct {
	Val uint64
}

func (UHex) String

func (h UHex) String() string

type UI

type UI interface {
	GetIdentifyUI() IdentifyUI
	GetIdentifyTrackUI() IdentifyUI
	GetLoginUI() LoginUI
	GetSecretUI() SecretUI
	GetTerminalUI() TerminalUI
	GetDumbOutputUI() DumbOutputUI
	GetProveUI() ProveUI
	GetLogUI() LogUI
	GetGPGUI() GPGUI
	GetProvisionUI(role KexRole) ProvisionUI
	GetPgpUI() PgpUI
	Configure() error
	Shutdown() error
}

type UIConsumer

type UIConsumer interface {
	Name() string
	RequiredUIs() []UIKind
	SubConsumers() []UIConsumer
}

type UIDMapper

type UIDMapper interface {
	// CheckUIDAginstUsername makes sure that the UID actually does map to the given username.
	// For new UIDs, it's a question of just SHA2'ing. For legacy usernames, we check the
	// hardcoded map.
	CheckUIDAgainstUsername(uid keybase1.UID, un NormalizedUsername) bool

	// MapHardcodedUsernameToUID will map the given legacy username to a UID if it exists
	// in the hardcoded map. If not, it will return the nil UID.
	MapHardcodedUsernameToUID(un NormalizedUsername) keybase1.UID

	// MapUIDToUsernamePackages maps the given set of UIDs to the username
	// packages, which include a username and a fullname, and when the mapping
	// was loaded from the server. It blocks on the network until all usernames
	// are known. If the `forceNetworkForFullNames` flag is specified, it will
	// block on the network too. If the flag is not specified, then stale
	// values (or unknown values) are OK, we won't go to network if we lack
	// them. All network calls are limited by the given timeBudget, or if 0 is
	// specified, there is indefinite budget. In the response, a nil
	// FullNamePackage means that the lookup failed. A non-nil FullNamePackage
	// means that some previous lookup worked, but might be arbitrarily out of
	// date (depending on the cachedAt time). A non-nil FullNamePackage with an
	// empty fullName field means that the user just hasn't supplied a
	// fullName.
	//
	// *NOTE* that this function can return useful data and an error. In this
	// regard, the error is more like a warning. But if, for instance, the
	// mapper runs out of time budget, it will return the data
	MapUIDsToUsernamePackages(ctx context.Context, g UIDMapperContext, uids []keybase1.UID, fullNameFreshness time.Duration,
		networktimeBudget time.Duration, forceNetworkForFullNames bool) ([]UsernamePackage, error)

	// SetTestingNoCachingMode puts the UID mapper into a mode where it never serves cached results, *strictly
	// for use in tests*
	SetTestingNoCachingMode(enabled bool)

	ClearUIDFullName(context.Context, UIDMapperContext, keybase1.UID) error

	// ClearUID is called to clear the given UID out of the cache, if the given eldest
	// seqno doesn't match what's currently cached.
	ClearUIDAtEldestSeqno(context.Context, UIDMapperContext, keybase1.UID, keybase1.Seqno) error

	// InformOfEldestSeqno informs the mapper of an up-to-date (uid,eldestSeqno) pair.
	// If the cache has a different value, it will clear the cache and then plumb
	// the pair all the way through to the server, whose cache may also be in need
	// of busting. Will return true if the cached value was up-to-date, and false
	// otherwise.
	InformOfEldestSeqno(context.Context, UIDMapperContext, keybase1.UserVersion) (bool, error)

	// MapUIDsToUsernamePackagesOffline maps given set of UIDs to username packages
	// from the cache only. No network calls will be made. Results might contains
	// unresolved usernames (caller should check with `IsNil()`).
	MapUIDsToUsernamePackagesOffline(ctx context.Context, g UIDMapperContext,
		uids []keybase1.UID, fullNameFreshness time.Duration) ([]UsernamePackage, error)
}

type UIDMapperContext

type UIDMapperContext interface {
	VLogContext
	APIContext
	KVStoreContext
	ClockContext
}

type UIDMismatchError

type UIDMismatchError struct {
	Msg string
}

func NewUIDMismatchError

func NewUIDMismatchError(m string) UIDMismatchError

func (UIDMismatchError) Error

func (u UIDMismatchError) Error() string

type UIDelegationUnavailableError

type UIDelegationUnavailableError struct{}

func (UIDelegationUnavailableError) Error

func (UIDelegationUnavailableError) ToStatus

type UIDer

type UIDer interface {
	GetUID() keybase1.UID
}

type UIKind

type UIKind int
const (
	GPGUIKind UIKind = iota
	IdentifyUIKind
	LogUIKind
	LoginUIKind
	ProveUIKind
	SecretUIKind
	ProvisionUIKind
	PgpUIKind
	UpdateUIKind
	SaltpackUIKind
	RekeyUIKind
	HomeUIKind
	Identify3UIKind
	ChatUIKind
)

func (UIKind) String

func (u UIKind) String() string

type UIRouter

type UIRouter interface {
	SetUI(ConnectionID, UIKind)

	// These are allowed to return nil for the UI even if
	// error is nil.
	GetIdentifyUI() (IdentifyUI, error)
	GetIdentifyUICtx(ctx context.Context) (int, IdentifyUI, error)
	GetSecretUI(sessionID int) (SecretUI, error)
	GetRekeyUI() (keybase1.RekeyUIInterface, int, error)
	GetRekeyUINoSessionID() (keybase1.RekeyUIInterface, error)
	GetHomeUI() (keybase1.HomeUIInterface, error)
	GetIdentify3UIAdapter(MetaContext) (IdentifyUI, error)
	GetIdentify3UI(MetaContext) (keybase1.Identify3UiInterface, error)
	GetChatUI() (ChatUI, error)
	GetLogUI() (LogUI, error)

	// WaitForUIType returns true if a UI of the specified type is registered,
	// or waits until timeout for such UI to register and returns false if this
	// does not happen.
	WaitForUIType(uiKind UIKind, timeout time.Duration) bool

	DumpUIs() map[UIKind]ConnectionID
	Shutdown()
}

type UIs

type UIs struct {
	GPGUI       GPGUI
	LogUI       LogUI
	LoginUI     LoginUI
	SecretUI    SecretUI
	IdentifyUI  IdentifyUI
	PgpUI       PgpUI
	ProveUI     ProveUI
	ProvisionUI ProvisionUI
	SaltpackUI  SaltpackUI

	// Usually set to `NONE`, meaning none specified.
	// But if we know it, specify the end client type here
	// since some things like GPG shell-out work differently
	// depending.
	ClientType keybase1.ClientType

	SessionID int
}

func (UIs) HasUI

func (e UIs) HasUI(kind UIKind) bool

type UPAKLoader

type UPAKLoader interface {
	LoginAs(u keybase1.UID) (err error)
	OnLogout() (err error)
	ClearMemory()
	Load(arg LoadUserArg) (ret *keybase1.UserPlusAllKeys, user *User, err error)
	LoadV2(arg LoadUserArg) (ret *keybase1.UserPlusKeysV2AllIncarnations, user *User, err error)
	LoadLite(arg LoadUserArg) (ret *keybase1.UPKLiteV1AllIncarnations, err error)
	CheckKIDForUID(ctx context.Context, uid keybase1.UID, kid keybase1.KID) (found bool, revokedAt *keybase1.KeybaseTime, deleted bool, err error)
	LoadUserPlusKeys(ctx context.Context, uid keybase1.UID, pollForKID keybase1.KID) (keybase1.UserPlusKeys, error)
	LoadKeyV2(ctx context.Context, uid keybase1.UID, kid keybase1.KID) (*keybase1.UserPlusKeysV2, *keybase1.UserPlusKeysV2AllIncarnations, *keybase1.PublicKeyV2NaCl, error)
	Invalidate(ctx context.Context, uid keybase1.UID)
	LoadDeviceKey(ctx context.Context, uid keybase1.UID, deviceID keybase1.DeviceID) (upak *keybase1.UserPlusAllKeys, deviceKey *keybase1.PublicKey, revoked *keybase1.RevokedKey, err error)
	LoadUPAKWithDeviceID(ctx context.Context, uid keybase1.UID, deviceID keybase1.DeviceID) (*keybase1.UserPlusKeysV2AllIncarnations, error)
	LookupUsername(ctx context.Context, uid keybase1.UID) (NormalizedUsername, error)
	LookupUsernameUPAK(ctx context.Context, uid keybase1.UID) (NormalizedUsername, error)
	LookupUID(ctx context.Context, un NormalizedUsername) (keybase1.UID, error)
	LookupUsernameAndDevice(ctx context.Context, uid keybase1.UID, did keybase1.DeviceID) (username NormalizedUsername, deviceName string, deviceType keybase1.DeviceTypeV2, err error)
	PutUserToCache(ctx context.Context, user *User) error
	LoadV2WithKID(ctx context.Context, uid keybase1.UID, kid keybase1.KID) (*keybase1.UserPlusKeysV2AllIncarnations, error)
	CheckDeviceForUIDAndUsername(ctx context.Context, uid keybase1.UID, did keybase1.DeviceID, n NormalizedUsername, suppressNetworkErrors bool) error
	Batcher(ctx context.Context, getArg func(int) *LoadUserArg, processResult func(int, *keybase1.UserPlusKeysV2AllIncarnations) error, window int) (err error)
}

UPAK Loader is a loader for UserPlusKeysV2AllIncarnations. It's a thin user object that is almost as good for many purposes, but can be safely copied and serialized.

func NewUncachedUPAKLoader

func NewUncachedUPAKLoader(g *GlobalContext) UPAKLoader

NewUncachedUPAKLoader creates a UPAK loader that doesn't do any caching. It uses the implementation of CachedUPAKLoader but disables all caching.

type UTF16UnsupportedError

type UTF16UnsupportedError struct{}

func (UTF16UnsupportedError) Error

func (e UTF16UnsupportedError) Error() string

type UnboxError

type UnboxError struct {
	// contains filtered or unexported fields
}

func NewUnboxError

func NewUnboxError(inner error) UnboxError

func NewUnboxErrorWithInfo

func NewUnboxErrorWithInfo(inner error, info string) UnboxError

func (UnboxError) Error

func (e UnboxError) Error() string

func (UnboxError) Info

func (e UnboxError) Info() string

type UncachedFullSelf

type UncachedFullSelf struct {
	Contextified
}

func NewUncachedFullSelf

func NewUncachedFullSelf(g *GlobalContext) *UncachedFullSelf

func (*UncachedFullSelf) HandleUserChanged

func (n *UncachedFullSelf) HandleUserChanged(u keybase1.UID) error

func (*UncachedFullSelf) New

func (n *UncachedFullSelf) New() FullSelfer

func (*UncachedFullSelf) OnLogin

func (n *UncachedFullSelf) OnLogin(mctx MetaContext) error

func (*UncachedFullSelf) Update

func (n *UncachedFullSelf) Update(ctx context.Context, u *User) error

func (*UncachedFullSelf) WithSelf

func (n *UncachedFullSelf) WithSelf(ctx context.Context, f func(u *User) error) error

func (*UncachedFullSelf) WithSelfForcePoll

func (n *UncachedFullSelf) WithSelfForcePoll(ctx context.Context, f func(u *User) error) error

func (*UncachedFullSelf) WithUser

func (n *UncachedFullSelf) WithUser(arg LoadUserArg, f func(u *User) error) error

type UnexpectedChatDataFromServer

type UnexpectedChatDataFromServer struct {
	Msg string
}

func (UnexpectedChatDataFromServer) Error

type UnexpectedKeyError

type UnexpectedKeyError struct {
}

func (UnexpectedKeyError) Error

func (e UnexpectedKeyError) Error() string

type UnforwardedLoggerWithLegacyInterface

type UnforwardedLoggerWithLegacyInterface interface {
	Debug(s string, args ...interface{})
	Error(s string, args ...interface{})
	Errorf(s string, args ...interface{})
	Warning(s string, args ...interface{})
	Info(s string, args ...interface{})
	Profile(s string, args ...interface{})
}

type UnknownKeyTypeError

type UnknownKeyTypeError struct {
	// contains filtered or unexported fields
}

func (UnknownKeyTypeError) Error

func (e UnknownKeyTypeError) Error() string

type UnknownSpecialKIDError

type UnknownSpecialKIDError struct {
	// contains filtered or unexported fields
}

func (UnknownSpecialKIDError) Error

func (u UnknownSpecialKIDError) Error() string

type UnknownStreamError

type UnknownStreamError struct{}

func (UnknownStreamError) Error

func (e UnknownStreamError) Error() string

func (UnknownStreamError) ToStatus

func (e UnknownStreamError) ToStatus() (s keybase1.Status)

type UnlockerFunc

type UnlockerFunc func(pw string, storeSecret bool) (ret GenericKey, err error)

type UnmetAssertionError

type UnmetAssertionError struct {
	User   string
	Remote bool
}

func (UnmetAssertionError) Error

func (e UnmetAssertionError) Error() string
type UntrackChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseUntrackChainLink(b GenericChainLink) (ret *UntrackChainLink, err error)

func (*UntrackChainLink) DoOwnNewLinkFromServerNotifications

func (u *UntrackChainLink) DoOwnNewLinkFromServerNotifications(g *GlobalContext)

func (*UntrackChainLink) IsRevocationIsh

func (u *UntrackChainLink) IsRevocationIsh() bool

func (*UntrackChainLink) ToDisplayString

func (u *UntrackChainLink) ToDisplayString() string

func (*UntrackChainLink) Type

func (u *UntrackChainLink) Type() string

type UntrackError

type UntrackError struct {
	// contains filtered or unexported fields
}

func NewUntrackError

func NewUntrackError(d string, a ...interface{}) UntrackError

func (UntrackError) Error

func (e UntrackError) Error() string

type UpdaterConfigReader

type UpdaterConfigReader interface {
	GetInstallID() InstallID
}

type Usage

type Usage struct {
	Config     bool
	GpgKeyring bool
	KbKeyring  bool
	API        bool
	Socket     bool
	AllowRoot  bool
}

func (Usage) UseKeyring

func (u Usage) UseKeyring() bool

type User

type User struct {
	Contextified
	// contains filtered or unexported fields
}

func LoadMe

func LoadMe(arg LoadUserArg) (*User, error)

func LoadMeByMetaContextAndUID

func LoadMeByMetaContextAndUID(m MetaContext, uid keybase1.UID) (*User, error)

func LoadMeByUID

func LoadMeByUID(ctx context.Context, g *GlobalContext, uid keybase1.UID) (*User, error)

func LoadUser

func LoadUser(arg LoadUserArg) (ret *User, err error)

func LoadUserFromLocalStorage

func LoadUserFromLocalStorage(m MetaContext, uid keybase1.UID) (u *User, err error)

func LoadUserFromServer

func LoadUserFromServer(m MetaContext, uid keybase1.UID, body *jsonw.Wrapper) (u *User, err error)

func NewUserFromLocalStorage

func NewUserFromLocalStorage(g *GlobalContext, o *jsonw.Wrapper) (*User, error)

func NewUserFromServer

func NewUserFromServer(g *GlobalContext, o *jsonw.Wrapper) (*User, error)

func NewUserThin

func NewUserThin(name string, uid keybase1.UID) *User

func (*User) AllSyncedSecretKeys

func (u *User) AllSyncedSecretKeys(m MetaContext) (keys []*SKB, err error)

AllSyncedSecretKeys returns all the PGP key blocks that were synced to API server. LoginContext can be nil if this isn't used while logging in, signing up.

func (*User) BaseProofSet

func (u *User) BaseProofSet() *ProofSet

BaseProofSet creates a basic proof set for a user with their keybase and uid proofs and any pgp fingerprint proofs.

func (*User) CheckBasicsFreshness

func (u *User) CheckBasicsFreshness(server int64) (current bool, reason string, err error)

func (*User) CryptocurrencySig

func (u *User) CryptocurrencySig(m MetaContext, key GenericKey, address string, typ CryptocurrencyType, sigToRevoke keybase1.SigID, merkleRoot *MerkleRoot, sigVersion SigVersion) (*ProofMetadataRes, error)

func (*User) DeviceNames

func (u *User) DeviceNames() ([]string, error)

func (*User) Equal

func (u *User) Equal(other *User) bool

func (*User) Export

func (u *User) Export() *keybase1.User

func (*User) ExportRemoteTracks

func (u *User) ExportRemoteTracks() []keybase1.RemoteTrack

NOTE: This list *must* be in sorted order. If we ever write V3, be careful to keep it sorted!

func (*User) ExportToUPKV2AllIncarnations

func (u *User) ExportToUPKV2AllIncarnations() (*keybase1.UserPlusKeysV2AllIncarnations, error)

func (*User) ExportToUserPlusAllKeys

func (u *User) ExportToUserPlusAllKeys() keybase1.UserPlusAllKeys

func (*User) ExportToUserPlusKeys

func (u *User) ExportToUserPlusKeys() keybase1.UserPlusKeys

func (*User) ExportToVersionVector

func (u *User) ExportToVersionVector() keybase1.UserVersionVector

func (*User) FilterActivePGPKeys

func (u *User) FilterActivePGPKeys(sibkey bool, query string) []*PGPKeyBundle

FilterActivePGPKeys returns the active pgp keys that match query.

func (*User) GetActivePGPFingerprints

func (u *User) GetActivePGPFingerprints(sibkey bool) (ret []PGPFingerprint)

GetActivePGPFingerprints looks into the user's ComputedKeyFamily and returns only the fingerprint of the active PGP keys. If you want only sibkeys, then // specify sibkey=true.

func (*User) GetActivePGPKIDs

func (u *User) GetActivePGPKIDs(sibkey bool) (ret []keybase1.KID)

func (*User) GetActivePGPKeys

func (u *User) GetActivePGPKeys(sibkey bool) (ret []*PGPKeyBundle)

GetActivePGPKeys looks into the user's ComputedKeyFamily and returns only the active PGP keys. If you want only sibkeys, then specify sibkey=true.

func (*User) GetComputedKeyFamily

func (u *User) GetComputedKeyFamily() (ret *ComputedKeyFamily)

func (*User) GetComputedKeyInfos

func (u *User) GetComputedKeyInfos() *ComputedKeyInfos

func (*User) GetCurrentEldestSeqno

func (u *User) GetCurrentEldestSeqno() keybase1.Seqno

func (*User) GetDevice

func (u *User) GetDevice(id keybase1.DeviceID) (*Device, error)

func (*User) GetDeviceSibkey

func (u *User) GetDeviceSibkey() (GenericKey, error)

func (*User) GetDeviceSubkey

func (u *User) GetDeviceSubkey() (subkey GenericKey, err error)

func (*User) GetEldestKID

func (u *User) GetEldestKID() (ret keybase1.KID)

May return an empty KID

func (*User) GetExpectedNextHighSkip

func (u *User) GetExpectedNextHighSkip(mctx MetaContext) (HighSkip, error)

func (*User) GetHighLinkSeqnos

func (u *User) GetHighLinkSeqnos(mctx MetaContext) (res []keybase1.Seqno, err error)

GetHighLinkSeqnos gets the list of all high links in the user's sigchain ascending.

func (*User) GetIDVersion

func (u *User) GetIDVersion() (int64, error)

func (*User) GetKeyFamily

func (u *User) GetKeyFamily() *KeyFamily
func (u *User) GetLastLink() *ChainLink

func (*User) GetName

func (u *User) GetName() string

func (*User) GetNormalizedName

func (u *User) GetNormalizedName() NormalizedUsername

func (*User) GetPublicChainTail

func (u *User) GetPublicChainTail() *MerkleTriple

func (*User) GetSalt

func (u *User) GetSalt() (salt []byte, err error)

func (*User) GetSigChainLastKnownID

func (u *User) GetSigChainLastKnownID() LinkID

func (*User) GetSigChainLastKnownSeqno

func (u *User) GetSigChainLastKnownSeqno() keybase1.Seqno

func (*User) GetSigHintsVersion

func (u *User) GetSigHintsVersion() int

func (*User) GetSigIDFromSeqno

func (u *User) GetSigIDFromSeqno(seqno keybase1.Seqno) keybase1.SigID

func (*User) GetStatus

func (u *User) GetStatus() keybase1.StatusCode

func (*User) GetSyncedSecretKey

func (u *User) GetSyncedSecretKey(m MetaContext) (ret *SKB, err error)

func (*User) GetSyncedSecretKeys

func (u *User) GetSyncedSecretKeys(m MetaContext) (ret []*SKB, err error)

func (*User) GetUID

func (u *User) GetUID() keybase1.UID

func (*User) HasActiveKey

func (u *User) HasActiveKey() (ret bool)

func (*User) HasCurrentDeviceInCurrentInstall

func (u *User) HasCurrentDeviceInCurrentInstall() bool

func (*User) HasDeviceInCurrentInstall

func (u *User) HasDeviceInCurrentInstall(did keybase1.DeviceID) bool

Returns whether or not the current install has an active device sibkey.

func (*User) HasEncryptionSubkey

func (u *User) HasEncryptionSubkey() bool

func (*User) IDTable

func (u *User) IDTable() *IdentityTable

func (*User) IsCachedIdentifyFresh

func (u *User) IsCachedIdentifyFresh(upk *keybase1.UserPlusKeysV2AllIncarnations) bool

func (*User) IsNewerThan

func (u *User) IsNewerThan(v *User) (bool, error)

func (*User) IsSigIDActive

func (u *User) IsSigIDActive(sigID keybase1.SigID) (bool, error)

func (*User) LinkFromSigID

func (u *User) LinkFromSigID(sigID keybase1.SigID) *ChainLink

func (*User) LoadSigChains

func (u *User) LoadSigChains(m MetaContext, f *MerkleUserLeaf, self bool, stubMode StubMode) (err error)

func (*User) MakeIDTable

func (u *User) MakeIDTable(m MetaContext) error

func (User) PartialCopy

func (u User) PartialCopy() *User

PartialCopy copies some fields of the User object, but not all. For instance, it doesn't copy the SigChain or IDTable, and it only makes a shallow copy of the ComputedKeyFamily.

func (*User) RevokeKeysProof

func (u *User) RevokeKeysProof(m MetaContext, key GenericKey, kidsToRevoke []keybase1.KID,
	deviceToDisable keybase1.DeviceID, merkleRoot *MerkleRoot) (*ProofMetadataRes, error)

func (*User) RevokeSigsProof

func (u *User) RevokeSigsProof(m MetaContext, key GenericKey, sigIDsToRevoke []keybase1.SigID, merkleRoot *MerkleRoot) (*ProofMetadataRes, error)

func (*User) ServiceProof

func (u *User) ServiceProof(m MetaContext, signingKey GenericKey, typ ServiceType, remotename string, sigVersion SigVersion) (*ProofMetadataRes, error)

func (*User) SigChainBump

func (u *User) SigChainBump(linkID LinkID, sigID keybase1.SigID, isHighDelegator bool)

SigChainBump is called during a multikey post to update the correct seqno, hash, and high skip. When a delegator posts a high link, they specify isHighDelegator=true in order to set the new high skip pointer to the delegator's link, so subsequent keys in the multikey will supply the correct high skip.

func (*User) SigChainBumpMT

func (u *User) SigChainBumpMT(mt MerkleTriple, isHighDelegator bool)

func (*User) SigChainDump

func (u *User) SigChainDump(w io.Writer)

func (*User) SigIDSearch

func (u *User) SigIDSearch(query string) (keybase1.SigID, error)

func (*User) SigningKeyPub

func (u *User) SigningKeyPub() (GenericKey, error)

func (*User) StellarAccountID

func (u *User) StellarAccountID() *stellar1.AccountID

Return the active stellar public address for a user. Returns nil if there is none or it has not been loaded.

func (*User) Store

func (u *User) Store(m MetaContext) error

func (*User) StoreSigChain

func (u *User) StoreSigChain(m MetaContext) error

func (*User) StoreTopLevel

func (u *User) StoreTopLevel(m MetaContext) error

func (*User) SyncSecrets

func (u *User) SyncSecrets(m MetaContext) error

func (*User) SyncedSecretKey

func (u *User) SyncedSecretKey(m MetaContext) (ret *SKB, err error)

func (*User) SyncedSecretKeyWithSka

func (u *User) SyncedSecretKeyWithSka(m MetaContext, ska SecretKeyArg) (ret *SKB, err error)

func (*User) TmpTrackChainLinkFor

func (u *User) TmpTrackChainLinkFor(m MetaContext, username string, uid keybase1.UID) (tcl *TrackChainLink, err error)

func (*User) ToTrackingStatement

func (u *User) ToTrackingStatement(w *jsonw.Wrapper, outcome *IdentifyOutcome) (err error)

func (*User) ToTrackingStatementBasics

func (u *User) ToTrackingStatementBasics(errp *error) *jsonw.Wrapper

func (*User) ToTrackingStatementKey

func (u *User) ToTrackingStatementKey(errp *error) *jsonw.Wrapper

func (*User) ToTrackingStatementPGPKeys

func (u *User) ToTrackingStatementPGPKeys(errp *error) *jsonw.Wrapper

func (*User) ToTrackingStatementSeqTail

func (u *User) ToTrackingStatementSeqTail() *jsonw.Wrapper

func (*User) ToUntrackingStatement

func (u *User) ToUntrackingStatement(w *jsonw.Wrapper) (err error)

func (*User) ToUntrackingStatementBasics

func (u *User) ToUntrackingStatementBasics() *jsonw.Wrapper

func (*User) ToUserForSignatures

func (u *User) ToUserForSignatures() (ret UserForSignatures, err error)

func (*User) ToUserVersion

func (u *User) ToUserVersion() keybase1.UserVersion

func (*User) ToWotStatement

func (u *User) ToWotStatement() *jsonw.Wrapper

func (*User) TrackChainLinkFor

func (u *User) TrackChainLinkFor(m MetaContext, username NormalizedUsername, uid keybase1.UID) (*TrackChainLink, error)

func (*User) TrackingProofFor

func (u *User) TrackingProofFor(m MetaContext, signingKey GenericKey, sigVersion SigVersion, u2 *User, outcome *IdentifyOutcome) (*ProofMetadataRes, error)

func (*User) UntrackingProofFor

func (u *User) UntrackingProofFor(m MetaContext, signingKey GenericKey, sigVersion SigVersion, u2 *User) (*ProofMetadataRes, error)

func (*User) UpdateEmailProof

func (u *User) UpdateEmailProof(m MetaContext, key GenericKey, newEmail string) (*jsonw.Wrapper, error)

func (*User) UpdatePassphraseProof

func (u *User) UpdatePassphraseProof(m MetaContext, key GenericKey, pwh string, ppGen PassphraseGeneration, pdpka5kid string) (*jsonw.Wrapper, error)

func (*User) VerifySelfSig

func (u *User) VerifySelfSig() error

func (*User) VerifySelfSigByKey

func (u *User) VerifySelfSigByKey() (ret bool)

func (*User) WotReactProof

func (u *User) WotReactProof(m MetaContext, signingKey GenericKey, sigVersion SigVersion, mac []byte) (*ProofMetadataRes, error)

func (*User) WotVouchProof

func (u *User) WotVouchProof(m MetaContext, signingKey GenericKey, sigVersion SigVersion, mac []byte, merkleRoot *MerkleRoot, sigIDToRevoke *keybase1.SigID) (*ProofMetadataRes, error)

type UserBasic

type UserBasic interface {
	GetUID() keybase1.UID
	GetName() string
}

type UserCardCache

type UserCardCache struct {
	// contains filtered or unexported fields
}

UserCardCache caches keybase1.UserCard objects in memory.

func NewUserCardCache

func NewUserCardCache(maxAge time.Duration) *UserCardCache

NewUserCardCache creates a UserCardCache. keybase1.UserCards will expire after maxAge.

func (*UserCardCache) Delete

func (c *UserCardCache) Delete(uid keybase1.UID) error

func (*UserCardCache) Get

func (c *UserCardCache) Get(uid keybase1.UID, useSession bool) (*keybase1.UserCard, error)

Get looks for a keybase1.UserCard for uid. It returns nil, nil if not found. useSession is set if the card is being looked up with a session.

func (*UserCardCache) Set

func (c *UserCardCache) Set(card *keybase1.UserCard, usedSession bool) error

Set stores card in the UserCardCache. usedSession is set based on whether user/card was looked up with a session or not.

func (*UserCardCache) Shutdown

func (c *UserCardCache) Shutdown()

Shutdown stops any goroutines in the cache.

type UserChangedHandler

type UserChangedHandler interface {
	// HandlerUserChanged is called when the with User with the given UID has
	// changed, either because of a sigchain change, or a profile change.
	HandleUserChanged(uid keybase1.UID) error
}

UserChangedHandler is a generic interface for handling user changed events. If the call returns an error, we'll remove this handler from the list, under the supposition that it's now dead.

type UserConfig

type UserConfig struct {
	ID              string                    `json:"id"`
	Name            NormalizedUsername        `json:"name"`
	Salt            string                    `json:"salt"`
	Device          *string                   `json:"device"`
	PassphraseState *keybase1.PassphraseState `json:"passphrase_state,omitempty"`
	// contains filtered or unexported fields
}

func ImportUserConfigFromJSONWrapper

func ImportUserConfigFromJSONWrapper(jw *jsonw.Wrapper) (ret *UserConfig, err error)

func NewOneshotUserConfig

func NewOneshotUserConfig(id keybase1.UID, name NormalizedUsername, salt []byte, dev keybase1.DeviceID) *UserConfig

func NewUserConfig

func NewUserConfig(id keybase1.UID, name NormalizedUsername, salt []byte, dev keybase1.DeviceID) *UserConfig

func (UserConfig) GetDeviceID

func (u UserConfig) GetDeviceID() keybase1.DeviceID

func (UserConfig) GetPassphraseState

func (u UserConfig) GetPassphraseState() *keybase1.PassphraseState

func (UserConfig) GetUID

func (u UserConfig) GetUID() keybase1.UID

func (UserConfig) GetUsername

func (u UserConfig) GetUsername() NormalizedUsername

func (*UserConfig) Import

func (u *UserConfig) Import() (err error)

func (UserConfig) IsOneshot

func (u UserConfig) IsOneshot() bool

func (*UserConfig) SetDevice

func (u *UserConfig) SetDevice(d keybase1.DeviceID)

func (*UserConfig) SetPassphraseState

func (u *UserConfig) SetPassphraseState(passphraseState keybase1.PassphraseState)

type UserConfigWrapper

type UserConfigWrapper struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type UserDeletedError

type UserDeletedError struct {
	Msg string
}

func (UserDeletedError) Error

func (e UserDeletedError) Error() string

func (UserDeletedError) ToStatus

func (e UserDeletedError) ToStatus() keybase1.Status

type UserEKBoxStorage

type UserEKBoxStorage interface {
	Put(mctx MetaContext, generation keybase1.EkGeneration, userEKBoxed keybase1.UserEkBoxed) error
	Get(mctx MetaContext, generation keybase1.EkGeneration, contentCtime *gregor1.Time) (keybase1.UserEk, error)
	MaxGeneration(mctx MetaContext, includeErrs bool) (keybase1.EkGeneration, error)
	DeleteExpired(mctx MetaContext, merkleRoot MerkleRoot) ([]keybase1.EkGeneration, error)
	ClearCache()
}

type UserForSignatures

type UserForSignatures struct {
	// contains filtered or unexported fields
}

func LoadSelfForTeamSignatures

func LoadSelfForTeamSignatures(ctx context.Context, g *GlobalContext) (ret UserForSignatures, err error)

func (UserForSignatures) GetEldestKID

func (u UserForSignatures) GetEldestKID() keybase1.KID

func (UserForSignatures) GetEldestSeqno

func (u UserForSignatures) GetEldestSeqno() keybase1.Seqno

func (UserForSignatures) GetLatestPerUserKey

func (u UserForSignatures) GetLatestPerUserKey() *keybase1.PerUserKey

func (UserForSignatures) GetName

func (u UserForSignatures) GetName() string

func (UserForSignatures) GetNormalizedName

func (u UserForSignatures) GetNormalizedName() NormalizedUsername

func (UserForSignatures) GetUID

func (u UserForSignatures) GetUID() keybase1.UID

func (UserForSignatures) ToUserVersion

func (u UserForSignatures) ToUserVersion() keybase1.UserVersion

type UserLinkSignature

type UserLinkSignature struct {
	Payload JSONPayload
	Seqno   keybase1.Seqno
	LinkID  LinkID
}

func PerUserKeyProofReverseSigned

func PerUserKeyProofReverseSigned(m MetaContext, me *User, perUserKeySeed PerUserKeySeed, generation keybase1.PerUserKeyGeneration,
	signer GenericKey) (*UserLinkSignature, error)

Make a per-user key proof with a reverse sig. Modifies the User `me` with a sigchain bump and key delegation. Returns a JSONPayload ready for use in "sigs" in sig/multi.

func StellarProofReverseSigned

func StellarProofReverseSigned(m MetaContext, me *User, walletAddress stellar1.AccountID,
	stellarSigner stellar1.SecretKey, deviceSigner GenericKey) (*UserLinkSignature, error)

Make a stellar proof with a reverse sig. Modifies the User `me` with a sigchain bump and key delegation. Returns a JSONPayload ready for use in "sigs" in sig/multi.

type UserNotFoundError

type UserNotFoundError struct {
	UID keybase1.UID
	Msg string
}

func (UserNotFoundError) Error

func (u UserNotFoundError) Error() string

type UserPlusKeysMemo

type UserPlusKeysMemo struct {
	sync.RWMutex
	Contextified
	// contains filtered or unexported fields
}

func NewUserPlusKeysMemo

func NewUserPlusKeysMemo(g *GlobalContext) *UserPlusKeysMemo

func (*UserPlusKeysMemo) Clear

func (u *UserPlusKeysMemo) Clear()

func (*UserPlusKeysMemo) Get

func (*UserPlusKeysMemo) Set

type UserReverifyNeededError

type UserReverifyNeededError struct {
	// contains filtered or unexported fields
}

func (UserReverifyNeededError) Error

func (e UserReverifyNeededError) Error() string

type UserServiceSummary

type UserServiceSummary map[string]string // service -> username

type UserServiceSummaryPackage

type UserServiceSummaryPackage struct {
	CachedAt   keybase1.Time
	ServiceMap UserServiceSummary
}

type UsernamePackage

type UsernamePackage struct {
	NormalizedUsername NormalizedUsername
	FullName           *keybase1.FullNamePackage
}

type VDebugLevel

type VDebugLevel int

func (VDebugLevel) String

func (v VDebugLevel) String() string

type VDebugLog

type VDebugLog struct {
	// contains filtered or unexported fields
}

VDebugLog is a "Verbose" debug logger; enable it if you really want spam and/or minutiae

func NewVDebugLog

func NewVDebugLog(l logger.Logger) *VDebugLog

func (*VDebugLog) CLogf

func (v *VDebugLog) CLogf(ctx context.Context, lev VDebugLevel, fs string, args ...interface{})

func (*VDebugLog) CLogfWithAddedDepth

func (v *VDebugLog) CLogfWithAddedDepth(ctx context.Context, lev VDebugLevel, d int, fs string, args ...interface{})

func (*VDebugLog) Configure

func (v *VDebugLog) Configure(s string)

func (*VDebugLog) DumpPayload

func (v *VDebugLog) DumpPayload() bool

func (*VDebugLog) DumpSiteLoadUser

func (v *VDebugLog) DumpSiteLoadUser() bool

func (*VDebugLog) Log

func (v *VDebugLog) Log(lev VDebugLevel, fs string, args ...interface{})

type VLogContext

type VLogContext interface {
	LogContext
	GetVDebugLog() *VDebugLog
}

type VerboseError

type VerboseError interface {
	Error() string
	Verbose() string
}

type VerboseLock

type VerboseLock struct {
	// contains filtered or unexported fields
}

func NewVerboseLock

func NewVerboseLock(level VDebugLevel, name string) *VerboseLock

func (*VerboseLock) Acquire

func (l *VerboseLock) Acquire(mctx MetaContext, reasonFormat string, args ...interface{}) (release VerboseLockRelease)

type VerboseLockRelease

type VerboseLockRelease = func()

type VerificationError

type VerificationError struct {
	Cause ErrorCause
}

VerificationError is the default verification error

func (VerificationError) Error

func (e VerificationError) Error() string

func (VerificationError) ToStatus

func (e VerificationError) ToStatus() keybase1.Status

type VerificationPath

type VerificationPath struct {
	Contextified
	// contains filtered or unexported fields
}

type VerifyContext

type VerifyContext interface {
	Debug(format string, args ...interface{})
}

type WaitForItError

type WaitForItError struct{}

func (WaitForItError) Error

func (e WaitForItError) Error() string

type WalletNetwork

type WalletNetwork string

Wallet and cryptocurrency are separate systems. Wallet links have reverse signatures, and the control secrets are in keybase. Whereas Cryptocurrency links are generally public only and have no reverse sigs. CryptocurrencyFamily and WalletNetwork are defined next to each other so that someone will notice if they start to overlap.

const (
	WalletNetworkStellar WalletNetwork = "stellar"
)
type WalletStellarChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func ParseWalletStellarChainLink(b GenericChainLink) (ret *WalletStellarChainLink, err error)

func (*WalletStellarChainLink) Display

func (*WalletStellarChainLink) ToDisplayString

func (s *WalletStellarChainLink) ToDisplayString() string

func (*WalletStellarChainLink) Type

func (s *WalletStellarChainLink) Type() string

func (*WalletStellarChainLink) VerifyReverseSig

func (s *WalletStellarChainLink) VerifyReverseSig(_ ComputedKeyFamily) (err error)

VerifyReverseSig checks a SibkeyChainLink's reverse signature using the ComputedKeyFamily provided.

type Warning

type Warning interface {
	Warning() string
	Warn(g *GlobalContext)
}

func ErrorToWarning

func ErrorToWarning(e error) Warning

func Warningf

func Warningf(format string, a ...interface{}) Warning

type Warnings

type Warnings struct {
	// contains filtered or unexported fields
}

func ImportWarnings

func ImportWarnings(v []string) Warnings

func (Warnings) IsEmpty

func (w Warnings) IsEmpty() bool

func (*Warnings) Push

func (w *Warnings) Push(e Warning)

func (Warnings) Warn

func (w Warnings) Warn(g *GlobalContext)

func (Warnings) Warnings

func (w Warnings) Warnings() []Warning
type WebProofChainLink struct {
	GenericChainLink
	// contains filtered or unexported fields
}
func NewWebProofChainLink(b GenericChainLink, p, h, proofText string) *WebProofChainLink

func (*WebProofChainLink) CheckDataJSON

func (w *WebProofChainLink) CheckDataJSON() *jsonw.Wrapper

func (*WebProofChainLink) ComputeTrackDiff

func (w *WebProofChainLink) ComputeTrackDiff(tl *TrackLookup) (res TrackDiff)

func (*WebProofChainLink) DisplayCheck

func (w *WebProofChainLink) DisplayCheck(m MetaContext, ui IdentifyUI, lcr LinkCheckResult) error

func (*WebProofChainLink) DisplayPriorityKey

func (w *WebProofChainLink) DisplayPriorityKey() string

func (*WebProofChainLink) GetHostname

func (w *WebProofChainLink) GetHostname() string

func (*WebProofChainLink) GetProofType

func (w *WebProofChainLink) GetProofType() keybase1.ProofType

func (*WebProofChainLink) GetProtocol

func (w *WebProofChainLink) GetProtocol() string

func (*WebProofChainLink) GetRemoteUsername

func (w *WebProofChainLink) GetRemoteUsername() string

func (*WebProofChainLink) LastWriterWins

func (w *WebProofChainLink) LastWriterWins() bool

func (*WebProofChainLink) ProofText

func (w *WebProofChainLink) ProofText() string

func (*WebProofChainLink) TableKey

func (w *WebProofChainLink) TableKey() string

func (*WebProofChainLink) ToDisplayString

func (w *WebProofChainLink) ToDisplayString() string

func (*WebProofChainLink) ToIDString

func (w *WebProofChainLink) ToIDString() string

func (*WebProofChainLink) ToKeyValuePair

func (w *WebProofChainLink) ToKeyValuePair() (string, string)

func (*WebProofChainLink) ToTrackingStatement

func (w *WebProofChainLink) ToTrackingStatement(state keybase1.ProofState) (*jsonw.Wrapper, error)

func (*WebProofChainLink) Type

func (w *WebProofChainLink) Type() string

type WebUnreachableError

type WebUnreachableError struct {
	// contains filtered or unexported fields
}

func NewWebUnreachableError

func NewWebUnreachableError(h string) WebUnreachableError

func (WebUnreachableError) Error

func (h WebUnreachableError) Error() string

type Win32

type Win32 struct {
	Base
}

func (Win32) CacheDir

func (w Win32) CacheDir() string

func (Win32) ConfigDir

func (w Win32) ConfigDir() string

func (Win32) DataDir

func (w Win32) DataDir() string

func (Win32) DownloadsDir

func (w Win32) DownloadsDir() string

func (Win32) Home

func (w Win32) Home(emptyOk bool) string

func (Win32) InfoDir

func (w Win32) InfoDir() string

func (Win32) LogDir

func (w Win32) LogDir() string

func (Win32) MobileSharedHome

func (w Win32) MobileSharedHome(emptyOk bool) string

func (Win32) Normalize

func (w Win32) Normalize(s string) string

func (Win32) RuntimeDir

func (w Win32) RuntimeDir() string

func (Win32) SandboxCacheDir

func (w Win32) SandboxCacheDir() string

func (Win32) ServiceSpawnDir

func (w Win32) ServiceSpawnDir() (string, error)

func (Win32) SharedCacheDir

func (w Win32) SharedCacheDir() string

func (Win32) SharedDataDir

func (w Win32) SharedDataDir() string

func (Win32) Split

func (w Win32) Split(s string) []string

func (Win32) Unsplit

func (w Win32) Unsplit(v []string) string
type WotReactChainLink struct {
	GenericChainLink
	ExpansionID string
}

func ParseWotReact

func ParseWotReact(base GenericChainLink) (ret *WotReactChainLink, err error)

func (*WotReactChainLink) DoOwnNewLinkFromServerNotifications

func (cl *WotReactChainLink) DoOwnNewLinkFromServerNotifications(g *GlobalContext)

func (*WotReactChainLink) Type

func (cl *WotReactChainLink) Type() string
type WotVouchChainLink struct {
	GenericChainLink
	ExpansionID string
	Revocations []keybase1.SigID
}

func ParseWotVouch

func ParseWotVouch(base GenericChainLink) (ret *WotVouchChainLink, err error)

func (*WotVouchChainLink) DoOwnNewLinkFromServerNotifications

func (cl *WotVouchChainLink) DoOwnNewLinkFromServerNotifications(g *GlobalContext)

func (*WotVouchChainLink) Type

func (cl *WotVouchChainLink) Type() string

type WrongCryptoFormatError

type WrongCryptoFormatError struct {
	Wanted, Received CryptoMessageFormat
	Operation        string
}

func (WrongCryptoFormatError) Error

func (e WrongCryptoFormatError) Error() string

func (WrongCryptoFormatError) ToStatus

func (e WrongCryptoFormatError) ToStatus() keybase1.Status

type WrongKeyError

type WrongKeyError struct {
	// contains filtered or unexported fields
}

func (WrongKeyError) Error

func (e WrongKeyError) Error() string

type WrongKidError

type WrongKidError struct {
	// contains filtered or unexported fields
}

func NewWrongKidError

func NewWrongKidError(w keybase1.KID, g keybase1.KID) WrongKidError

func (WrongKidError) Error

func (w WrongKidError) Error() string

type WrongSigError

type WrongSigError struct {
	// contains filtered or unexported fields
}

func (WrongSigError) Error

func (e WrongSigError) Error() string

type XAPIResType

type XAPIResType int
const (
	XAPIResJSON XAPIResType = iota
	XAPIResHTML
	XAPIResText
)

type XdgPosix

type XdgPosix struct {
	Base
}

func (XdgPosix) CacheDir

func (x XdgPosix) CacheDir() string

func (XdgPosix) ConfigDir

func (x XdgPosix) ConfigDir() string

func (XdgPosix) DataDir

func (x XdgPosix) DataDir() string

func (XdgPosix) DownloadsDir

func (x XdgPosix) DownloadsDir() string

func (XdgPosix) Home

func (x XdgPosix) Home(emptyOk bool) string

func (XdgPosix) InfoDir

func (x XdgPosix) InfoDir() string

func (XdgPosix) IsNonstandardHome

func (x XdgPosix) IsNonstandardHome() (bool, error)

IsNonstandardHome is true if the home directory gleaned via cmdline, env, or config is different from that in /etc/passwd.

func (XdgPosix) LogDir

func (x XdgPosix) LogDir() string

func (XdgPosix) MobileSharedHome

func (x XdgPosix) MobileSharedHome(emptyOk bool) string

func (XdgPosix) Normalize

func (x XdgPosix) Normalize(s string) string

func (XdgPosix) RuntimeDir

func (x XdgPosix) RuntimeDir() string

func (XdgPosix) SandboxCacheDir

func (x XdgPosix) SandboxCacheDir() string

func (XdgPosix) ServiceSpawnDir

func (x XdgPosix) ServiceSpawnDir() (ret string, err error)

func (XdgPosix) SharedCacheDir

func (x XdgPosix) SharedCacheDir() string

func (XdgPosix) SharedDataDir

func (x XdgPosix) SharedDataDir() string

Source Files

Directories

Path Synopsis
testfixtures

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL