Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.6k

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "CreateTeamTLF", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ",", "tlfID", "tlf", ".", "ID", ")", "(", "err", "error", ")", "{", "k", ".", "createTeamTLFTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "k", ".", "delegate", ".", "CreateTeamTLF", "(", "ctx", ",", "teamID", ",", "tlfID", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "CreateTeamTLF", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "GetTeamSettings", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "(", "settings", "keybase1", ".", "KBFSTeamSettings", ",", "err", "error", ")", "{", "k", ".", "getTeamSettingsTimer", ".", "Time", "(", "func", "(", ")", "{", "settings", ",", "err", "=", "k", ".", "delegate", ".", "GetTeamSettings", "(", "ctx", ",", "teamID", ",", "offline", ")", "\n", "}", ")", "\n", "return", "settings", ",", "err", "\n", "}" ]

[ "GetTeamSettings", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "GetCurrentMerkleRoot", "(", "ctx", "context", ".", "Context", ")", "(", "root", "keybase1", ".", "MerkleRootV2", ",", "updateTime", "time", ".", "Time", ",", "err", "error", ")", "{", "k", ".", "getCurrentMerkleRootTimer", ".", "Time", "(", "func", "(", ")", "{", "root", ",", "updateTime", ",", "err", "=", "k", ".", "delegate", ".", "GetCurrentMerkleRoot", "(", "ctx", ")", "\n", "}", ")", "\n", "return", "root", ",", "updateTime", ",", "err", "\n", "}" ]

[ "GetCurrentMerkleRoot", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "VerifyMerkleRoot", "(", "ctx", "context", ".", "Context", ",", "root", "keybase1", ".", "MerkleRootV2", ",", "kbfsRoot", "keybase1", ".", "KBFSRoot", ")", "(", "err", "error", ")", "{", "k", ".", "verifyMerkleRootTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "k", ".", "delegate", ".", "VerifyMerkleRoot", "(", "ctx", ",", "root", ",", "kbfsRoot", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "VerifyMerkleRoot", "implements", "the", "KBPKI", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "CurrentSession", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "sessionInfo", "idutil", ".", "SessionInfo", ",", "err", "error", ")", "{", "k", ".", "currentSessionTimer", ".", "Time", "(", "func", "(", ")", "{", "sessionInfo", ",", "err", "=", "k", ".", "delegate", ".", "CurrentSession", "(", "ctx", ",", "sessionID", ")", "\n", "}", ")", "\n", "return", "sessionInfo", ",", "err", "\n", "}" ]

[ "CurrentSession", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "FavoriteAdd", "(", "ctx", "context", ".", "Context", ",", "folder", "keybase1", ".", "Folder", ")", "(", "err", "error", ")", "{", "k", ".", "favoriteAddTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "k", ".", "delegate", ".", "FavoriteAdd", "(", "ctx", ",", "folder", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "FavoriteAdd", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "FavoriteDelete", "(", "ctx", "context", ".", "Context", ",", "folder", "keybase1", ".", "Folder", ")", "(", "err", "error", ")", "{", "k", ".", "favoriteDeleteTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "k", ".", "delegate", ".", "FavoriteDelete", "(", "ctx", ",", "folder", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "FavoriteDelete", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "FavoriteList", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "favorites", "keybase1", ".", "FavoritesResult", ",", "err", "error", ")", "{", "k", ".", "favoriteListTimer", ".", "Time", "(", "func", "(", ")", "{", "favorites", ",", "err", "=", "k", ".", "delegate", ".", "FavoriteList", "(", "ctx", ",", "sessionID", ")", "\n", "}", ")", "\n", "return", "favorites", ",", "err", "\n", "}" ]

[ "FavoriteList", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "EncryptFavorites", "(", "ctx", "context", ".", "Context", ",", "dataIn", "[", "]", "byte", ")", "(", "dataOut", "[", "]", "byte", ",", "err", "error", ")", "{", "k", ".", "favoriteListTimer", ".", "Time", "(", "func", "(", ")", "{", "dataOut", ",", "err", "=", "k", ".", "delegate", ".", "EncryptFavorites", "(", "ctx", ",", "dataIn", ")", "\n", "}", ")", "\n", "return", "dataOut", ",", "err", "\n", "}" ]

[ "EncryptFavorites", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "NotifyOnlineStatusChanged", "(", "ctx", "context", ".", "Context", ",", "online", "bool", ")", "(", "err", "error", ")", "{", "k", ".", "notifyTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "k", ".", "delegate", ".", "NotifyOnlineStatusChanged", "(", "ctx", ",", "online", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "NotifyOnlineStatusChanged", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "Notify", "(", "ctx", "context", ".", "Context", ",", "notification", "*", "keybase1", ".", "FSNotification", ")", "(", "err", "error", ")", "{", "k", ".", "notifyTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "k", ".", "delegate", ".", "Notify", "(", "ctx", ",", "notification", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "Notify", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "NotifyPathUpdated", "(", "ctx", "context", ".", "Context", ",", "path", "string", ")", "(", "err", "error", ")", "{", "k", ".", "notifyPathUpdatedTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "k", ".", "delegate", ".", "NotifyPathUpdated", "(", "ctx", ",", "path", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "NotifyPathUpdated", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "NotifySyncStatus", "(", "ctx", "context", ".", "Context", ",", "status", "*", "keybase1", ".", "FSPathSyncStatus", ")", "(", "err", "error", ")", "{", "k", ".", "notifyTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "k", ".", "delegate", ".", "NotifySyncStatus", "(", "ctx", ",", "status", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "NotifySyncStatus", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "NotifyOverallSyncStatus", "(", "ctx", "context", ".", "Context", ",", "status", "keybase1", ".", "FolderSyncStatus", ")", "(", "err", "error", ")", "{", "k", ".", "notifyTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "k", ".", "delegate", ".", "NotifyOverallSyncStatus", "(", "ctx", ",", "status", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "NotifyOverallSyncStatus", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "FlushUserFromLocalCache", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ")", "{", "k", ".", "delegate", ".", "FlushUserFromLocalCache", "(", "ctx", ",", "uid", ")", "\n", "}" ]

[ "FlushUserFromLocalCache", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "ClearCaches", "(", "ctx", "context", ".", "Context", ")", "{", "k", ".", "delegate", ".", "ClearCaches", "(", "ctx", ")", "\n", "}" ]

[ "ClearCaches", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "EstablishMountDir", "(", "ctx", "context", ".", "Context", ")", "(", "string", ",", "error", ")", "{", "return", "k", ".", "delegate", ".", "EstablishMountDir", "(", "ctx", ")", "\n", "}" ]

[ "EstablishMountDir", "implements", "the", "KeybaseDaemon", "interface", "for", "KeybaseDaemonLocal", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "PutGitMetadata", "(", "ctx", "context", ".", "Context", ",", "folder", "keybase1", ".", "Folder", ",", "repoID", "keybase1", ".", "RepoID", ",", "metadata", "keybase1", ".", "GitLocalMetadata", ")", "(", "err", "error", ")", "{", "k", ".", "putGitMetadataTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "k", ".", "delegate", ".", "PutGitMetadata", "(", "ctx", ",", "folder", ",", "repoID", ",", "metadata", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "PutGitMetadata", "implements", "the", "KeybaseDaemon", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "NewRPCHandlerWithCtx", "(", "kbCtx", "libkbfs", ".", "Context", ",", "config", "libkbfs", ".", "Config", ",", "kbfsInitParams", "*", "libkbfs", ".", "InitParams", ")", "(", "*", "RPCHandler", ",", "func", "(", ")", ")", "{", "shutdown", ":=", "StartAutogit", "(", "config", ",", "100", ")", "\n", "return", "&", "RPCHandler", "{", "kbCtx", ":", "kbCtx", ",", "config", ":", "config", ",", "kbfsInitParams", ":", "kbfsInitParams", ",", "log", ":", "config", ".", "MakeLogger", "(", "\"", "\"", ")", ",", "}", ",", "shutdown", "\n", "}" ]

[ "NewRPCHandlerWithCtx", "returns", "a", "new", "instance", "of", "a", "Git", "RPC", "handler", "." ]

[ "func", "(", "rh", "*", "RPCHandler", ")", "CreateRepo", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "CreateRepoArg", ")", "(", "id", "keybase1", ".", "RepoID", ",", "err", "error", ")", "{", "rh", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "arg", ".", "Name", ",", "arg", ".", "Folder", ".", "FolderType", ",", "arg", ".", "Folder", ".", "Name", ")", "\n", "defer", "func", "(", ")", "{", "rh", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "defer", "cancel", "(", ")", "\n", "ctx", ",", "gitConfig", ",", "tlfHandle", ",", "tempDir", ",", "err", ":=", "rh", ".", "getHandleAndConfig", "(", "ctx", ",", "arg", ".", "Folder", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "defer", "func", "(", ")", "{", "rmErr", ":=", "os", ".", "RemoveAll", "(", "tempDir", ")", "\n", "if", "rmErr", "!=", "nil", "{", "rh", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\\n", "\"", ",", "tempDir", ",", "rmErr", ")", "\n", "}", "\n", "}", "(", ")", "\n", "defer", "gitConfig", ".", "Shutdown", "(", "ctx", ")", "\n\n", "ctx", "=", "context", ".", "WithValue", "(", "ctx", ",", "libkbfs", ".", "CtxAllowNameKey", ",", "kbfsRepoDir", ")", "\n", "gitID", ",", "err", ":=", "CreateRepoAndID", "(", "ctx", ",", "gitConfig", ",", "tlfHandle", ",", "string", "(", "arg", ".", "Name", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "err", "=", "rh", ".", "waitForJournal", "(", "ctx", ",", "gitConfig", ",", "tlfHandle", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "keybase1", ".", "RepoID", "(", "gitID", ".", "String", "(", ")", ")", ",", "nil", "\n", "}" ]

[ "CreateRepo", "implements", "keybase1", ".", "KBFSGitInterface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "rh", "*", "RPCHandler", ")", "DeleteRepo", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "DeleteRepoArg", ")", "(", "err", "error", ")", "{", "rh", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "arg", ".", "Name", ",", "arg", ".", "Folder", ".", "FolderType", ",", "arg", ".", "Folder", ".", "Name", ")", "\n", "defer", "func", "(", ")", "{", "rh", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "defer", "cancel", "(", ")", "\n", "ctx", ",", "gitConfig", ",", "tlfHandle", ",", "tempDir", ",", "err", ":=", "rh", ".", "getHandleAndConfig", "(", "ctx", ",", "arg", ".", "Folder", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "func", "(", ")", "{", "rmErr", ":=", "os", ".", "RemoveAll", "(", "tempDir", ")", "\n", "if", "rmErr", "!=", "nil", "{", "rh", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\\n", "\"", ",", "tempDir", ",", "rmErr", ")", "\n", "}", "\n", "}", "(", ")", "\n", "defer", "gitConfig", ".", "Shutdown", "(", "ctx", ")", "\n\n", "err", "=", "DeleteRepo", "(", "ctx", ",", "gitConfig", ",", "tlfHandle", ",", "string", "(", "arg", ".", "Name", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "err", "=", "rh", ".", "waitForJournal", "(", "ctx", ",", "gitConfig", ",", "tlfHandle", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "rh", ".", "scheduleCleaning", "(", "arg", ".", "Folder", ")", "\n", "return", "nil", "\n", "}" ]

[ "DeleteRepo", "implements", "keybase1", ".", "KBFSGitInterface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "rh", "*", "RPCHandler", ")", "Gc", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "GcArg", ")", "(", "err", "error", ")", "{", "rh", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "arg", ".", "Name", ",", "arg", ".", "Folder", ".", "FolderType", ",", "arg", ".", "Folder", ".", "Name", ")", "\n", "defer", "func", "(", ")", "{", "rh", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "defer", "cancel", "(", ")", "\n", "ctx", ",", "gitConfig", ",", "tlfHandle", ",", "tempDir", ",", "err", ":=", "rh", ".", "getHandleAndConfig", "(", "ctx", ",", "arg", ".", "Folder", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "func", "(", ")", "{", "rmErr", ":=", "os", ".", "RemoveAll", "(", "tempDir", ")", "\n", "if", "rmErr", "!=", "nil", "{", "rh", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\\n", "\"", ",", "tempDir", ",", "rmErr", ")", "\n", "}", "\n", "}", "(", ")", "\n", "defer", "gitConfig", ".", "Shutdown", "(", "ctx", ")", "\n\n", "gco", ":=", "GCOptions", "{", "MaxLooseRefs", ":", "arg", ".", "Options", ".", "MaxLooseRefs", ",", "PruneMinLooseObjects", ":", "arg", ".", "Options", ".", "PruneMinLooseObjects", ",", "PruneExpireTime", ":", "keybase1", ".", "FromTime", "(", "arg", ".", "Options", ".", "PruneExpireTime", ")", ",", "MaxObjectPacks", ":", "arg", ".", "Options", ".", "MaxObjectPacks", ",", "}", "\n", "err", "=", "GCRepo", "(", "ctx", ",", "gitConfig", ",", "tlfHandle", ",", "string", "(", "arg", ".", "Name", ")", ",", "gco", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "rh", ".", "waitForJournal", "(", "ctx", ",", "gitConfig", ",", "tlfHandle", ")", "\n", "}" ]

[ "Gc", "implements", "keybase1", ".", "KBFSGitInterface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "s", "*", "PassphraseStreamCache", ")", "PassphraseStream", "(", ")", "*", "PassphraseStream", "{", "if", "s", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n", "return", "s", ".", "passphraseStream", ".", "Clone", "(", ")", "\n", "}" ]

[ "PassphraseStream", "returns", "a", "copy", "of", "the", "currently", "cached", "passphrase", "stream", "or", "nil", "if", "none", "exists", "." ]

[ "func", "(", "e", "*", "SaltpackUserKeyfinder", ")", "AddPUK", "(", "m", "libkb", ".", "MetaContext", ",", "upk", "*", "keybase1", ".", "UserPlusKeysV2", ")", "error", "{", "if", "!", "e", ".", "Arg", ".", "UseEntityKeys", "{", "// No need to add anything", "return", "nil", "\n", "}", "\n\n", "if", "e", ".", "hasRecipientEntityKeys", "(", "upk", ".", "Uid", ".", "AsUserOrTeam", "(", ")", ")", "{", "// This user's keys were already added", "return", "nil", "\n", "}", "\n\n", "hasPUK", ":=", "len", "(", "upk", ".", "PerUserKeys", ")", ">", "0", "\n\n", "if", "!", "hasPUK", "{", "hasPaperKey", ":=", "false", "\n", "hasDeviceKey", ":=", "false", "\n", "for", "KID", ",", "key", ":=", "range", "upk", ".", "DeviceKeys", "{", "if", "e", ".", "isPaperEncryptionKey", "(", "&", "key", ",", "&", "upk", ".", "DeviceKeys", ")", "{", "hasPaperKey", "=", "true", "\n", "}", "\n", "if", "libkb", ".", "KIDIsDeviceEncrypt", "(", "KID", ")", "&&", "!", "e", ".", "isPaperEncryptionKey", "(", "&", "key", ",", "&", "upk", ".", "DeviceKeys", ")", "{", "hasDeviceKey", "=", "true", "\n", "}", "\n", "}", "\n\n", "m", ".", "Debug", "(", "\"", "\"", ",", "upk", ".", "Username", ")", "\n", "return", "libkb", ".", "NoNaClEncryptionKeyError", "{", "Username", ":", "upk", ".", "Username", ",", "HasPGPKey", ":", "len", "(", "upk", ".", "PGPKeys", ")", ">", "0", ",", "HasPUK", ":", "hasPUK", ",", "HasDeviceKey", ":", "hasDeviceKey", ",", "HasPaperKey", ":", "hasPaperKey", ",", "}", "\n", "}", "\n\n", "// We ensured above that the user has a PUK, so the loop below will be executed at least once", "maxGen", ":=", "-", "1", "\n", "var", "lk", "keybase1", ".", "KID", "\n", "for", "_", ",", "k", ":=", "range", "upk", ".", "PerUserKeys", "{", "if", "k", ".", "Gen", ">", "maxGen", "{", "maxGen", "=", "k", ".", "Gen", "\n", "lk", "=", "k", ".", "EncKID", "\n", "}", "\n", "}", "\n", "if", "lk", "==", "\"", "\"", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "m", ".", "Debug", "(", "\"", "\"", ",", "upk", ".", "Username", ")", "\n", "e", ".", "RecipientEntityKeyMap", "[", "upk", ".", "Uid", ".", "AsUserOrTeam", "(", ")", "]", "=", "[", "]", "keybase1", ".", "KID", "{", "lk", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "AddPUK", "returns", "no", "error", "unless", "the", "user", "has", "no", "PUK", "in", "which", "case", "it", "returns", "a", "libkb", ".", "NoNaClEncryptionKeyError" ]

[ "func", "(", "sf", "SizeFlag", ")", "String", "(", ")", "string", "{", "// This happens when izZeroValue() from flag.go makes a zero", "// value from the type of a flag.", "if", "sf", ".", "v", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "v", ":=", "*", "sf", ".", "v", "\n", "var", "suffix", "string", "\n", "const", "units", "=", "\"", "\"", "\n", "var", "c", "byte", "\n", "if", "v", "%", "1000", "==", "0", "{", "for", "i", ":=", "0", ";", "v", "%", "1000", "==", "0", "&&", "i", "<", "len", "(", "units", ")", ";", "i", "++", "{", "c", "=", "units", "[", "i", "]", "\n", "v", "/=", "1000", "\n", "}", "\n", "suffix", "=", "string", "(", "c", ")", "\n", "}", "else", "if", "v", "%", "1024", "==", "0", "{", "for", "i", ":=", "0", ";", "v", "%", "1024", "==", "0", "&&", "i", "<", "len", "(", "units", ")", ";", "i", "++", "{", "c", "=", "units", "[", "i", "]", "\n", "v", "/=", "1024", "\n", "}", "\n", "suffix", "=", "string", "(", "c", ")", "+", "\"", "\"", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "v", ",", "suffix", ")", "\n", "}" ]

[ "String", "for", "flag", "interface", "." ]

[ "func", "(", "sf", "SizeFlag", ")", "Set", "(", "raw", "string", ")", "error", "{", "i", ":=", "0", "\n", "for", ";", "i", "<", "len", "(", "raw", ")", "&&", "raw", "[", "i", "]", ">=", "'0'", "&&", "raw", "[", "i", "]", "<=", "'9'", ";", "i", "++", "{", "}", "\n", "val", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "raw", "[", ":", "i", "]", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// constant map so concurrent access is ok.", "mult", ",", "found", ":=", "sizeFlagMap", "[", "strings", ".", "ToLower", "(", "raw", "[", "i", ":", "]", ")", "]", "\n", "if", "!", "found", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "raw", ")", "\n", "}", "\n", "*", "sf", ".", "v", "=", "val", "*", "mult", "\n", "return", "nil", "\n", "}" ]

[ "Set", "for", "flag", "interface", "." ]

[ "func", "NewPGPKeyfinder", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "arg", "*", "PGPKeyfinderArg", ")", "*", "PGPKeyfinder", "{", "return", "&", "PGPKeyfinder", "{", "arg", ":", "arg", ",", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewPGPKeyfinder", "creates", "a", "PGPKeyfinder", "engine", "." ]

[ "func", "(", "e", "*", "PGPKeyfinder", ")", "loadUsers", "(", "m", "libkb", ".", "MetaContext", ")", "{", "if", "e", ".", "runerr", "!=", "nil", "{", "return", "\n", "}", "\n\n", "for", "_", ",", "u", ":=", "range", "e", ".", "arg", ".", "Usernames", "{", "arg", ":=", "libkb", ".", "NewLoadUserByNameArg", "(", "e", ".", "G", "(", ")", ",", "u", ")", "\n", "user", ",", "err", ":=", "libkb", ".", "LoadUser", "(", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "e", ".", "runerr", "=", "err", "\n", "return", "\n", "}", "\n", "e", ".", "addUser", "(", "user", ",", "false", ")", "\n", "}", "\n\n", "}" ]

[ "don", "t", "identify", "or", "track", "just", "load", "the", "users" ]

[ "func", "NewUntrackEngine", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "arg", "*", "UntrackEngineArg", ")", "*", "UntrackEngine", "{", "if", "libkb", ".", "SigVersion", "(", "arg", ".", "SigVersion", ")", "==", "libkb", ".", "KeybaseNullSigVersion", "{", "arg", ".", "SigVersion", "=", "libkb", ".", "GetDefaultSigVersion", "(", "g", ")", "\n", "}", "\n\n", "return", "&", "UntrackEngine", "{", "arg", ":", "arg", ",", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewUntrackEngine", "creates", "a", "default", "UntrackEngine", "for", "tracking", "theirName", "." ]

[ "func", "NewAuditor", "(", "g", "*", "libkb", ".", "GlobalContext", ")", "*", "Auditor", "{", "ret", ":=", "&", "Auditor", "{", "}", "\n", "ret", ".", "newLRU", "(", "libkb", ".", "NewMetaContextBackground", "(", "g", ")", ")", "\n", "return", "ret", "\n", "}" ]

[ "NewAuditor", "makes", "a", "new", "auditor" ]

[ "func", "NewAuditorAndInstall", "(", "g", "*", "libkb", ".", "GlobalContext", ")", "{", "if", "g", ".", "GetEnv", "(", ")", ".", "GetDisableTeamAuditor", "(", ")", "{", "g", ".", "Log", ".", "CDebugf", "(", "context", ".", "TODO", "(", ")", ",", "\"", "\"", ")", "\n", "g", ".", "SetTeamAuditor", "(", "dummyAuditor", "{", "}", ")", "\n", "}", "else", "{", "a", ":=", "NewAuditor", "(", "g", ")", "\n", "g", ".", "SetTeamAuditor", "(", "a", ")", "\n", "g", ".", "AddLogoutHook", "(", "a", ",", "\"", "\"", ")", "\n", "g", ".", "AddDbNukeHook", "(", "a", ",", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "NewAuditorAndInstall", "makes", "a", "new", "Auditor", "and", "dangles", "it", "off", "of", "the", "given", "GlobalContext", "." ]

[ "func", "(", "a", "*", "Auditor", ")", "doPreProbes", "(", "m", "libkb", ".", "MetaContext", ",", "history", "*", "keybase1", ".", "AuditHistory", ",", "probeID", "int", ",", "headMerkleSeqno", "keybase1", ".", "Seqno", ")", "(", "numProbes", "int", ",", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "first", ":=", "m", ".", "G", "(", ")", ".", "MerkleClient", ".", "FirstSeqnoWithSkips", "(", "m", ")", "\n", "if", "first", "==", "nil", "{", "return", "0", ",", "NewAuditError", "(", "\"", "\"", ")", "\n", "}", "\n\n", "probeTuples", ",", "err", ":=", "a", ".", "computeProbes", "(", "m", ",", "history", ".", "ID", ",", "history", ".", "PreProbes", ",", "probeID", ",", "*", "first", ",", "headMerkleSeqno", ",", "len", "(", "history", ".", "PreProbes", ")", ",", "getAuditParams", "(", "m", ")", ".", "NumPreProbes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "len", "(", "probeTuples", ")", "==", "0", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "0", ",", "nil", "\n", "}", "\n", "for", "_", ",", "tuple", ":=", "range", "probeTuples", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "tuple", ".", "merkle", ")", "\n", "if", "tuple", ".", "team", "!=", "keybase1", ".", "Seqno", "(", "0", ")", "||", "!", "tuple", ".", "linkID", ".", "IsNil", "(", ")", "{", "return", "0", ",", "NewAuditError", "(", "\"", "\"", ",", "tuple", ".", "merkle", ",", "history", ".", "ID", ",", "tuple", ".", "linkID", ",", "tuple", ".", "team", ")", "\n", "}", "\n", "}", "\n", "return", "len", "(", "probeTuples", ")", ",", "nil", "\n", "}" ]

[ "doPreProbes", "probabilistically", "checks", "that", "no", "team", "occupied", "the", "slot", "before", "the", "team", "in", "question", "was", "created", ".", "It", "selects", "probes", "from", "before", "the", "team", "was", "created", ".", "Each", "probed", "leaf", "must", "not", "be", "occupied", "." ]

[ "func", "GetCurrentSessionIfPossible", "(", "ctx", "context", ".", "Context", ",", "kbpki", "CurrentSessionGetter", ",", "sessionNotRequired", "bool", ")", "(", "SessionInfo", ",", "error", ")", "{", "session", ",", "err", ":=", "kbpki", ".", "GetCurrentSession", "(", "ctx", ")", "\n", "if", "err", "==", "nil", "{", "return", "session", ",", "nil", "\n", "}", "\n", "// Return all errors if a session is required.", "if", "!", "sessionNotRequired", "{", "return", "SessionInfo", "{", "}", ",", "err", "\n", "}", "\n\n", "// If not logged in, return empty session.", "if", "_", ",", "notLoggedIn", ":=", "err", ".", "(", "NoCurrentSessionError", ")", ";", "notLoggedIn", "{", "return", "SessionInfo", "{", "}", ",", "nil", "\n", "}", "\n\n", "// Otherwise, just return the error.", "return", "SessionInfo", "{", "}", ",", "err", "\n", "}" ]

[ "GetCurrentSessionIfPossible", "returns", "the", "current", "username", "and", "UID", "from", "kbpki", ".", "GetCurrentSession", ".", "If", "sessionNotRequired", "is", "true", "NoCurrentSessionError", "is", "ignored", "and", "empty", "username", "and", "uid", "will", "be", "returned", ".", "If", "it", "is", "false", "all", "errors", "are", "returned", "." ]

[ "func", "SessionInfoFromProtocol", "(", "session", "keybase1", ".", "Session", ")", "(", "SessionInfo", ",", "error", ")", "{", "// Import the KIDs to validate them.", "deviceSubkey", ",", "err", ":=", "libkb", ".", "ImportKeypairFromKID", "(", "session", ".", "DeviceSubkeyKid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "SessionInfo", "{", "}", ",", "err", "\n", "}", "\n", "deviceSibkey", ",", "err", ":=", "libkb", ".", "ImportKeypairFromKID", "(", "session", ".", "DeviceSibkeyKid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "SessionInfo", "{", "}", ",", "err", "\n", "}", "\n", "cryptPublicKey", ":=", "kbfscrypto", ".", "MakeCryptPublicKey", "(", "deviceSubkey", ".", "GetKID", "(", ")", ")", "\n", "verifyingKey", ":=", "kbfscrypto", ".", "MakeVerifyingKey", "(", "deviceSibkey", ".", "GetKID", "(", ")", ")", "\n", "return", "SessionInfo", "{", "Name", ":", "kbname", ".", "NewNormalizedUsername", "(", "session", ".", "Username", ")", ",", "UID", ":", "keybase1", ".", "UID", "(", "session", ".", "Uid", ")", ",", "CryptPublicKey", ":", "cryptPublicKey", ",", "VerifyingKey", ":", "verifyingKey", ",", "}", ",", "nil", "\n", "}" ]

[ "SessionInfoFromProtocol", "returns", "SessionInfo", "from", "Session" ]

[ "func", "(", "m", "memoizedMeasurable", ")", "Size", "(", ")", "int", "{", "if", "m", ".", "size", "<=", "0", "{", "m", ".", "size", "=", "m", ".", "m", ".", "Size", "(", ")", "\n", "}", "\n", "return", "m", ".", "size", "\n", "}" ]

[ "Size", "implements", "the", "Measurable", "interface", "." ]

[ "func", "NewLogin", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "deviceType", "string", ",", "username", "string", ",", "ct", "keybase1", ".", "ClientType", ")", "*", "Login", "{", "return", "NewLoginWithUserSwitch", "(", "g", ",", "deviceType", ",", "username", ",", "ct", ",", "false", ")", "\n", "}" ]

[ "NewLogin", "creates", "a", "Login", "engine", ".", "username", "is", "optional", ".", "deviceType", "should", "be", "libkb", ".", "DeviceTypeDesktop", "or", "libkb", ".", "DeviceTypeMobile", "." ]

[ "func", "(", "e", "*", "Login", ")", "notProvisionedErr", "(", "m", "libkb", ".", "MetaContext", ",", "err", "error", ")", "bool", "{", "if", "err", "==", "errNoDevice", "{", "return", "true", "\n", "}", "\n", "if", "err", "==", "errNoConfig", "{", "return", "true", "\n", "}", "\n\n", "m", ".", "Debug", "(", "\"", "\"", ",", "err", ",", "err", ")", "\n", "return", "false", "\n", "}" ]

[ "notProvisionedErr", "will", "return", "true", "if", "err", "signifies", "that", "login", "failed", "because", "this", "device", "has", "not", "yet", "been", "provisioned", "." ]

[ "func", "NewRandomEvictedCache", "(", "maxBytes", "int", ")", "Cache", "{", "return", "&", "randomEvictedCache", "{", "maxBytes", ":", "maxBytes", ",", "data", ":", "make", "(", "map", "[", "Measurable", "]", "memoizedMeasurable", ")", ",", "}", "\n", "}" ]

[ "NewRandomEvictedCache", "returns", "a", "Cache", "that", "uses", "random", "eviction", "strategy", ".", "The", "cache", "will", "have", "a", "capacity", "of", "maxBytes", "bytes", ".", "A", "zero", "-", "byte", "capacity", "cache", "is", "valid", ".", "Internally", "we", "store", "a", "memoizing", "wrapper", "for", "the", "raw", "Measurable", "to", "avoid", "unnecessarily", "frequent", "size", "calculations", ".", "Note", "that", "memoizing", "size", "means", "once", "the", "entry", "is", "in", "the", "cache", "we", "never", "bother", "recalculating", "their", "size", ".", "It", "s", "fine", "if", "the", "size", "changes", "but", "the", "cache", "eviction", "will", "continue", "using", "the", "old", "size", "." ]

[ "func", "NewLRUEvictedCache", "(", "maxBytes", "int", ")", "Cache", "{", "c", ":=", "&", "lruEvictedCache", "{", "maxBytes", ":", "maxBytes", ",", "}", "\n", "c", ".", "data", "=", "&", "lru", ".", "Cache", "{", "OnEvicted", ":", "func", "(", "key", "lru", ".", "Key", ",", "value", "interface", "{", "}", ")", "{", "// No locking is needed in this function because we do them in", "// public methods Get/Add, and RemoveOldest() is only called in the", "// Add method.", "if", "memoized", ",", "ok", ":=", "value", ".", "(", "memoizedMeasurable", ")", ";", "ok", "{", "if", "k", ",", "ok", ":=", "key", ".", "(", "Measurable", ")", ";", "ok", "{", "c", ".", "cachedBytes", "-=", "k", ".", "Size", "(", ")", "+", "memoized", ".", "Size", "(", ")", "\n", "}", "\n", "}", "\n", "}", ",", "}", "\n", "return", "c", "\n", "}" ]

[ "NewLRUEvictedCache", "returns", "a", "Cache", "that", "uses", "LRU", "eviction", "strategy", ".", "The", "cache", "will", "have", "a", "capacity", "of", "maxBytes", "bytes", ".", "A", "zero", "-", "byte", "capacity", "cache", "is", "valid", ".", "Internally", "we", "store", "a", "memoizing", "wrapper", "for", "the", "raw", "Measurable", "to", "avoid", "unnecessarily", "frequent", "size", "calculations", ".", "Note", "that", "this", "means", "once", "the", "entry", "is", "in", "the", "cache", "we", "never", "bother", "recalculating", "their", "size", ".", "It", "s", "fine", "if", "the", "size", "changes", "but", "the", "cache", "eviction", "will", "continue", "using", "the", "old", "size", "." ]

[ "func", "NewArchiveRelTimeFile", "(", "fs", "*", "FS", ",", "handle", "*", "tlfhandle", ".", "Handle", ",", "filename", "string", ",", "entryValid", "*", "time", ".", "Duration", ")", "*", "SpecialReadFile", "{", "*", "entryValid", "=", "0", "\n", "return", "&", "SpecialReadFile", "{", "read", ":", "func", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "byte", ",", "time", ".", "Time", ",", "error", ")", "{", "data", ",", "isRel", ",", "err", ":=", "libfs", ".", "FileDataFromRelativeTimeString", "(", "ctx", ",", "fs", ".", "config", ",", "handle", ",", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n", "if", "!", "isRel", "{", "panic", "(", "\"", "\"", "+", "\"", "\"", ")", "\n", "}", "\n", "return", "data", ",", "time", ".", "Time", "{", "}", ",", "nil", "\n", "}", ",", "}", "\n", "}" ]

[ "NewArchiveRelTimeFile", "returns", "a", "special", "read", "file", "that", "contains", "a", "by", "-", "revision", "directory", "name", "that", "corresponds", "to", "the", "given", "relative", "time", "string", "for", "the", "given", "folder", "." ]

[ "func", "(", "q", "*", "logQueue", ")", "setDropFlag", "(", ")", "{", "select", "{", "case", "q", ".", "drop", "<-", "true", ":", "// do this outside the logging mechanism to make sure it gets through", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "q", ".", "name", ")", "\n", "default", ":", "}", "\n", "}" ]

[ "setDropFlag", "puts", "a", "flag", "into", "the", "drop", "channel", "if", "the", "channel", "is", "empty", ".", "This", "is", "to", "signal", "that", "external", "log", "messages", "have", "been", "dropped", "." ]

[ "func", "(", "q", "*", "logQueue", ")", "checkDropFlag", "(", ")", "{", "select", "{", "case", "<-", "q", ".", "drop", ":", "q", ".", "buffer", "<-", "&", "logEntry", "{", "level", ":", "keybase1", ".", "LogLevel_WARN", ",", "format", ":", "\"", "\"", ",", "}", "\n", "default", ":", "}", "\n", "}" ]

[ "checkDropFlag", "checks", "to", "see", "if", "anything", "is", "in", "the", "drop", "channel", ".", "If", "there", "is", "a", "flag", "in", "there", "it", "will", "warn", "client", "that", "log", "messages", "were", "dropped", "." ]

[ "func", "(", "s", "*", "HybridInboxSource", ")", "getConvsLocal", "(", "ctx", "context", ".", "Context", ",", "uid", "gregor1", ".", "UID", ",", "convIDs", "[", "]", "chat1", ".", "ConversationID", ")", "(", "[", "]", "chat1", ".", "ConversationLocal", ",", "error", ")", "{", "// Read back affected conversation so we can send it to the frontend", "ib", ",", "_", ",", "err", ":=", "s", ".", "Read", "(", "ctx", ",", "uid", ",", "types", ".", "ConversationLocalizerBlocking", ",", "types", ".", "InboxSourceDataSourceAll", ",", "nil", ",", "&", "chat1", ".", "GetInboxLocalQuery", "{", "ConvIDs", ":", "convIDs", ",", "}", ",", "nil", ")", "\n", "return", "ib", ".", "Convs", ",", "err", "\n", "}" ]

[ "Get", "convs", ".", "May", "return", "fewer", "or", "no", "conversations", "." ]

[ "func", "(", "c", "LoginClient", ")", "GetConfiguredAccounts", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "res", "[", "]", "ConfiguredAccount", ",", "err", "error", ")", "{", "__arg", ":=", "GetConfiguredAccountsArg", "{", "SessionID", ":", "sessionID", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Returns", "an", "array", "of", "information", "about", "accounts", "configured", "on", "the", "local", "machine", ".", "Currently", "configured", "accounts", "are", "defined", "as", "those", "that", "have", "stored", "secrets", "but", "this", "definition", "may", "be", "expanded", "in", "the", "future", "." ]

[ "func", "(", "c", "LoginClient", ")", "Login", "(", "ctx", "context", ".", "Context", ",", "__arg", "LoginArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Performs", "login", ".", "deviceType", "should", "be", "libkb", ".", "DeviceTypeDesktop", "or", "libkb", ".", "DeviceTypeMobile", ".", "username", "is", "optional", ".", "If", "the", "current", "device", "isn", "t", "provisioned", "this", "function", "will", "provision", "it", "." ]

[ "func", "(", "c", "LoginClient", ")", "LoginProvisionedDevice", "(", "ctx", "context", ".", "Context", ",", "__arg", "LoginProvisionedDeviceArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Login", "a", "user", "only", "if", "the", "user", "is", "on", "a", "provisioned", "device", ".", "Username", "is", "optional", ".", "If", "noPassphrasePrompt", "is", "set", "then", "only", "a", "stored", "secret", "will", "be", "used", "to", "unlock", "the", "device", "keys", "." ]

[ "func", "(", "c", "LoginClient", ")", "LoginWithPaperKey", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "err", "error", ")", "{", "__arg", ":=", "LoginWithPaperKeyArg", "{", "SessionID", ":", "sessionID", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Login", "and", "unlock", "by", "-", "trying", "unlocked", "device", "keys", "if", "available", "-", "prompting", "for", "a", "paper", "key", "and", "using", "that" ]

[ "func", "(", "c", "LoginClient", ")", "PaperKey", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "err", "error", ")", "{", "__arg", ":=", "PaperKeyArg", "{", "SessionID", ":", "sessionID", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "PaperKey", "generates", "paper", "backup", "keys", "for", "restoring", "an", "account", ".", "It", "calls", "login_ui", ".", "displayPaperKeyPhrase", "with", "the", "phrase", "." ]

[ "func", "(", "c", "LoginClient", ")", "PaperKeySubmit", "(", "ctx", "context", ".", "Context", ",", "__arg", "PaperKeySubmitArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "paperKeySubmit", "checks", "that", "paperPhrase", "is", "a", "valid", "paper", "key", "for", "the", "logged", "in", "user", "caches", "the", "keys", "and", "sends", "a", "notification", "." ]

[ "func", "(", "c", "LoginClient", ")", "Unlock", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "err", "error", ")", "{", "__arg", ":=", "UnlockArg", "{", "SessionID", ":", "sessionID", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Unlock", "restores", "access", "to", "local", "key", "store", "by", "priming", "passphrase", "stream", "cache", "." ]

[ "func", "(", "c", "LoginClient", ")", "LoginOneshot", "(", "ctx", "context", ".", "Context", ",", "__arg", "LoginOneshotArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "loginOneshot", "allows", "a", "service", "to", "have", "a", "onetime", "login", "without", "provisioning", "a", "device", ".", "It", "bootstraps", "credentials", "with", "the", "given", "paperkey" ]

[ "func", "(", "o", "*", "Options", ")", "NetworkOptions", "(", "mctx", "libkb", ".", "MetaContext", ",", "r", "remote", ".", "Remoter", ")", "stellar1", ".", "NetworkOptions", "{", "o", ".", "Lock", "(", ")", "\n", "defer", "o", ".", "Unlock", "(", ")", "\n\n", "if", "time", ".", "Since", "(", "o", ".", "mtime", ")", "<", "1", "*", "time", ".", "Hour", "{", "return", "o", ".", "network", "\n", "}", "\n\n", "options", ",", "err", ":=", "r", ".", "NetworkOptions", "(", "mctx", ".", "Ctx", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "options", ")", "\n", "o", ".", "network", "=", "options", "\n", "o", ".", "mtime", "=", "time", ".", "Now", "(", ")", "\n", "}", "\n\n", "return", "o", ".", "network", "\n", "}" ]

[ "NetworkOptions", "returns", "stellar1", ".", "NetworkOptions", "that", "is", "less", "than", "1", "hour", "old", "." ]

[ "func", "ParseStellarSecretKey", "(", "secStr", "string", ")", "(", "stellar1", ".", "SecretKey", ",", "stellar1", ".", "AccountID", ",", "*", "keypair", ".", "Full", ",", "error", ")", "{", "secStr", "=", "strings", ".", "ToUpper", "(", "secStr", ")", "\n", "if", "len", "(", "secStr", ")", "!=", "56", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "secStr", ")", ")", "\n", "}", "\n", "_", ",", "err", ":=", "base32", ".", "StdEncoding", ".", "DecodeString", "(", "secStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "kp", ",", "err", ":=", "keypair", ".", "Parse", "(", "secStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "switch", "kp", ":=", "kp", ".", "(", "type", ")", "{", "case", "*", "keypair", ".", "FromAddress", ":", "return", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "*", "keypair", ".", "Full", ":", "return", "stellar1", ".", "SecretKey", "(", "kp", ".", "Seed", "(", ")", ")", ",", "stellar1", ".", "AccountID", "(", "kp", ".", "Address", "(", ")", ")", ",", "kp", ",", "nil", "\n", "default", ":", "return", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "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", "ParseStellarAccountID", "(", "idStr", "string", ")", "(", "stellar1", ".", "AccountID", ",", "error", ")", "{", "idStr", "=", "strings", ".", "ToUpper", "(", "idStr", ")", "\n", "if", "len", "(", "idStr", ")", "!=", "56", "{", "return", "\"", "\"", ",", "NewInvalidStellarAccountIDError", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "len", "(", "idStr", ")", ")", ")", "\n", "}", "\n", "_", ",", "err", ":=", "base32", ".", "StdEncoding", ".", "DecodeString", "(", "idStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "NewInvalidStellarAccountIDError", "(", "\"", "\"", ")", "\n", "}", "\n", "kp", ",", "err", ":=", "keypair", ".", "Parse", "(", "idStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "NewInvalidStellarAccountIDError", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n", "switch", "kp", ":=", "kp", ".", "(", "type", ")", "{", "case", "*", "keypair", ".", "FromAddress", ":", "return", "stellar1", ".", "AccountID", "(", "kp", ".", "Address", "(", ")", ")", ",", "nil", "\n", "case", "*", "keypair", ".", "Full", ":", "return", "\"", "\"", ",", "NewInvalidStellarAccountIDError", "(", "\"", "\"", ")", "\n", "default", ":", "return", "\"", "\"", ",", "NewInvalidStellarAccountIDError", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

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

[ "func", "configureProcesses", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "cl", "*", "libcmdline", ".", "CommandLine", ",", "cmd", "*", "libcmdline", ".", "Command", ")", "(", "err", "error", ")", "{", "g", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "defer", "func", "(", ")", "{", "g", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "// On Linux, the service configures its own autostart file. Otherwise, no", "// need to configure if we're a service.", "if", "cl", ".", "IsService", "(", ")", "{", "g", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "g", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "_", ",", "err", ":=", "install", ".", "AutoInstall", "(", "g", ",", "\"", "\"", ",", "false", ",", "10", "*", "time", ".", "Second", ",", "g", ".", "Log", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "// Start the server on the other end, possibly.", "// There are two cases in which we do this: (1) we want", "// a local loopback server in standalone mode; (2) we", "// need to \"autofork\" it. Do at most one of these", "// operations.", "if", "g", ".", "Env", ".", "GetStandalone", "(", ")", "{", "if", "cl", ".", "IsNoStandalone", "(", ")", "{", "err", "=", "client", ".", "CantRunInStandaloneError", "{", "}", "\n", "return", "err", "\n", "}", "\n", "svc", ":=", "service", ".", "NewService", "(", "g", ",", "false", "/* isDaemon */", ")", "\n", "err", "=", "svc", ".", "SetupCriticalSubServices", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "svc", ".", "StartLoopbackServer", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// StandaloneChatConnector is an interface with only one", "// method: StartStandaloneChat. This way we can pass Service", "// object while not exposing anything but that one function.", "g", ".", "StandaloneChatConnector", "=", "svc", "\n", "g", ".", "Standalone", "=", "true", "\n\n", "if", "pflerr", ",", "ok", ":=", "err", ".", "(", "libkb", ".", "PIDFileLockError", ")", ";", "ok", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "pflerr", ".", "Filename", ")", "\n", "return", "err", "\n", "}", "\n", "return", "err", "\n", "}", "\n\n", "// After this point, we need to provide a remote logging story if necessary", "// If this command specifically asks not to be forked, then we are done in this", "// function. This sort of thing is true for the `ctl` commands and also the `version`", "// command.", "fc", ":=", "cl", ".", "GetForkCmd", "(", ")", "\n", "if", "fc", "==", "libcmdline", ".", "NoFork", "{", "return", "configureLogging", "(", "g", ",", "cl", ")", "\n", "}", "\n\n", "var", "newProc", "bool", "\n", "if", "libkb", ".", "IsBrewBuild", "{", "// If we're running in Brew mode, we might need to install ourselves as a persistent", "// service for future invocations of the command.", "newProc", ",", "err", "=", "install", ".", "AutoInstall", "(", "g", ",", "\"", "\"", ",", "false", ",", "10", "*", "time", ".", "Second", ",", "g", ".", "Log", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "else", "{", "// If this command warrants an autofork, do it now.", "if", "fc", "==", "libcmdline", ".", "ForceFork", "||", "g", ".", "Env", ".", "GetAutoFork", "(", ")", "{", "newProc", ",", "err", "=", "client", ".", "AutoForkServer", "(", "g", ",", "cl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Restart the service if we see that it's out of date. It's important to do this", "// before we make any RPCs to the service --- for instance, before the logging", "// calls below. See the v1.0.8 update fiasco for more details. Also, only need", "// to do this if we didn't just start a new process.", "if", "!", "newProc", "{", "if", "err", "=", "client", ".", "FixVersionClash", "(", "g", ",", "cl", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Ignore error", "if", "err", "=", "client", ".", "WarnOutdatedKBFS", "(", "g", ",", "cl", ")", ";", "err", "!=", "nil", "{", "g", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "g", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "newProc", ")", "\n", "if", "err", "=", "configureLogging", "(", "g", ",", "cl", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// This sends the client's PATH to the service so the service can update", "// its PATH if necessary. This is called after FixVersionClash(), which", "// happens above in configureProcesses().", "if", "err", "=", "configurePath", "(", "g", ",", "cl", ")", ";", "err", "!=", "nil", "{", "// Further note -- don't die here. It could be we're calling this method", "// against an earlier version of the service that doesn't support it.", "// It's not critical that it succeed, so continue on.", "g", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "AutoFork?", "Standalone?", "ClientServer?", "Brew", "service?", "This", "function", "deals", "with", "the", "various", "run", "configurations", "that", "we", "can", "run", "in", "." ]

[ "func", "configurePath", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "cl", "*", "libcmdline", ".", "CommandLine", ")", "error", "{", "if", "cl", ".", "IsService", "(", ")", "{", "// this only runs on the client", "return", "nil", "\n", "}", "\n\n", "return", "client", ".", "SendPath", "(", "g", ")", "\n", "}" ]

[ "configurePath", "sends", "the", "client", "s", "PATH", "to", "the", "service", "." ]

[ "func", "stripFieldsFromAppStatusError", "(", "e", "error", ")", "error", "{", "if", "e", "==", "nil", "{", "return", "e", "\n", "}", "\n", "if", "ase", ",", "ok", ":=", "e", ".", "(", "libkb", ".", "AppStatusError", ")", ";", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ase", ".", "Desc", ",", "ase", ".", "Code", ")", "\n", "}", "\n", "return", "e", "\n", "}" ]

[ "stripFieldsFromAppStatusError", "is", "an", "error", "prettifier", ".", "By", "default", "AppStatusErrors", "print", "optional", "fields", "that", "were", "problematic", ".", "But", "they", "make", "for", "pretty", "ugly", "error", "messages", "spit", "back", "to", "the", "user", ".", "So", "strip", "that", "out", "but", "still", "leave", "in", "an", "error", "-", "code", "integer", "since", "those", "are", "quite", "helpful", "." ]

[ "func", "NewKeyServerMemory", "(", "config", "KeyServerConfig", ",", "log", "logger", ".", "Logger", ")", "(", "*", "KeyServerLocal", ",", "error", ")", "{", "return", "newKeyServerLocal", "(", "config", ",", "log", ",", "storage", ".", "NewMemStorage", "(", ")", ",", "nil", ")", "\n", "}" ]

[ "NewKeyServerMemory", "returns", "a", "KeyServerLocal", "with", "an", "in", "-", "memory", "leveldb", "instance", "." ]

[ "func", "NewKeyServerDir", "(", "config", "KeyServerConfig", ",", "log", "logger", ".", "Logger", ",", "dirPath", "string", ")", "(", "*", "KeyServerLocal", ",", "error", ")", "{", "return", "newKeyServerDisk", "(", "config", ",", "log", ",", "dirPath", ",", "nil", ")", "\n", "}" ]

[ "NewKeyServerDir", "constructs", "a", "new", "KeyServerLocal", "that", "stores", "its", "data", "in", "the", "given", "directory", "." ]

[ "func", "NewKeyServerTempDir", "(", "config", "KeyServerConfig", ",", "log", "logger", ".", "Logger", ")", "(", "*", "KeyServerLocal", ",", "error", ")", "{", "tempdir", ",", "err", ":=", "ioutil", ".", "TempDir", "(", "os", ".", "TempDir", "(", ")", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "newKeyServerDisk", "(", "config", ",", "log", ",", "tempdir", ",", "func", "(", "log", "logger", ".", "Logger", ")", "{", "err", ":=", "ioutil", ".", "RemoveAll", "(", "tempdir", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warning", "(", "\"", "\"", ",", "tempdir", ",", "err", ")", "\n", "}", "\n", "}", ")", "\n", "}" ]

[ "NewKeyServerTempDir", "constructs", "a", "new", "KeyServerLocal", "that", "stores", "its", "data", "in", "a", "temp", "directory", "which", "is", "cleaned", "up", "on", "shutdown", "." ]

[ "func", "(", "ks", "*", "KeyServerLocal", ")", "GetTLFCryptKeyServerHalf", "(", "ctx", "context", ".", "Context", ",", "serverHalfID", "kbfscrypto", ".", "TLFCryptKeyServerHalfID", ",", "key", "kbfscrypto", ".", "CryptPublicKey", ")", "(", "serverHalf", "kbfscrypto", ".", "TLFCryptKeyServerHalf", ",", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "kbfscrypto", ".", "TLFCryptKeyServerHalf", "{", "}", ",", "err", "\n", "}", "\n\n", "ks", ".", "shutdownLock", ".", "RLock", "(", ")", "\n", "defer", "ks", ".", "shutdownLock", ".", "RUnlock", "(", ")", "\n", "if", "*", "ks", ".", "shutdown", "{", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "buf", ",", "err", ":=", "ks", ".", "db", ".", "Get", "(", "serverHalfID", ".", "ID", ".", "Bytes", "(", ")", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "err", "=", "ks", ".", "config", ".", "Codec", "(", ")", ".", "Decode", "(", "buf", ",", "&", "serverHalf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfscrypto", ".", "TLFCryptKeyServerHalf", "{", "}", ",", "err", "\n", "}", "\n\n", "session", ",", "err", ":=", "ks", ".", "config", ".", "KBPKI", "(", ")", ".", "GetCurrentSession", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfscrypto", ".", "TLFCryptKeyServerHalf", "{", "}", ",", "err", "\n", "}", "\n\n", "err", "=", "kbfscrypto", ".", "VerifyTLFCryptKeyServerHalfID", "(", "serverHalfID", ",", "session", ".", "UID", ",", "key", ",", "serverHalf", ")", "\n", "if", "err", "!=", "nil", "{", "ks", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "kbfscrypto", ".", "TLFCryptKeyServerHalf", "{", "}", ",", "kbfsmd", ".", "ServerErrorUnauthorized", "{", "Err", ":", "err", "}", "\n", "}", "\n", "return", "serverHalf", ",", "nil", "\n", "}" ]

[ "GetTLFCryptKeyServerHalf", "implements", "the", "KeyServer", "interface", "for", "KeyServerLocal", "." ]

[ "func", "(", "ks", "*", "KeyServerLocal", ")", "PutTLFCryptKeyServerHalves", "(", "ctx", "context", ".", "Context", ",", "keyServerHalves", "kbfsmd", ".", "UserDeviceKeyServerHalves", ")", "error", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "ks", ".", "shutdownLock", ".", "RLock", "(", ")", "\n", "defer", "ks", ".", "shutdownLock", ".", "RUnlock", "(", ")", "\n", "if", "*", "ks", ".", "shutdown", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// batch up the writes such that they're atomic.", "batch", ":=", "&", "leveldb", ".", "Batch", "{", "}", "\n", "for", "uid", ",", "deviceMap", ":=", "range", "keyServerHalves", "{", "for", "deviceKey", ",", "serverHalf", ":=", "range", "deviceMap", "{", "buf", ",", "err", ":=", "ks", ".", "config", ".", "Codec", "(", ")", ".", "Encode", "(", "serverHalf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "id", ",", "err", ":=", "kbfscrypto", ".", "MakeTLFCryptKeyServerHalfID", "(", "uid", ",", "deviceKey", ",", "serverHalf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "batch", ".", "Put", "(", "id", ".", "ID", ".", "Bytes", "(", ")", ",", "buf", ")", "\n", "}", "\n", "}", "\n", "return", "ks", ".", "db", ".", "Write", "(", "batch", ",", "nil", ")", "\n", "}" ]

[ "PutTLFCryptKeyServerHalves", "implements", "the", "KeyServer", "interface", "for", "KeyServerLocal", "." ]

[ "func", "(", "ks", "*", "KeyServerLocal", ")", "DeleteTLFCryptKeyServerHalf", "(", "ctx", "context", ".", "Context", ",", "_", "keybase1", ".", "UID", ",", "_", "kbfscrypto", ".", "CryptPublicKey", ",", "serverHalfID", "kbfscrypto", ".", "TLFCryptKeyServerHalfID", ")", "error", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "ks", ".", "shutdownLock", ".", "RLock", "(", ")", "\n", "defer", "ks", ".", "shutdownLock", ".", "RUnlock", "(", ")", "\n", "if", "*", "ks", ".", "shutdown", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// TODO: verify that the kid is really valid for the given uid", "return", "ks", ".", "db", ".", "Delete", "(", "serverHalfID", ".", "ID", ".", "Bytes", "(", ")", ",", "nil", ")", "\n", "}" ]

[ "DeleteTLFCryptKeyServerHalf", "implements", "the", "KeyServer", "interface", "for", "KeyServerLocal", "." ]

[ "func", "(", "ks", "*", "KeyServerLocal", ")", "CopyWithConfigAndLogger", "(", "config", "KeyServerConfig", ",", "log", "logger", ".", "Logger", ")", "*", "KeyServerLocal", "{", "return", "&", "KeyServerLocal", "{", "config", ",", "ks", ".", "db", ",", "log", ",", "ks", ".", "shutdownLock", ",", "ks", ".", "shutdown", ",", "ks", ".", "shutdownFunc", "}", "\n", "}" ]

[ "CopyWithConfigAndLogger", "copies", "a", "key", "server", "but", "swaps", "the", "config", "and", "the", "logger", "." ]

[ "func", "(", "ks", "*", "KeyServerLocal", ")", "Shutdown", "(", ")", "{", "ks", ".", "shutdownLock", ".", "Lock", "(", ")", "\n", "defer", "ks", ".", "shutdownLock", ".", "Unlock", "(", ")", "\n", "if", "*", "ks", ".", "shutdown", "{", "return", "\n", "}", "\n", "*", "ks", ".", "shutdown", "=", "true", "\n\n", "if", "ks", ".", "db", "!=", "nil", "{", "ks", ".", "db", ".", "Close", "(", ")", "\n", "}", "\n\n", "if", "ks", ".", "shutdownFunc", "!=", "nil", "{", "ks", ".", "shutdownFunc", "(", "ks", ".", "log", ")", "\n", "}", "\n", "}" ]

[ "Shutdown", "implements", "the", "KeyServer", "interface", "for", "KeyServerLocal", "." ]

[ "func", "(", "c", "*", "aclCheckerV1", ")", "getPermissions", "(", "p", "string", ",", "username", "*", "string", ")", "(", "permissions", "permissionsV1", ",", "max", "permissionsV1", ",", "effectivePath", "string", ")", "{", "// This is only called on the root aclCheckerV1, and c.ac is always", "// populated here. So even if no other path shows up in the ACLs, any path", "// will get root's *accessControlV1 as the last resort.", "ac", ":=", "c", ".", "getAccessControl", "(", "nil", ",", "p", ")", "\n", "permissions", "=", "ac", ".", "anonymous", "\n", "if", "ac", ".", "whitelistAdditional", "==", "nil", "||", "username", "==", "nil", "{", "return", "permissions", ",", "ac", ".", "maxPermission", ",", "ac", ".", "p", "\n", "}", "\n", "if", "perms", ",", "ok", ":=", "ac", ".", "whitelistAdditional", "[", "*", "username", "]", ";", "ok", "{", "permissions", ".", "read", "=", "perms", ".", "read", "||", "permissions", ".", "read", "\n", "permissions", ".", "list", "=", "perms", ".", "list", "||", "permissions", ".", "list", "\n", "}", "\n", "return", "permissions", ",", "ac", ".", "maxPermission", ",", "ac", ".", "p", "\n", "}" ]

[ "getPermissions", "returns", "the", "permissions", "that", "username", "has", "on", "p", ".", "This", "method", "should", "only", "be", "called", "on", "the", "root", "aclCheckerV1", "." ]

[ "func", "AddPlatformFlags", "(", "flags", "*", "flag", ".", "FlagSet", ")", "*", "PlatformParams", "{", "var", "params", "PlatformParams", "\n", "flags", ".", "BoolVar", "(", "&", "params", ".", "UseSystemFuse", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVar", "(", "&", "params", ".", "UseLocal", ",", "\"", "\"", ",", "false", ",", "\"", "\"", "+", "\"", "\\\"", "\\\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ")", "\n", "return", "&", "params", "\n", "}" ]

[ "AddPlatformFlags", "adds", "platform", "-", "specific", "flags", "to", "the", "given", "FlagSet", "and", "returns", "a", "PlatformParams", "object", "that", "will", "be", "filled", "in", "when", "the", "given", "FlagSet", "is", "parsed", "." ]

[ "func", "(", "c", "ProvisionUiClient", ")", "SwitchToGPGSignOK", "(", "ctx", "context", ".", "Context", ",", "__arg", "SwitchToGPGSignOKArg", ")", "(", "res", "bool", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "If", "there", "was", "an", "error", "importing", "a", "gpg", "key", "into", "the", "local", "keyring", "tell", "the", "user", "and", "offer", "to", "switch", "to", "GPG", "signing", "with", "this", "key", ".", "Return", "true", "to", "switch", "to", "GPG", "signing", "false", "to", "abort", "provisioning", "." ]

[ "func", "(", "c", "ProvisionUiClient", ")", "DisplaySecretExchanged", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "err", "error", ")", "{", "__arg", ":=", "DisplaySecretExchangedArg", "{", "SessionID", ":", "sessionID", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "DisplaySecretExchanged", "is", "called", "when", "the", "kex2", "secret", "has", "successfully", "been", "exchanged", "by", "the", "two", "devices", "." ]

[ "func", "(", "c", "ProvisionUiClient", ")", "PromptNewDeviceName", "(", "ctx", "context", ".", "Context", ",", "__arg", "PromptNewDeviceNameArg", ")", "(", "res", "string", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "PromptNewDeviceName", "is", "called", "when", "the", "device", "provisioning", "process", "needs", "a", "name", "for", "the", "new", "device", ".", "To", "help", "the", "clients", "not", "send", "a", "duplicate", "name", "existingDevices", "is", "populated", "with", "the", "current", "device", "names", "for", "the", "user", ".", "If", "the", "device", "name", "returned", "to", "the", "service", "is", "invalid", "or", "already", "taken", "it", "will", "call", "this", "again", "with", "an", "error", "message", "in", "errorMessage", "." ]

[ "func", "(", "c", "ProvisionUiClient", ")", "ProvisioneeSuccess", "(", "ctx", "context", ".", "Context", ",", "__arg", "ProvisioneeSuccessArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "ProvisioneeSuccess", "is", "called", "on", "provisionee", "when", "it", "is", "successfully", "provisioned", "." ]

[ "func", "(", "c", "ProvisionUiClient", ")", "ProvisionerSuccess", "(", "ctx", "context", ".", "Context", ",", "__arg", "ProvisionerSuccessArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "ProvisionerSuccess", "is", "called", "on", "provisioner", "when", "it", "successfully", "provisions", "another", "device", "." ]

[ "func", "MsgpackDecodeAll", "(", "data", "[", "]", "byte", ",", "handle", "*", "codec", ".", "MsgpackHandle", ",", "out", "interface", "{", "}", ")", "error", "{", "decoder", ":=", "codec", ".", "NewDecoderBytes", "(", "data", ",", "handle", ")", "\n", "err", ":=", "decoder", ".", "Decode", "(", "out", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "decoder", ".", "NumBytesRead", "(", ")", "!=", "len", "(", "data", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "data", ")", "-", "decoder", ".", "NumBytesRead", "(", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

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

[ "func", "MakePseudonym", "(", "info", "TlfPseudonymInfo", ")", "(", "TlfPseudonym", ",", "error", ")", "{", "input", ":=", "tlfPseudonymContents", "{", "Version", ":", "tlfPseudonymVersion", ",", "Name", ":", "info", ".", "Name", ",", "ID", ":", "info", ".", "ID", ",", "KeyGen", ":", "info", ".", "KeyGen", ",", "}", "\n", "mh", ":=", "codec", ".", "MsgpackHandle", "{", "WriteExt", ":", "true", "}", "\n", "var", "buf", "[", "]", "byte", "\n", "enc", ":=", "codec", ".", "NewEncoderBytes", "(", "&", "buf", ",", "&", "mh", ")", "\n", "err", ":=", "enc", ".", "Encode", "(", "input", ")", "\n", "if", "err", "!=", "nil", "{", "return", "[", "32", "]", "byte", "{", "}", ",", "err", "\n", "}", "\n", "mac", ":=", "hmac", ".", "New", "(", "sha256", ".", "New", ",", "info", ".", "HmacKey", "[", ":", "]", ")", "\n", "mac", ".", "Write", "(", "buf", ")", "\n", "hmac", ":=", "MakeByte32", "(", "mac", ".", "Sum", "(", "nil", ")", ")", "\n", "return", "hmac", ",", "nil", "\n", "}" ]

[ "MakePseudonym", "makes", "a", "TLF", "pseudonym", "from", "the", "given", "input", "." ]

[ "func", "GetTlfPseudonyms", "(", "ctx", "context", ".", "Context", ",", "g", "*", "GlobalContext", ",", "pnyms", "[", "]", "TlfPseudonym", ")", "(", "[", "]", "GetTlfPseudonymEither", ",", "error", ")", "{", "var", "pnymStrings", "[", "]", "string", "\n", "for", "_", ",", "x", ":=", "range", "pnyms", "{", "pnymStrings", "=", "append", "(", "pnymStrings", ",", "x", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "payload", ":=", "make", "(", "JSONPayload", ")", "\n", "payload", "[", "\"", "\"", "]", "=", "pnymStrings", "\n\n", "var", "res", "getTlfPseudonymsRes", "\n", "mctx", ":=", "NewMetaContext", "(", "ctx", ",", "g", ")", "\n", "err", ":=", "g", ".", "API", ".", "PostDecode", "(", "mctx", ",", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "SessionType", ":", "APISessionTypeREQUIRED", ",", "JSONPayload", ":", "payload", ",", "}", ",", "&", "res", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Validate the response", "if", "len", "(", "res", ".", "TlfPseudonyms", ")", "!=", "len", "(", "pnyms", ")", "{", "return", "nil", ",", "&", "PseudonymGetError", "{", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "len", "(", "res", ".", "TlfPseudonyms", ")", ",", "len", "(", "pnyms", ")", ")", "}", "\n", "}", "\n", "var", "resList", "[", "]", "GetTlfPseudonymEither", "\n", "for", "i", ",", "received", ":=", "range", "res", ".", "TlfPseudonyms", "{", "resList", "=", "append", "(", "resList", ",", "checkAndConvertTlfPseudonymFromServer", "(", "ctx", ",", "g", ",", "pnyms", "[", "i", "]", ",", "received", ")", ")", "\n", "}", "\n\n", "return", "resList", ",", "nil", "\n", "}" ]

[ "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", "." ]

[ "func", "MakeKeyPseudonym", "(", "info", "KeyPseudonymInfo", ")", "(", "KeyPseudonym", ",", "error", ")", "{", "var", "idBytes", "[", "16", "]", "byte", "\n", "id", ":=", "info", ".", "ID", ".", "ToBytes", "(", ")", "\n\n", "copy", "(", "idBytes", "[", ":", "]", ",", "id", ")", "\n\n", "input", ":=", "keyPseudonymContents", "{", "Version", ":", "KeyPseudonymVersion", ",", "ID", ":", "idBytes", ",", "Application", ":", "info", ".", "Application", ",", "KeyGen", ":", "info", ".", "KeyGen", ",", "}", "\n", "mh", ":=", "codec", ".", "MsgpackHandle", "{", "WriteExt", ":", "true", "}", "\n", "var", "buf", "[", "]", "byte", "\n", "enc", ":=", "codec", ".", "NewEncoderBytes", "(", "&", "buf", ",", "&", "mh", ")", "\n", "if", "err", ":=", "enc", ".", "Encode", "(", "input", ")", ";", "err", "!=", "nil", "{", "return", "[", "32", "]", "byte", "{", "}", ",", "err", "\n", "}", "\n\n", "mac", ":=", "hmac", ".", "New", "(", "sha256", ".", "New", ",", "info", ".", "Nonce", "[", ":", "]", ")", "\n", "mac", ".", "Write", "(", "buf", ")", "\n", "hmac", ":=", "MakeByte32", "(", "mac", ".", "Sum", "(", "nil", ")", ")", "\n", "return", "hmac", ",", "nil", "\n", "}" ]

[ "MakePseudonym", "makes", "a", "key", "pseudonym", "from", "the", "given", "input", "." ]

[ "func", "MakeAndPostKeyPseudonyms", "(", "m", "MetaContext", ",", "pnymInfos", "*", "[", "]", "KeyPseudonymInfo", ")", "(", "err", "error", ")", "{", "var", "pnymReqs", "[", "]", "keyPseudonymReq", "\n\n", "if", "len", "(", "*", "pnymInfos", ")", "==", "0", "{", "return", "\n", "}", "\n\n", "for", "i", ",", "info", ":=", "range", "*", "pnymInfos", "{", "// Compute the pseudonym", "var", "pnym", "KeyPseudonym", "\n", "pnym", ",", "err", "=", "MakeKeyPseudonym", "(", "info", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "(", "*", "pnymInfos", ")", "[", "i", "]", ".", "KeyPseudonym", "=", "pnym", "\n", "pnymReqs", "=", "append", "(", "pnymReqs", ",", "keyPseudonymReq", "{", "Pseudonym", ":", "pnym", ",", "ID", ":", "info", ".", "ID", ",", "Application", ":", "int", "(", "info", ".", "Application", ")", ",", "KeyGen", ":", "int", "(", "info", ".", "KeyGen", ")", ",", "Nonce", ":", "info", ".", "Nonce", ",", "}", ")", "\n", "}", "\n\n", "payload", ":=", "make", "(", "JSONPayload", ")", "\n", "payload", "[", "\"", "\"", "]", "=", "pnymReqs", "\n\n", "_", ",", "err", "=", "m", ".", "G", "(", ")", ".", "API", ".", "PostJSON", "(", "m", ",", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "JSONPayload", ":", "payload", ",", "SessionType", ":", "APISessionTypeREQUIRED", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "MakeAndPostKeyPseudonyms", "fills", "the", "KeyPseudonym", "field", "of", "each", "of", "the", "pnymInfos", "with", "the", "appropriate", "KeyPseudonym", "." ]

[ "func", "GetKeyPseudonyms", "(", "m", "MetaContext", ",", "pnyms", "[", "]", "KeyPseudonym", ")", "(", "[", "]", "KeyPseudonymOrError", ",", "error", ")", "{", "var", "pnymStrings", "[", "]", "string", "\n", "for", "_", ",", "x", ":=", "range", "pnyms", "{", "pnymStrings", "=", "append", "(", "pnymStrings", ",", "x", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "var", "res", "getKeyPseudonymsRes", "\n", "err", ":=", "m", ".", "G", "(", ")", ".", "API", ".", "GetDecode", "(", "m", ",", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "SessionType", ":", "APISessionTypeREQUIRED", ",", "Args", ":", "HTTPArgs", "{", "\"", "\"", ":", "S", "{", "Val", ":", "strings", ".", "Join", "(", "pnymStrings", ",", "\"", "\"", ")", "}", ",", "}", ",", "}", ",", "&", "res", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Validate the response", "if", "len", "(", "res", ".", "KeyPseudonyms", ")", "!=", "len", "(", "pnyms", ")", "{", "return", "nil", ",", "&", "KeyPseudonymGetError", "{", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "len", "(", "res", ".", "KeyPseudonyms", ")", ",", "len", "(", "pnyms", ")", ")", "}", "\n", "}", "\n", "var", "resList", "[", "]", "KeyPseudonymOrError", "\n", "for", "i", ",", "received", ":=", "range", "res", ".", "KeyPseudonyms", "{", "resList", "=", "append", "(", "resList", ",", "checkAndConvertKeyPseudonymFromServer", "(", "pnyms", "[", "i", "]", ",", "received", ")", ")", "\n", "}", "\n\n", "return", "resList", ",", "nil", "\n", "}" ]

[ "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", "." ]

[ "func", "RandomPseudonymNonce", "(", ")", "KeyPseudonymNonce", "{", "slice", ",", "err", ":=", "RandBytes", "(", "32", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "KeyPseudonymNonce", "(", "MakeByte32", "(", "slice", ")", ")", "\n", "}" ]

[ "RandomPseudonymNonce", "returns", "a", "random", "nonce", "which", "is", "used", "as", "an", "HMAC", "key", "." ]

[ "func", "GetMySecretKey", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "getSecretUI", "func", "(", ")", "libkb", ".", "SecretUI", ",", "secretKeyType", "libkb", ".", "SecretKeyType", ",", "reason", "string", ")", "(", "libkb", ".", "GenericKey", ",", "error", ")", "{", "key", ",", "err", ":=", "g", ".", "ActiveDevice", ".", "KeyByType", "(", "secretKeyType", ")", "\n", "if", "err", "!=", "nil", "{", "if", "_", ",", "ok", ":=", "err", ".", "(", "libkb", ".", "NotFoundError", ")", ";", "ok", "{", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "secretKeyType", ")", "\n", "return", "nil", ",", "libkb", ".", "LoginRequiredError", "{", "Context", ":", "\"", "\"", "}", "\n", "}", "\n", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "secretKeyType", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "return", "key", ",", "nil", "\n", "}" ]

[ "GetMySecretKey", "uses", "ActiveDevice", "to", "get", "a", "secret", "key", "for", "the", "current", "user", ".", "It", "used", "to", "have", "functionality", "to", "load", "the", "user", "and", "prompt", "for", "a", "passphrase", "to", "unlock", "the", "keys", "but", "that", "is", "outdated", "now", ".", "Either", "you", "are", "logged", "in", "and", "have", "your", "device", "keys", "cached", "or", "you", "aren", "t", ".", "If", "the", "key", "isn", "t", "found", "in", "the", "ActiveDevice", "cache", "this", "will", "return", "LoginRequiredError", "." ]

[ "func", "SignED25519", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "getSecretUI", "func", "(", ")", "libkb", ".", "SecretUI", ",", "arg", "keybase1", ".", "SignED25519Arg", ")", "(", "ret", "keybase1", ".", "ED25519SignatureInfo", ",", "err", "error", ")", "{", "signingKey", ",", "err", ":=", "GetMySecretKey", "(", "ctx", ",", "g", ",", "getSecretUI", ",", "libkb", ".", "DeviceSigningKeyType", ",", "arg", ".", "Reason", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "kp", ",", "ok", ":=", "signingKey", ".", "(", "libkb", ".", "NaclSigningKeyPair", ")", "\n", "if", "!", "ok", "||", "kp", ".", "Private", "==", "nil", "{", "err", "=", "libkb", ".", "KeyCannotSignError", "{", "}", "\n", "return", "\n", "}", "\n\n", "sig", ":=", "kp", ".", "Private", ".", "Sign", "(", "arg", ".", "Msg", ")", "\n", "publicKey", ":=", "kp", ".", "Public", "\n", "ret", "=", "keybase1", ".", "ED25519SignatureInfo", "{", "Sig", ":", "keybase1", ".", "ED25519Signature", "(", "sig", ")", ",", "PublicKey", ":", "keybase1", ".", "ED25519PublicKey", "(", "publicKey", ")", ",", "}", "\n", "return", "\n", "}" ]

[ "SignED25519", "signs", "the", "given", "message", "with", "the", "current", "user", "s", "private", "signing", "key", "." ]

[ "func", "SignED25519ForKBFS", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "getSecretUI", "func", "(", ")", "libkb", ".", "SecretUI", ",", "arg", "keybase1", ".", "SignED25519ForKBFSArg", ")", "(", "ret", "keybase1", ".", "ED25519SignatureInfo", ",", "err", "error", ")", "{", "signingKey", ",", "err", ":=", "GetMySecretKey", "(", "ctx", ",", "g", ",", "getSecretUI", ",", "libkb", ".", "DeviceSigningKeyType", ",", "arg", ".", "Reason", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "kp", ",", "ok", ":=", "signingKey", ".", "(", "libkb", ".", "NaclSigningKeyPair", ")", "\n", "if", "!", "ok", "||", "kp", ".", "Private", "==", "nil", "{", "err", "=", "libkb", ".", "KeyCannotSignError", "{", "}", "\n", "return", "\n", "}", "\n\n", "var", "sigInfo", "kbcrypto", ".", "NaclSigInfo", "\n", "sigInfo", ",", "err", "=", "kp", ".", "SignV2", "(", "arg", ".", "Msg", ",", "kbcrypto", ".", "SignaturePrefixKBFS", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "publicKey", ":=", "kp", ".", "Public", "\n", "ret", "=", "keybase1", ".", "ED25519SignatureInfo", "{", "Sig", ":", "keybase1", ".", "ED25519Signature", "(", "sigInfo", ".", "Sig", ")", ",", "PublicKey", ":", "keybase1", ".", "ED25519PublicKey", "(", "publicKey", ")", ",", "}", "\n", "return", "\n", "}" ]

[ "SignED25519ForKBFS", "signs", "the", "given", "message", "with", "the", "current", "user", "s", "private", "signing", "key", "on", "behalf", "of", "KBFS", "." ]

[ "func", "SignToString", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "getSecretUI", "func", "(", ")", "libkb", ".", "SecretUI", ",", "arg", "keybase1", ".", "SignToStringArg", ")", "(", "sig", "string", ",", "err", "error", ")", "{", "signingKey", ",", "err", ":=", "GetMySecretKey", "(", "ctx", ",", "g", ",", "getSecretUI", ",", "libkb", ".", "DeviceSigningKeyType", ",", "arg", ".", "Reason", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "kp", ",", "ok", ":=", "signingKey", ".", "(", "libkb", ".", "NaclSigningKeyPair", ")", "\n", "if", "!", "ok", "||", "kp", ".", "Private", "==", "nil", "{", "err", "=", "libkb", ".", "KeyCannotSignError", "{", "}", "\n", "return", "\n", "}", "\n\n", "sig", ",", "_", ",", "err", "=", "kp", ".", "SignToString", "(", "arg", ".", "Msg", ")", "\n", "return", "\n", "}" ]

[ "SignToString", "signs", "the", "given", "message", "with", "the", "current", "user", "s", "private", "signing", "key", "and", "outputs", "the", "serialized", "NaclSigInfo", "string", "." ]

[ "func", "UnboxBytes32", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "getSecretUI", "func", "(", ")", "libkb", ".", "SecretUI", ",", "arg", "keybase1", ".", "UnboxBytes32Arg", ")", "(", "bytes32", "keybase1", ".", "Bytes32", ",", "err", "error", ")", "{", "encryptionKey", ",", "err", ":=", "GetMySecretKey", "(", "ctx", ",", "g", ",", "getSecretUI", ",", "libkb", ".", "DeviceEncryptionKeyType", ",", "arg", ".", "Reason", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "return", "unboxBytes32", "(", "encryptionKey", ",", "arg", ".", "EncryptedBytes32", ",", "arg", ".", "Nonce", ",", "arg", ".", "PeersPublicKey", ")", "\n", "}" ]

[ "UnboxBytes32", "decrypts", "the", "given", "message", "with", "the", "current", "user", "s", "private", "encryption", "key", "and", "the", "given", "nonce", "and", "peer", "public", "key", "." ]

[ "func", "matchingCachedKey", "(", "m", "libkb", ".", "MetaContext", ",", "arg", "keybase1", ".", "UnboxBytes32AnyArg", ")", "(", "key", "libkb", ".", "GenericKey", ",", "index", "int", ",", "err", "error", ")", "{", "// check device key first", "dkey", ",", "err", ":=", "m", ".", "ActiveDevice", "(", ")", ".", "EncryptionKey", "(", ")", "\n", "if", "err", "==", "nil", "&&", "dkey", "!=", "nil", "{", "if", "n", ",", "ok", ":=", "kidMatch", "(", "dkey", ",", "arg", ".", "Bundles", ")", ";", "ok", "{", "return", "dkey", ",", "n", ",", "nil", "\n", "}", "\n", "}", "\n\n", "device", ":=", "m", ".", "ActiveDevice", "(", ")", ".", "ProvisioningKey", "(", "m", ")", "\n", "if", "device", "!=", "nil", "{", "pkey", ":=", "device", ".", "EncryptionKey", "(", ")", "\n", "if", "n", ",", "ok", ":=", "kidMatch", "(", "pkey", ",", "arg", ".", "Bundles", ")", ";", "ok", "{", "return", "pkey", ",", "n", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "0", ",", "nil", "\n", "}" ]

[ "check", "cached", "keys", "for", "arg", ".", "Bundles", "match", "." ]

[ "func", "matchingDeviceKey", "(", "m", "libkb", ".", "MetaContext", ",", "secretUI", "libkb", ".", "SecretUI", ",", "arg", "keybase1", ".", "UnboxBytes32AnyArg", ",", "me", "*", "libkb", ".", "User", ")", "(", "key", "libkb", ".", "GenericKey", ",", "index", "int", ",", "err", "error", ")", "{", "ekey", ",", "err", ":=", "me", ".", "GetDeviceSubkey", "(", ")", "\n", "if", "err", "==", "nil", "{", "if", "n", ",", "ok", ":=", "kidMatch", "(", "ekey", ",", "arg", ".", "Bundles", ")", ";", "ok", "{", "// unlock this key", "parg", ":=", "libkb", ".", "SecretKeyPromptArg", "{", "Ska", ":", "libkb", ".", "SecretKeyArg", "{", "Me", ":", "me", ",", "KeyType", ":", "libkb", ".", "DeviceEncryptionKeyType", ",", "}", ",", "SecretUI", ":", "secretUI", ",", "Reason", ":", "arg", ".", "Reason", ",", "UseCancelCache", ":", "true", ",", "}", "\n", "key", ",", "err", ":=", "m", ".", "G", "(", ")", ".", "Keyrings", ".", "GetSecretKeyWithPrompt", "(", "m", ",", "parg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n", "return", "key", ",", "n", ",", "nil", "\n", "}", "\n\n", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "logNoMatch", "(", "m", ",", "ekey", ",", "arg", ".", "Bundles", ")", "\n", "}", "else", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", ",", "0", ",", "nil", "\n", "}" ]

[ "check", "device", "key", "for", "arg", ".", "Bundles", "match", "." ]

[ "func", "matchingPaperKey", "(", "m", "libkb", ".", "MetaContext", ",", "secretUI", "libkb", ".", "SecretUI", ",", "arg", "keybase1", ".", "UnboxBytes32AnyArg", ",", "me", "*", "libkb", ".", "User", ")", "(", "key", "libkb", ".", "GenericKey", ",", "index", "int", ",", "err", "error", ")", "{", "cki", ":=", "me", ".", "GetComputedKeyInfos", "(", ")", "\n", "if", "cki", "==", "nil", "{", "return", "nil", ",", "0", ",", "nil", "\n", "}", "\n", "var", "matchingPaper", "[", "]", "*", "libkb", ".", "Device", "\n", "for", "_", ",", "pdev", ":=", "range", "cki", ".", "PaperDevices", "(", ")", "{", "enckey", ",", "err", ":=", "me", ".", "GetComputedKeyFamily", "(", ")", ".", "GetEncryptionSubkeyForDevice", "(", "pdev", ".", "ID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "kidMatch", "(", "enckey", ",", "arg", ".", "Bundles", ")", ";", "ok", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "*", "pdev", ".", "Description", ")", "\n", "matchingPaper", "=", "append", "(", "matchingPaper", ",", "pdev", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "matchingPaper", ")", "==", "0", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "0", ",", "nil", "\n", "}", "\n\n", "phrase", ",", "err", ":=", "libkb", ".", "GetPaperKeyForCryptoPassphrase", "(", "m", ",", "secretUI", ",", "arg", ".", "Reason", ",", "matchingPaper", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n", "paperPhrase", ",", "err", ":=", "libkb", ".", "NewPaperKeyPhraseCheckVersion", "(", "m", ",", "phrase", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n\n", "bkarg", ":=", "&", "PaperKeyGenArg", "{", "Passphrase", ":", "paperPhrase", ",", "SkipPush", ":", "true", ",", "}", "\n", "bkeng", ":=", "NewPaperKeyGen", "(", "m", ".", "G", "(", ")", ",", "bkarg", ")", "\n", "if", "err", ":=", "RunEngine2", "(", "m", ",", "bkeng", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n\n", "// find the index for the key they entered (and make sure the key they entered matches)", "if", "n", ",", "ok", ":=", "kidMatch", "(", "bkeng", ".", "EncKey", "(", ")", ",", "arg", ".", "Bundles", ")", ";", "ok", "{", "m", ".", "ActiveDevice", "(", ")", ".", "CacheProvisioningKey", "(", "m", ",", "bkeng", ".", "DeviceWithKeys", "(", ")", ")", "\n", "return", "bkeng", ".", "EncKey", "(", ")", ",", "n", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "0", ",", "nil", "\n", "}" ]

[ "check", "all", "the", "user", "s", "paper", "keys", "for", "arg", ".", "Bundles", "match" ]

[ "func", "NewCrypto", "(", "g", "*", "libkb", ".", "GlobalContext", ")", "*", "Crypto", "{", "return", "&", "Crypto", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewCrypto", "returns", "a", "Crypto", "object", "." ]

[ "func", "(", "c", "*", "Crypto", ")", "Box", "(", "ctx", "context", ".", "Context", ",", "plaintext", "[", "]", "byte", ",", "teamSpec", "keybase1", ".", "TeamIDWithVisibility", ")", "(", "*", "keybase1", ".", "EncryptedGitMetadata", ",", "error", ")", "{", "team", ",", "err", ":=", "c", ".", "loadTeam", "(", "ctx", ",", "teamSpec", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "public", ":=", "teamSpec", ".", "Visibility", "==", "keybase1", ".", "TLFVisibility_PUBLIC", "\n\n", "key", ":=", "publicCryptKey", "\n", "if", "!", "public", "{", "key", ",", "err", "=", "team", ".", "GitMetadataKey", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "nonce", ",", "err", ":=", "libkb", ".", "RandomNaclDHNonce", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "encKey", "[", "libkb", ".", "NaclSecretBoxKeySize", "]", "byte", "=", "key", ".", "Key", "\n", "sealed", ":=", "secretbox", ".", "Seal", "(", "nil", ",", "plaintext", ",", "&", "nonce", ",", "&", "encKey", ")", "\n\n", "return", "&", "keybase1", ".", "EncryptedGitMetadata", "{", "V", ":", "libkb", ".", "CurrentGitMetadataEncryptionVersion", ",", "E", ":", "sealed", ",", "N", ":", "nonce", ",", "Gen", ":", "key", ".", "KeyGeneration", ",", "}", ",", "nil", "\n", "}" ]

[ "Box", "encrypts", "the", "plaintext", "with", "the", "most", "current", "key", "for", "the", "given", "team", ".", "It", "yields", "a", "NaCl", "ciphertext", "and", "nonce", "and", "also", "says", "which", "generation", "of", "the", "key", "it", "used", "." ]

[ "func", "(", "c", "*", "Crypto", ")", "Unbox", "(", "ctx", "context", ".", "Context", ",", "teamSpec", "keybase1", ".", "TeamIDWithVisibility", ",", "metadata", "*", "keybase1", ".", "EncryptedGitMetadata", ")", "(", "plaintext", "[", "]", "byte", ",", "err", "error", ")", "{", "defer", "c", ".", "G", "(", ")", ".", "CTrace", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "teamSpec", ".", "TeamID", ",", "teamSpec", ".", "Visibility", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "if", "metadata", ".", "V", "!=", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "metadata", ".", "V", ")", "\n", "}", "\n\n", "public", ":=", "teamSpec", ".", "Visibility", "==", "keybase1", ".", "TLFVisibility_PUBLIC", "\n\n", "var", "needKeyGeneration", "keybase1", ".", "PerTeamKeyGeneration", "\n", "if", "!", "public", "{", "needKeyGeneration", "=", "metadata", ".", "Gen", "\n", "}", "\n", "team", ",", "err", ":=", "c", ".", "loadTeam", "(", "ctx", ",", "teamSpec", ",", "needKeyGeneration", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "key", ":=", "publicCryptKey", "\n", "if", "!", "public", "{", "key", ",", "err", "=", "team", ".", "ApplicationKeyAtGeneration", "(", "ctx", ",", "keybase1", ".", "TeamApplication_GIT_METADATA", ",", "metadata", ".", "Gen", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "var", "encKey", "[", "libkb", ".", "NaclSecretBoxKeySize", "]", "byte", "=", "key", ".", "Key", "\n", "var", "naclNonce", "[", "libkb", ".", "NaclDHNonceSize", "]", "byte", "=", "metadata", ".", "N", "\n\n", "plaintext", ",", "ok", ":=", "secretbox", ".", "Open", "(", "nil", ",", "metadata", ".", "E", ",", "&", "naclNonce", ",", "&", "encKey", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "libkb", ".", "DecryptOpenError", "{", "}", "\n", "}", "\n", "return", "plaintext", ",", "nil", "\n", "}" ]

[ "Unbox", "decrypts", "the", "given", "ciphertext", "with", "the", "given", "nonce", "for", "the", "given", "generation", "of", "the", "given", "team", ".", "Can", "return", "an", "error", ".", "Will", "return", "a", "non", "-", "nil", "plaintext", "on", "success", "." ]

[ "func", "NewBackgroundTask", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "args", "*", "BackgroundTaskArgs", ")", "*", "BackgroundTask", "{", "return", "&", "BackgroundTask", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "args", ":", "args", ",", "shutdownFunc", ":", "nil", ",", "}", "\n", "}" ]

[ "NewBackgroundTask", "creates", "a", "BackgroundTask", "engine", "." ]

[ "func", "(", "e", "*", "BackgroundTask", ")", "Name", "(", ")", "string", "{", "if", "e", ".", "args", "!=", "nil", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "e", ".", "args", ".", "Name", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "Name", "is", "the", "unique", "engine", "name", "." ]

[ "func", "(", "id", "BranchID", ")", "MarshalBinary", "(", ")", "(", "data", "[", "]", "byte", ",", "err", "error", ")", "{", "return", "id", ".", "id", "[", ":", "]", ",", "nil", "\n", "}" ]

[ "MarshalBinary", "implements", "the", "encoding", ".", "BinaryMarshaler", "interface", "for", "BranchID", "." ]

[ "func", "(", "id", "*", "BranchID", ")", "UnmarshalBinary", "(", "data", "[", "]", "byte", ")", "error", "{", "if", "len", "(", "data", ")", "!=", "BranchIDByteLen", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "copy", "(", "id", ".", "id", "[", ":", "]", ",", "data", ")", "\n", "return", "nil", "\n", "}" ]

[ "UnmarshalBinary", "implements", "the", "encoding", ".", "BinaryUnmarshaler", "interface", "for", "BranchID", "." ]

[ "func", "ParseBranchID", "(", "s", "string", ")", "(", "BranchID", ",", "error", ")", "{", "if", "len", "(", "s", ")", "!=", "BranchIDStringLen", "{", "return", "NullBranchID", ",", "InvalidBranchID", "{", "s", "}", "\n", "}", "\n", "bytes", ",", "err", ":=", "hex", ".", "DecodeString", "(", "s", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NullBranchID", ",", "InvalidBranchID", "{", "s", "}", "\n", "}", "\n", "var", "id", "BranchID", "\n", "err", "=", "id", ".", "UnmarshalBinary", "(", "bytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NullBranchID", ",", "InvalidBranchID", "{", "s", "}", "\n", "}", "\n", "return", "id", ",", "nil", "\n", "}" ]

[ "ParseBranchID", "parses", "a", "hex", "encoded", "BranchID", ".", "Returns", "NullBranchID", "and", "an", "InvalidBranchID", "on", "falire", "." ]

[ "func", "MakeRandomBranchID", "(", ")", "(", "BranchID", ",", "error", ")", "{", "var", "id", "BranchID", "\n", "// Loop just in case we randomly pick the null or local squash", "// branch IDs.", "for", "id", "==", "NullBranchID", "||", "id", "==", "PendingLocalSquashBranchID", "{", "err", ":=", "kbfscrypto", ".", "RandRead", "(", "id", ".", "id", "[", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "BranchID", "{", "}", ",", "err", "\n", "}", "\n", "}", "\n", "return", "id", ",", "nil", "\n", "}" ]

[ "MakeRandomBranchID", "generates", "a", "per", "-", "device", "branch", "ID", "using", "a", "CSPRNG", ".", "It", "will", "not", "return", "LocalSquashBranchID", "or", "NullBranchID", "." ]

[ "func", "FakeBranchID", "(", "b", "byte", ")", "BranchID", "{", "bytes", ":=", "[", "BranchIDByteLen", "]", "byte", "{", "b", "}", "\n", "return", "BranchID", "{", "bytes", "}", "\n", "}" ]

[ "FakeBranchID", "creates", "a", "fake", "branch", "ID", "from", "the", "given", "byte", "." ]

[ "func", "NewRetryAPIArg", "(", "endpoint", "string", ")", "APIArg", "{", "return", "APIArg", "{", "Endpoint", ":", "endpoint", ",", "InitialTimeout", ":", "HTTPRetryInitialTimeout", ",", "RetryMultiplier", ":", "HTTPRetryMutliplier", ",", "RetryCount", ":", "HTTPRetryCount", ",", "}", "\n", "}" ]

[ "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", "." ]

[ "func", "ShouldCreate", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ")", "(", "res", "ShouldCreateResult", ",", "err", "error", ")", "{", "mctx", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "g", ")", "\n", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "defer", "func", "(", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "res", ",", "err", "!=", "nil", ")", "\n", "}", "(", ")", "\n", "arg", ":=", "libkb", ".", "NewAPIArg", "(", "\"", "\"", ")", "\n", "arg", ".", "RetryCount", "=", "3", "\n", "arg", ".", "SessionType", "=", "libkb", ".", "APISessionTypeREQUIRED", "\n", "var", "apiRes", "shouldCreateRes", "\n", "err", "=", "mctx", ".", "G", "(", ")", ".", "API", ".", "GetDecode", "(", "mctx", ",", "arg", ",", "&", "apiRes", ")", "\n", "return", "apiRes", ".", "ShouldCreateResult", ",", "err", "\n", "}" ]

[ "ShouldCreate", "asks", "the", "server", "whether", "to", "create", "this", "user", "s", "initial", "wallet", "." ]

[ "func", "PostWithChainlink", "(", "mctx", "libkb", ".", "MetaContext", ",", "clearBundle", "stellar1", ".", "Bundle", ")", "(", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "uid", ":=", "mctx", ".", "G", "(", ")", ".", "ActiveDevice", ".", "UID", "(", ")", "\n", "if", "uid", ".", "IsNil", "(", ")", "{", "return", "libkb", ".", "NoUIDError", "{", "}", "\n", "}", "\n", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "loadMeArg", ":=", "libkb", ".", "NewLoadUserArg", "(", "mctx", ".", "G", "(", ")", ")", ".", "WithNetContext", "(", "mctx", ".", "Ctx", "(", ")", ")", ".", "WithUID", "(", "uid", ")", ".", "WithSelf", "(", "true", ")", ".", "WithPublicKeyOptional", "(", ")", "\n", "me", ",", "err", ":=", "libkb", ".", "LoadUser", "(", "loadMeArg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "deviceSigKey", ",", "err", ":=", "mctx", ".", "G", "(", ")", ".", "ActiveDevice", ".", "SigningKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "pukGen", ",", "pukSeed", ",", "err", ":=", "getLatestPuk", "(", "mctx", ".", "Ctx", "(", ")", ",", "mctx", ".", "G", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "payload", ",", "seqno", ",", "linkID", ",", "err", ":=", "buildChainLinkPayload", "(", "mctx", ",", "clearBundle", ",", "me", ",", "pukGen", ",", "pukSeed", ",", "deviceSigKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "_", ",", "err", "=", "mctx", ".", "G", "(", ")", ".", "API", ".", "PostJSON", "(", "mctx", ",", "libkb", ".", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "SessionType", ":", "libkb", ".", "APISessionTypeREQUIRED", ",", "JSONPayload", ":", "*", "payload", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", "=", "libkb", ".", "MerkleCheckPostedUserSig", "(", "mctx", ",", "uid", ",", "seqno", ",", "linkID", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "mctx", ".", "G", "(", ")", ".", "UserChanged", "(", "mctx", ".", "Ctx", "(", ")", ",", "uid", ")", "\n", "return", "nil", "\n", "}" ]

[ "Post", "a", "bundle", "to", "the", "server", "with", "a", "chainlink", "." ]