id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c161500 | err = k.delegate.CreateTeamTLF(ctx, teamID, tlfID)
})
return err
} | |
c161501 | {
settings, err = k.delegate.GetTeamSettings(ctx, teamID, offline)
})
return settings, err
} | |
c161502 | root, updateTime, err = k.delegate.GetCurrentMerkleRoot(ctx)
})
return root, updateTime, err
} | |
c161503 |
k.verifyMerkleRootTimer.Time(func() {
err = k.delegate.VerifyMerkleRoot(ctx, root, kbfsRoot)
})
return err
} | |
c161504 | err = k.delegate.CurrentSession(ctx, sessionID)
})
return sessionInfo, err
} | |
c161505 | (err error) {
k.favoriteAddTimer.Time(func() {
err = k.delegate.FavoriteAdd(ctx, folder)
})
return err
} | |
c161506 | (err error) {
k.favoriteDeleteTimer.Time(func() {
err = k.delegate.FavoriteDelete(ctx, folder)
})
return err
} | |
c161507 | err error) {
k.favoriteListTimer.Time(func() {
favorites, err = k.delegate.FavoriteList(ctx, sessionID)
})
return favorites, err
} | |
c161508 | dataOut, err = k.delegate.EncryptFavorites(ctx, dataIn)
})
return dataOut, err
} | |
c161509 | err = k.delegate.NotifyOnlineStatusChanged(ctx, online)
})
return err
} | |
c161510 | (err error) {
k.notifyTimer.Time(func() {
err = k.delegate.Notify(ctx, notification)
})
return err
} | |
c161511 | (err error) {
k.notifyPathUpdatedTimer.Time(func() {
err = k.delegate.NotifyPathUpdated(ctx, path)
})
return err
} | |
c161512 | (err error) {
k.notifyTimer.Time(func() {
err = k.delegate.NotifySyncStatus(ctx, status)
})
return err
} | |
c161513 | (err error) {
k.notifyTimer.Time(func() {
err = k.delegate.NotifyOverallSyncStatus(ctx, status)
})
return err
} | |
c161514 |
k.delegate.FlushUserFromLocalCache(ctx, uid)
} | |
c161515 | context.Context) {
k.delegate.ClearCaches(ctx)
} | |
c161516 |
return k.delegate.EstablishMountDir(ctx)
} | |
c161517 |
metadata keybase1.GitLocalMetadata) (err error) {
k.putGitMetadataTimer.Time(func() {
err = k.delegate.PutGitMetadata(ctx, folder, repoID, metadata)
})
return err
} | |
c161518 | kbCtx,
config: config,
kbfsInitParams: kbfsInitParams,
log: config.MakeLogger(""),
}, shutdown
} | |
c161519 | ctx, arg.Folder)
if err != nil {
return "", err
}
defer func() {
rmErr := os.RemoveAll(tempDir)
if rmErr != nil {
rh.log.CDebugf(
ctx, "Error cleaning storage dir %s: %+v\n", tempDir, rmErr)
}
}()
defer gitConfig.Shutdown(ctx)
ctx = context.WithValue(ctx, libkbfs.CtxAllowNameKey, kbfsRepoDir)
gi... | |
c161520 | {
rh.log.CDebugf(
ctx, "Error cleaning storage dir %s: %+v\n", tempDir, rmErr)
}
}()
defer gitConfig.Shutdown(ctx)
err = DeleteRepo(ctx, gitConfig, tlfHandle, string(arg.Name))
if err != nil {
return err
}
err = rh.waitForJournal(ctx, gitConfig, tlfHandle)
if err != nil {
return err
}
rh.sched... | |
c161521 | nil {
return err
}
defer func() {
rmErr := os.RemoveAll(tempDir)
if rmErr != nil {
rh.log.CDebugf(
ctx, "Error cleaning storage dir %s: %+v\n", tempDir, rmErr)
}
}()
defer gitConfig.Shutdown(ctx)
gco := GCOptions{
MaxLooseRefs: arg.Options.MaxLooseRefs,
PruneMinLooseObjects: arg.Option... | |
c161522 |
if s == nil {
return nil
}
s.Lock()
defer s.Unlock()
return s.passphraseStream.Clone()
} | |
c161523 | hasPaperKey,
}
}
// We ensured above that the user has a PUK, so the loop below will be executed at least once
maxGen := -1
var lk keybase1.KID
for _, k := range upk.PerUserKeys {
if k.Gen > maxGen {
maxGen = k.Gen
lk = k.EncKID
}
}
if lk == "" {
panic("This should never happen, user has a PUK wi... | |
c161524 | 1000
}
suffix = string(c)
} else if v%1024 == 0 {
for i := 0; v%1024 == 0 && i < len(units); i++ {
c = units[i]
v /= 1024
}
suffix = string(c) + "i"
}
return fmt.Sprintf("%d%s", v, suffix)
} | |
c161525 | mult, found := sizeFlagMap[strings.ToLower(raw[i:])]
if !found {
return fmt.Errorf("Invalid syntax: %q, supported syntax is 0-9+(k|m|g|t)[i]", raw)
}
*sf.v = val * mult
return nil
} | |
c161526 |
return &PGPKeyfinder{
arg: arg,
Contextified: libkb.NewContextified(g),
}
} | |
c161527 | user, err := libkb.LoadUser(arg)
if err != nil {
e.runerr = err
return
}
e.addUser(user, false)
}
} | |
c161528 | }
return &UntrackEngine{
arg: arg,
Contextified: libkb.NewContextified(g),
}
} | |
c161529 | := &Auditor{}
ret.newLRU(libkb.NewMetaContextBackground(g))
return ret
} | |
c161530 | audit disabled")
g.SetTeamAuditor(dummyAuditor{})
} else {
a := NewAuditor(g)
g.SetTeamAuditor(a)
g.AddLogoutHook(a, "team auditor")
g.AddDbNukeHook(a, "team auditor")
}
} | |
c161531 | 0, nil
}
for _, tuple := range probeTuples {
m.Debug("preProbe: checking probe at merkle %d", tuple.merkle)
if tuple.team != keybase1.Seqno(0) || !tuple.linkID.IsNil() {
return 0, NewAuditError("merkle root at %v should have been nil for %v; got %s/%d",
tuple.merkle, history.ID, tuple.linkID, tuple.team)
... | |
c161532 | }
// Return all errors if a session is required.
if !sessionNotRequired {
return SessionInfo{}, err
}
// If not logged in, return empty session.
if _, notLoggedIn := err.(NoCurrentSessionError); notLoggedIn {
return SessionInfo{}, nil
}
// Otherwise, just return the error.
return SessionInfo{}, err
} | |
c161533 | verifyingKey := kbfscrypto.MakeVerifyingKey(deviceSibkey.GetKID())
return SessionInfo{
Name: kbname.NewNormalizedUsername(session.Username),
UID: keybase1.UID(session.Uid),
CryptPublicKey: cryptPublicKey,
VerifyingKey: verifyingKey,
}, nil
} | |
c161534 | = m.m.Size()
}
return m.size
} | |
c161535 |
return NewLoginWithUserSwitch(g, deviceType, username, ct, false)
} | |
c161536 | m.Debug("notProvisioned, not handling error %s (err type: %T)", err, err)
return false
} | |
c161537 | make(map[Measurable]memoizedMeasurable),
}
} | |
c161538 | 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()
}
}
},
}
return c
} | |
c161539 |
data, isRel, err := libfs.FileDataFromRelativeTimeString(
ctx, fs.config, handle, filename)
if err != nil {
return nil, time.Time{}, err
}
if !isRel {
panic("ArchiveRelTimeFile should only be used with " +
"reltime file names")
}
return data, time.Time{}, nil
},
}
} | |
c161540 | "WARNING: dropping log messages destined for %q due to full log buffer\n", q.name)
default:
}
} | |
c161541 | format: "Service log messages were dropped due to full buffer",
}
default:
}
} | |
c161542 | 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)
return ib.Convs, err
} | |
c161543 | c.Cli.Call(ctx, "keybase.1.login.getConfiguredAccounts", []interface{}{__arg}, &res)
return
} | |
c161544 | = c.Cli.Call(ctx, "keybase.1.login.login", []interface{}{__arg}, nil)
return
} | |
c161545 | (err error) {
err = c.Cli.Call(ctx, "keybase.1.login.loginProvisionedDevice", []interface{}{__arg}, nil)
return
} | |
c161546 | := LoginWithPaperKeyArg{SessionID: sessionID}
err = c.Cli.Call(ctx, "keybase.1.login.loginWithPaperKey", []interface{}{__arg}, nil)
return
} | |
c161547 | := PaperKeyArg{SessionID: sessionID}
err = c.Cli.Call(ctx, "keybase.1.login.paperKey", []interface{}{__arg}, nil)
return
} | |
c161548 | (err error) {
err = c.Cli.Call(ctx, "keybase.1.login.paperKeySubmit", []interface{}{__arg}, nil)
return
} | |
c161549 | := UnlockArg{SessionID: sessionID}
err = c.Cli.Call(ctx, "keybase.1.login.unlock", []interface{}{__arg}, nil)
return
} | |
c161550 | (err error) {
err = c.Cli.Call(ctx, "keybase.1.login.loginOneshot", []interface{}{__arg}, nil)
return
} | |
c161551 | calling NetworkOptions: %s", err)
} else {
mctx.Debug("updating NetworkOptions: %+v", options)
o.network = options
o.mtime = time.Now()
}
return o.network
} | |
c161552 | switch kp := kp.(type) {
case *keypair.FromAddress:
return "", "", nil, errors.New("unexpected Stellar account ID, expected secret key")
case *keypair.Full:
return stellar1.SecretKey(kp.Seed()), stellar1.AccountID(kp.Address()), kp, nil
default:
return "", "", nil, fmt.Errorf("invalid Stellar secret key")
}
... | |
c161553 | {
case *keypair.FromAddress:
return stellar1.AccountID(kp.Address()), nil
case *keypair.Full:
return "", NewInvalidStellarAccountIDError("unexpected Stellar secret key, expected account ID")
default:
return "", NewInvalidStellarAccountIDError("invalid keypair type")
}
} | |
c161554 | newProc, err = install.AutoInstall(g, "", false, 10*time.Second, g.Log)
if err != nil {
return err
}
} else {
// If this command warrants an autofork, do it now.
if fc == libcmdline.ForceFork || g.Env.GetAutoFork() {
newProc, err = client.AutoForkServer(g, cl)
if err != nil {
return err
}
}... | |
c161555 | only runs on the client
return nil
}
return client.SendPath(g)
} | |
c161556 |
return fmt.Errorf("%s (code %d)", ase.Desc, ase.Code)
}
return e
} | |
c161557 | (
*KeyServerLocal, error) {
return newKeyServerLocal(config, log, storage.NewMemStorage(), nil)
} | |
c161558 | dirPath string) (
*KeyServerLocal, error) {
return newKeyServerDisk(config, log, dirPath, nil)
} | |
c161559 | func(log logger.Logger) {
err := ioutil.RemoveAll(tempdir)
if err != nil {
log.Warning("error removing %s: %s", tempdir, err)
}
})
} | |
c161560 | kbfscrypto.TLFCryptKeyServerHalf{}, err
}
session, err := ks.config.KBPKI().GetCurrentSession(ctx)
if err != nil {
return kbfscrypto.TLFCryptKeyServerHalf{}, err
}
err = kbfscrypto.VerifyTLFCryptKeyServerHalfID(
serverHalfID, session.UID, key, serverHalf)
if err != nil {
ks.log.CDebugf(ctx, "error verify... | |
c161561 | buf, err := ks.config.Codec().Encode(serverHalf)
if err != nil {
return err
}
id, err := kbfscrypto.MakeTLFCryptKeyServerHalfID(
uid, deviceKey, serverHalf)
if err != nil {
return err
}
batch.Put(id.ID.Bytes(), buf)
}
}
return ks.db.Write(batch, nil)
} | |
c161562 | *ks.shutdown {
return errors.New("Key server already shut down")
}
// TODO: verify that the kid is really valid for the given uid
return ks.db.Delete(serverHalfID.ID.Bytes(), nil)
} | |
c161563 | *KeyServerLocal {
return &KeyServerLocal{
config, ks.db, log, ks.shutdownLock, ks.shutdown, ks.shutdownFunc}
} | |
c161564 |
ks.db.Close()
}
if ks.shutdownFunc != nil {
ks.shutdownFunc(ks.log)
}
} | |
c161565 | root's *accessControlV1 as the last resort.
ac := c.getAccessControl(nil, p)
permissions = ac.anonymous
if ac.whitelistAdditional == nil || username == nil {
return permissions, ac.maxPermission, ac.p
}
if perms, ok := ac.whitelistAdditional[*username]; ok {
permissions.read = perms.read || permissions.read
... | |
c161566 | "apps. The \"hacky stuff\" includes a Trash implementation that only "+
"works for the user's own private TLF, so if you enable this please "+
"only work under your own private TLF.")
return ¶ms
} | |
c161567 | "keybase.1.provisionUi.switchToGPGSignOK", []interface{}{__arg}, &res)
return
} | |
c161568 | := DisplaySecretExchangedArg{SessionID: sessionID}
err = c.Cli.Call(ctx, "keybase.1.provisionUi.DisplaySecretExchanged", []interface{}{__arg}, nil)
return
} | |
c161569 | "keybase.1.provisionUi.PromptNewDeviceName", []interface{}{__arg}, &res)
return
} | |
c161570 | (err error) {
err = c.Cli.Call(ctx, "keybase.1.provisionUi.ProvisioneeSuccess", []interface{}{__arg}, nil)
return
} | |
c161571 | (err error) {
err = c.Cli.Call(ctx, "keybase.1.provisionUi.ProvisionerSuccess", []interface{}{__arg}, nil)
return
} | |
c161572 | len(data) {
return fmt.Errorf("Did not consume entire buffer: %d byte(s) left", len(data)-decoder.NumBytesRead())
}
return nil
} | |
c161573 | := enc.Encode(input)
if err != nil {
return [32]byte{}, err
}
mac := hmac.New(sha256.New, info.HmacKey[:])
mac.Write(buf)
hmac := MakeByte32(mac.Sum(nil))
return hmac, nil
} | |
c161574 |
}
// Validate the response
if len(res.TlfPseudonyms) != len(pnyms) {
return nil, &PseudonymGetError{fmt.Sprintf("invalid server response for pseudonym get: len %v != %v",
len(res.TlfPseudonyms), len(pnyms))}
}
var resList []GetTlfPseudonymEither
for i, received := range res.TlfPseudonyms {
resList = appe... | |
c161575 | info.Application,
KeyGen: info.KeyGen,
}
mh := codec.MsgpackHandle{WriteExt: true}
var buf []byte
enc := codec.NewEncoderBytes(&buf, &mh)
if err := enc.Encode(input); err != nil {
return [32]byte{}, err
}
mac := hmac.New(sha256.New, info.Nonce[:])
mac.Write(buf)
hmac := MakeByte32(mac.Sum(nil))
ret... | |
c161576 | pnymReqs = append(pnymReqs, keyPseudonymReq{
Pseudonym: pnym,
ID: info.ID,
Application: int(info.Application),
KeyGen: int(info.KeyGen),
Nonce: info.Nonce,
})
}
payload := make(JSONPayload)
payload["key_pseudonyms"] = pnymReqs
_, err = m.G().API.PostJSON(m, APIArg{
Endpoi... | |
c161577 | response
if len(res.KeyPseudonyms) != len(pnyms) {
return nil, &KeyPseudonymGetError{fmt.Sprintf("invalid server response for pseudonym get: len %v != %v",
len(res.KeyPseudonyms), len(pnyms))}
}
var resList []KeyPseudonymOrError
for i, received := range res.KeyPseudonyms {
resList = append(resList, checkAnd... | |
c161578 | panic(err)
}
return KeyPseudonymNonce(MakeByte32(slice))
} | |
c161579 | type %s in ActiveDevice, returning LoginRequiredError", secretKeyType)
return nil, libkb.LoginRequiredError{Context: "GetMySecretKey"}
}
g.Log.CDebugf(ctx, "GetMySecretKey(%s), unexpected error: %s", secretKeyType, err)
return nil, err
}
return key, nil
} | |
c161580 |
sig := kp.Private.Sign(arg.Msg)
publicKey := kp.Public
ret = keybase1.ED25519SignatureInfo{
Sig: keybase1.ED25519Signature(sig),
PublicKey: keybase1.ED25519PublicKey(publicKey),
}
return
} | |
c161581 | sigInfo, err = kp.SignV2(arg.Msg, kbcrypto.SignaturePrefixKBFS)
if err != nil {
return
}
publicKey := kp.Public
ret = keybase1.ED25519SignatureInfo{
Sig: keybase1.ED25519Signature(sigInfo.Sig),
PublicKey: keybase1.ED25519PublicKey(publicKey),
}
return
} | |
c161582 | ok := signingKey.(libkb.NaclSigningKeyPair)
if !ok || kp.Private == nil {
err = libkb.KeyCannotSignError{}
return
}
sig, _, err = kp.SignToString(arg.Msg)
return
} | |
c161583 | libkb.DeviceEncryptionKeyType, arg.Reason)
if err != nil {
return
}
return unboxBytes32(encryptionKey, arg.EncryptedBytes32, arg.Nonce, arg.PeersPublicKey)
} | |
c161584 | && dkey != nil {
if n, ok := kidMatch(dkey, arg.Bundles); ok {
return dkey, n, nil
}
}
device := m.ActiveDevice().ProvisioningKey(m)
if device != nil {
pkey := device.EncryptionKey()
if n, ok := kidMatch(pkey, arg.Bundles); ok {
return pkey, n, nil
}
}
return nil, 0, nil
} | |
c161585 | != nil {
return nil, 0, err
}
return key, n, nil
}
m.Debug("matchingDeviceKey: no match found for ekey in arg.Bundles")
logNoMatch(m, ekey, arg.Bundles)
} else {
m.Debug("matchingDeviceKey: ignoring error getting device subkey: %s", err)
}
return nil, 0, nil
} | |
c161586 |
bkarg := &PaperKeyGenArg{
Passphrase: paperPhrase,
SkipPush: true,
}
bkeng := NewPaperKeyGen(m.G(), bkarg)
if err := RunEngine2(m, bkeng); err != nil {
return nil, 0, err
}
// find the index for the key they entered (and make sure the key they entered matches)
if n, ok := kidMatch(bkeng.EncKey(), arg.B... | |
c161587 |
Contextified: libkb.NewContextified(g),
}
} | |
c161588 | err != nil {
return nil, err
}
var encKey [libkb.NaclSecretBoxKeySize]byte = key.Key
sealed := secretbox.Seal(nil, plaintext, &nonce, &encKey)
return &keybase1.EncryptedGitMetadata{
V: libkb.CurrentGitMetadataEncryptionVersion,
E: sealed,
N: nonce,
Gen: key.KeyGeneration,
}, nil
} | |
c161589 |
key := publicCryptKey
if !public {
key, err = team.ApplicationKeyAtGeneration(ctx, keybase1.TeamApplication_GIT_METADATA, metadata.Gen)
if err != nil {
return nil, err
}
}
var encKey [libkb.NaclSecretBoxKeySize]byte = key.Key
var naclNonce [libkb.NaclDHNonceSize]byte = metadata.N
plaintext, ok := sec... | |
c161590 | {
return &BackgroundTask{
Contextified: libkb.NewContextified(g),
args: args,
shutdownFunc: nil,
}
} | |
c161591 | fmt.Sprintf("BackgroundTask(%v)", e.args.Name)
}
return "BackgroundTask"
} | |
c161592 | {
return id.id[:], nil
} | |
c161593 | return errors.New("invalid BranchID")
}
copy(id.id[:], data)
return nil
} | |
c161594 |
err = id.UnmarshalBinary(bytes)
if err != nil {
return NullBranchID, InvalidBranchID{s}
}
return id, nil
} | |
c161595 | kbfscrypto.RandRead(id.id[:])
if err != nil {
return BranchID{}, err
}
}
return id, nil
} | |
c161596 | := [BranchIDByteLen]byte{b}
return BranchID{bytes}
} | |
c161597 |
InitialTimeout: HTTPRetryInitialTimeout,
RetryMultiplier: HTTPRetryMutliplier,
RetryCount: HTTPRetryCount,
}
} | |
c161598 | arg.RetryCount = 3
arg.SessionType = libkb.APISessionTypeREQUIRED
var apiRes shouldCreateRes
err = mctx.G().API.GetDecode(mctx, arg, &apiRes)
return apiRes.ShouldCreateResult, err
} | |
c161599 |
deviceSigKey, err := mctx.G().ActiveDevice.SigningKey()
if err != nil {
return fmt.Errorf("signing key not found: (%v)", err)
}
pukGen, pukSeed, err := getLatestPuk(mctx.Ctx(), mctx.G())
if err != nil {
return err
}
payload, seqno, linkID, err := buildChainLinkPayload(mctx, clearBundle, me, pukGen, pukSeed... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.