id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c23000 |
events.EventUser: ctx.Identity.TeleportUser,
events.LocalAddr: ctx.Conn.LocalAddr().String(),
events.RemoteAddr: ctx.Conn.RemoteAddr().String(),
})
h.Warnf("Port forwarding request denied: %v.", systemErrorMessage)
return trace.AccessDenied(userErrorMessage)
}
return nil
} | |
c23001 | a Teleport certificate
// authority (CA) or fallback to host key checking if it's allowed.
certChecker := utils.CertChecker{
CertChecker: ssh.CertChecker{
IsHostAuthority: h.IsHostAuthority,
HostKeyFallback: h.hostKeyCallback,
},
}
err := certChecker.CheckHostKey(addr, remote, key)
if err != nil {
ret... | |
c23002 | {
return trace.AccessDenied("remote host presented a public key, expected a host certificate")
}
// If strict host key checking is not enabled, log that Teleport trusted an
// insecure key, but allow the request to go through.
h.Warn("Insecure configuration! Strict host key checking disabled, allowing login wit... | |
c23003 | cert); err != nil {
return false
}
return true
} | |
c23004 | cert); err != nil {
h.Entry.Debugf("Unable to find SSH host CA: %v.", err)
return false
}
return true
} | |
c23005 | if err != nil {
return nil, trace.Wrap(err)
}
} else {
certRoles, err := extractRolesFromCert(cert)
if err != nil {
return nil, trace.AccessDenied("failed to parse certificate roles")
}
roleNames, err := ca.CombinedMapping().Map(certRoles)
if err != nil {
return nil, trace.AccessDenied("failed to... | |
c23006 | // host checkers.
switch v := key.(type) {
case *ssh.Certificate:
if sshutils.KeysEqual(v.SignatureKey, checker) {
ca = cas[i]
break
}
default:
if sshutils.KeysEqual(key, checker) {
ca = cas[i]
break
}
}
}
}
// the certificate was signed by unknown authority
if ca ... | |
c23007 | == teleport.ComponentProxy {
return true
}
return false
} | |
c23008 | if !ok {
// it's ok to not have any roles in the metadata
return nil, nil
}
return services.UnmarshalCertRoles(data)
} | |
c23009 |
}
// look to see if we already have a connection to this cluster
remoteClt, ok := c.getRemoteClient(site.GetName())
if !ok {
rClt, rConn, err := c.newRemoteClient(site)
if err != nil {
return nil, trace.Wrap(err)
}
// add a closer for the underlying connection
if rConn != nil {
c.AddClosers(rConn... | |
c23010 | err != nil {
return nil, nil, trace.Wrap(err)
}
return clt, nil, nil
} | |
c23011 |
return func(in context.Context, network, _ string) (net.Conn, error) {
return remoteCluster.DialAuthServer()
}
} | |
c23012 | services.HostCA,
DomainName: clusterName[0],
}, false)
if err != nil {
return nil, trace.Wrap(err)
}
certPool, err = services.CertPool(certAuthority)
if err != nil {
return nil, trace.Wrap(err)
}
}
tlsConfig := utils.TLSConfig(c.parent.cipherSuites)
tlsCert, err := tls.X509KeyPair(c.sess... | |
c23013 | if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
} | |
c23014 | 0 {
return nil, nil, trace.BadParameter("expected at least valid principal in certificate")
}
privateKey, err := ssh.ParseRawPrivateKey(c.sess.GetPriv())
if err != nil {
return nil, nil, trace.Wrap(err, "failed to parse SSH private key")
}
keyring := agent.NewKeyring()
err = keyring.Add(agent.AddedKey{
Pr... | |
c23015 | closer.Close()
}
if c.clt != nil {
return trace.Wrap(c.clt.Close())
}
return nil
} | |
c23016 | authServers: servers,
closer: utils.NewCloseBroadcaster(),
cipherSuites: cipherSuites,
}
// periodically close expired and unused sessions
go cache.expireSessions()
return cache, nil
} | |
c23017 | return
}
if err := ctx.Close(); err != nil {
log.Infof("failed to close context: %v", err)
}
}()
} | |
c23018 | == 0 {
return nil, trace.AccessDenied(
"list of user teams is empty, did you grant access?")
}
claims := &services.GithubClaims{
Username: user.Login,
OrganizationToTeams: orgToTeams,
}
log.WithFields(logrus.Fields{trace.Component: "github"}).Debugf(
"Claims: %#v.", claims)
return claims, ni... | |
c23019 |
var user userResponse
err = json.Unmarshal(bytes, &user)
if err != nil {
return nil, trace.Wrap(err)
}
return &user, nil
} | |
c23020 | Audit Log.
log.Warnf(warningMessage)
c.authServer.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodGithub,
events.AuthAttemptMessage: warningMessage,
})
return result, nil
}
u, err := url.Parse(nextPage)
if err != nil {
return ni... | |
c23021 | nil, "", trace.AccessDenied("bad response: %v %v",
response.StatusCode, string(bytes))
}
// Parse web links header to extract any pagination links. This is used to
// return the next link which can be used in a loop to pull back all data.
wls := utils.ParseWebLinks(response)
return bytes, wls.NextPage, nil
} | |
c23022 |
return trace.BadParameter("destination address required to connect to remote host")
}
if s.HostCertificate == nil {
return trace.BadParameter("host certificate required to act on behalf of remote host")
}
if s.Clock == nil {
s.Clock = clockwork.NewRealClock()
}
return nil
} | |
c23023 | s.authHandlers = &srv.AuthHandlers{
Entry: logrus.WithFields(logrus.Fields{
trace.Component: teleport.ComponentForwardingNode,
trace.ComponentFields: logrus.Fields{},
}),
Server: s,
Component: teleport.ComponentForwardingNode,
AuditLog: c.AuthClient,
AccessPoint: c.AuthClient,
}
//... | |
c23024 | auditLog.EmitAuditEvent(event, fields); err != nil {
s.log.Error(err)
}
} else {
s.log.Warn("SSH server has no audit log")
}
} | |
c23025 | }
}
// Signal to waiting goroutines that the server is closing (for example,
// the keep alive loop).
s.closeCancel()
return trace.NewAggregate(errs...)
} | |
c23026 | cfg.Token = token
return true
}
return false
} | |
c23027 | cfg.Hostname,
AuthServers: cfg.AuthServers,
Auth: cfg.Auth,
Console: cfg.Console,
}
} | |
c23028 | c.RecentTTL == nil {
return defaults.RecentCacheTTL
}
return *c.RecentTTL
} | |
c23029 | fmt.Sprintf("cache that will expire after connection to database is lost after %v, %v", defaults.CacheTTL, recentCachePolicy)
}
return fmt.Sprintf("cache that will expire after connection to database is lost after %v, %v", c.TTL, recentCachePolicy)
} | |
c23030 | = kex
cfg.MACAlgorithms = macs
// defaults for the auth service:
cfg.Auth.Enabled = true
cfg.Auth.SSHAddr = *defaults.AuthListenAddr()
cfg.Auth.StorageConfig.Type = dir.GetName()
cfg.Auth.StorageConfig.Params = backend.Params{defaults.BackendPath: filepath.Join(cfg.DataDir, defaults.BackendDir)}
cfg.Auth.Stati... | |
c23031 | // If enough keep-alives are missed, the connection is dead, call cancel
// and notify the server to disconnect and cleanup.
missedCount = missedCount + 1
if missedCount > p.MaxCount {
log.Infof("Missed %v keep-alive messages, closing connection.", missedCount)
p.CloseCancel()
return
}
// If ... | |
c23032 |
}()
select {
case err := <-errorCh:
if err != nil {
return false
}
return true
case <-time.After(timeout):
return false
case <-closeContext.Done():
return false
}
} | |
c23033 | prevent unexpected data races
copy := resource
copy.SetResourceID(0)
resource = copy
}
return utils.FastMarshal(resource)
} | |
c23034 | := namespace.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
namespace.Metadata.ID = cfg.ID
}
if !cfg.Expires.IsZero() {
namespace.Metadata.Expires = &cfg.Expires
}
return &namespace, nil
} | |
c23035 | information")
c.diagURL = c.top.Arg("diag-addr", "Diagnostic HTTP URL").Default("http://127.0.0.1:3434").String()
c.refreshPeriod = c.top.Arg("refresh", "Refresh period").Default("5s").Duration()
} | |
c23036 |
lastTab = e.ID
}
// render previously fetched data on the resize event
if re != nil {
if err := c.render(ctx, *re, lastTab); err != nil {
return trace.Wrap(err)
}
}
case <-ticker.C:
// fetch data and re-render on ticker
prev = re
re, err = c.fetchAndGenerateReport(ctx, client, p... | |
c23037 | {
return out[i].Count > out[j].Count
}
return out[i].GetFreq() > out[j].GetFreq()
})
return out
} | |
c23038 | freq := float64(c.Count-prevCount.Count) / float64(period/time.Second)
c.Freq = &freq
} | |
c23039 | }
percentiles = append(percentiles, Percentile{
Percentile: 100 * (float64(bucket.Count) / float64(h.Count)),
Value: time.Duration(bucket.UpperBound * float64(time.Second)),
})
}
return percentiles
} | |
c23040 | %T %v at %v", trace.Unwrap(err), err, string(debug.Stack())))
} | |
c23041 | got %T %v at %v", trace.Unwrap(err), err, string(debug.Stack())))
} | |
c23042 | got %T %v at %v", trace.Unwrap(err), err, string(debug.Stack())))
} | |
c23043 | got %T %v at %v", trace.Unwrap(err), err, string(debug.Stack())))
} | |
c23044 | got %T %v at %v", trace.Unwrap(err), err, string(debug.Stack())))
} | |
c23045 | check.Equals, true, check.Commentf("expected ConnectionProblem, got %T %v at %v", trace.Unwrap(err), err, string(debug.Stack())))
} | |
c23046 | true, DisablePointerAddresses: true}
c.Assert(a, check.DeepEquals, b, check.Commentf("%v\nStack:\n%v\n", diff.Diff(d.Sdump(a), d.Sdump(b)), string(debug.Stack())))
} | |
c23047 | maxSize || p.H < minSize {
return trace.BadParameter("bad height: %v", p.H)
}
return nil
} | |
c23048 | p.H > maxSize || p.H < minSize {
p.H = teleport.DefaultTerminalHeight
}
return nil
} | |
c23049 | h.streamPairsLock.Lock()
defer h.streamPairsLock.Unlock()
delete(h.streamPairs, requestID)
} | |
c23050 | streamType)
p, created := h.getStreamPair(requestID)
if created {
go h.monitorStreamPair(p, time.After(h.streamCreationTimeout))
}
if complete, err := p.add(stream); err != nil {
msg := fmt.Sprintf("error processing stream for request %s: %v", requestID, err)
p.printError(msg)
} else if com... | |
c23051 | %v -> %v.", p.requestID, portString)
if err != nil {
msg := fmt.Errorf("error forwarding port %d to pod %s: %v", port, h.podName, err)
fmt.Fprint(p.errorStream, msg.Error())
}
} | |
c23052 | != nil {
return false, trace.BadParameter("data stream already assigned")
}
p.dataStream = stream
}
complete := p.errorStream != nil && p.dataStream != nil
if complete {
close(p.complete)
}
return complete, nil
} | |
c23053 |
return false, trace.BadParameter(err.Error())
}
// Since the expression is always surrounded by ^ and $ this is an exact
// match for either a a plain string (for example ^hello$) or for a regexp
// (for example ^hel*o$).
if expr.MatchString(input) {
return true, nil
}
}
return false, nil
} | |
c23054 | Import storage data
err = legacy.Import(ctx, litebk, func() (legacy.Exporter, error) {
return dir.New(legacy.Params{"path": path})
})
if err != nil {
return nil, trace.Wrap(err)
}
return &ProcessStorage{Backend: litebk}, nil
} | |
c23055 |
if err := utils.UnmarshalWithSchema(GetStateSchema(), &res, item.Value); err != nil {
return nil, trace.BadParameter(err.Error())
}
return &res, nil
} | |
c23056 | Key: backend.Key(statesPrefix, strings.ToLower(role.String()), stateName),
Value: value,
}
_, err = p.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23057 | {
return nil, trace.Wrap(err)
}
var res IdentityV2
if err := utils.UnmarshalWithSchema(GetIdentitySchema(), &res, item.Value); err != nil {
return nil, trace.BadParameter(err.Error())
}
return ReadIdentityFromKeyPair(&PackedKeys{
Key: res.Spec.Key,
Cert: res.Spec.SSHCert,
TLSCert: res.Sp... | |
c23058 |
return trace.Wrap(err)
}
value, err := json.Marshal(res)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(idsPrefix, strings.ToLower(id.ID.Role.String()), name),
Value: value,
}
_, err = p.Put(context.TODO(), item)
return trace.Wrap(err)
} | |
c23059 | services.MetadataSchema, IdentitySpecV2Schema, services.DefaultDefinitions)
} | |
c23060 | services.RotationSchema), services.DefaultDefinitions)
} | |
c23061 | f.GetString(EventLogin),
f.GetInt(EventCursor),
f.GetInt(SessionPrintEventBytes))
} | |
c23062 | return ""
}
v, _ := val.(string)
return v
} | |
c23063 | <-replySent:
notify <- struct{}{}
case <-ctx.Done():
}
} | |
c23064 | return trace.ConvertSystemError(err)
}
return nil
} | |
c23065 | {
return trace.ConvertSystemError(os.RemoveAll(r.Path))
} | |
c23066 |
if err == nil {
return !fi.IsDir()
}
return false
} | |
c23067 |
if err == nil {
return fi.IsDir()
}
return false
} | |
c23068 |
if err != nil {
return "", trace.ConvertSystemError(err)
}
return abs, nil
} | |
c23069 | nil, trace.BadParameter("%v is not a file", path)
}
f, err := os.Open(newPath)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
return f, nil
} | |
c23070 | return nil, trace.BadParameter("%v is not a directory", path)
}
return fi, nil
} | |
c23071 | teleport.WindowsOS:
return os.Getenv(teleport.EnvUserProfile)
}
return ""
} | |
c23072 | return t.File()
}
return nil, trace.BadParameter("unsupported listener: %T", listener)
} | |
c23073 | }()
return &SyncBuffer{
reader: reader,
writer: writer,
buf: buf,
}
} | |
c23074 |
if err != nil {
return err
}
return err2
} | |
c23075 |
a.state = agentStateDiscovering
}
a.Entry = log.WithFields(log.Fields{
trace.Component: teleport.ComponentReverseTunnelAgent,
trace.ComponentFields: log.Fields{
"target": cfg.Addr.String(),
},
})
a.hostKeyCallback = a.checkHostSignature
return a, nil
} | |
c23076 |
proxyID := fmt.Sprintf("%v.%v", proxy.GetName(), a.ClusterName)
if _, ok := principals[proxyID]; ok {
return true
}
return false
} | |
c23077 | if a.connectedTo(proxy) {
return true
}
}
return false
} | |
c23078 |
case a.EventsC <- ConnectedEvent:
case <-a.ctx.Done():
a.Debug("Context is closing.")
return
default:
}
}
// A connection has been established start processing requests. Note that
// this function blocks while the connection is up. It will unblock when
// the connection is closed either due to inter... | |
c23079 | return trace.Wrap(err)
}
a.Debugf("Ping -> %v.", conn.RemoteAddr())
// ssh channel closed:
case req := <-reqC:
if req == nil {
return trace.ConnectionProblem(nil, "heartbeat: connection closed")
}
// new transport request:
case nch := <-newTransportC:
if nch == nil {
continue
}
a.... | |
c23080 | := make(chan time.Time)
close(closedChan)
return &Linear{LinearConfig: cfg, closedChan: closedChan}, nil
} | |
c23081 | 0
}
if a <= r.Max {
return a
}
return r.Max
} | |
c23082 | return r.closedChan
}
return time.After(r.Duration())
} | |
c23083 | duration=%v)", r.attempt, r.Duration())
} | |
c23084 | C.size_t(bufSize),
&result)
if rv != 0 || result == nil {
log.Errorf("lookupPosixShell: lookup username %s: %s", username, syscall.Errno(rv))
return "", trace.BadParameter("cannot determine shell for %s", username)
}
// If no shell was found, return trace.NotFound to allow the caller to set
// the default ... | |
c23085 |
return "", trace.Wrap(err)
}
return Fingerprint(key), nil
} | |
c23086 | "", trace.Wrap(err)
}
return Fingerprint(signer.PublicKey()), nil
} | |
c23087 | must not be empty")
}
return &hmacAnonymizer{
key: key,
}, nil
} | |
c23088 | return base64.StdEncoding.EncodeToString(h.Sum(nil))
} | |
c23089 | }
// since ProcessObject works with unstructured data, the
// data needs to be re-interpreted in structured form
bytes, err := json.Marshal(processed)
if err != nil {
return trace.Wrap(err)
}
if err := json.Unmarshal(bytes, object); err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23090 | tarball := tar.NewWriter(writer)
go func() {
if err := writeSessionArchive(index, tarball, writer); err != nil {
log.Warningf("Failed to write archive: %v.", trace.DebugReport(err))
}
}()
return reader, nil
} | |
c23091 |
rsaKey, ok := key.(*rsa.PrivateKey)
if !ok {
return nil, trace.BadParameter("key of type %T is not supported, only RSA keys are supported for signatures", key)
}
certASN, _ := pem.Decode([]byte(certPEM))
if certASN == nil {
return nil, trace.BadParameter("expected PEM-encoded block")
}
return &SigningKeySto... | |
c23092 | := x509.ParseCertificateRequest(block.Bytes)
if err != nil {
return nil, trace.BadParameter(err.Error())
}
return csr, nil
} | |
c23093 | x509.ParseCertificate(block.Bytes)
if err != nil {
return nil, trace.BadParameter(err.Error())
}
return cert, nil
} | |
c23094 | nil, trace.BadParameter("expected PEM-encoded block")
}
return ParsePrivateKeyDER(block.Bytes)
} | |
c23095 | generalKey.(type) {
case *rsa.PrivateKey:
return generalKey.(*rsa.PrivateKey), nil
case *ecdsa.PrivateKey:
return generalKey.(*ecdsa.PrivateKey), nil
}
return nil, trace.BadParameter("unsupported private key type")
} | |
c23096 | }
// build a concatenated certificate chain
var buf bytes.Buffer
for _, cc := range certificateChain {
_, err := buf.Write(cc)
if err != nil {
return nil, trace.Wrap(err)
}
}
// parse the chain and get a slice of x509.Certificates.
x509Chain, err := x509.ParseCertificates(buf.Bytes())
if err != nil {... | |
c23097 | waitCtx,
waitCancel: waitCancel,
Entry: log.WithFields(log.Fields{
trace.Component: "loadbalancer",
trace.ComponentFields: log.Fields{
"listen": frontend.String(),
},
}),
connections: make(map[NetAddr]map[int64]net.Conn),
}, nil
} | |
c23098 | 1
tracker, ok := l.connections[backend]
if !ok {
tracker = make(map[int64]net.Conn)
l.connections[backend] = tracker
}
tracker[l.connID] = conn
return l.connID
} | |
c23099 |
defer l.Unlock()
tracker, ok := l.connections[backend]
if !ok {
return
}
delete(tracker, id)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.