id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c23200 | {
return trace.Wrap(err)
}
return c.CertChecker.CheckCert(principal, cert)
} | |
c23201 | nil {
return trace.Wrap(err)
}
return c.CertChecker.CheckHostKey(addr, remote, key)
} | |
c23202 | != nil {
return nil, nil, trace.Wrap(err)
}
key, err := rsa.GenerateKey(rand.Reader, teleport.RSAKeySize)
if err != nil {
return nil, nil, trace.Wrap(err)
}
cert, certSigner, err := createCertificate(principal, certType, caKey, key)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return cert, certSi... | |
c23203 | err != nil {
return nil, nil, trace.Wrap(err)
}
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
return nil, nil, trace.Wrap(err)
}
cert, certSigner, err := createCertificate(principal, certType, caKey, key)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return cert, cert... | |
c23204 |
ValidAfter: uint64(time.Now().UTC().Add(-1 * time.Minute).Unix()),
ValidBefore: uint64(time.Now().UTC().Add(1 * time.Minute).Unix()),
CertType: certType,
}
err = cert.SignCert(rand.Reader, caSigner)
if err != nil {
return nil, nil, trace.Wrap(err)
}
certSigner, err := ssh.NewCertSigner(cer... | |
c23205 | if server sent "local" IP address to us, replace the ip/host part with the remote address we see
// on the socket, but keep the original port:
server.SetAddr(utils.ReplaceLocalhost(server.GetAddr(), r.RemoteAddr))
if req.TTL != 0 {
server.SetTTL(s, req.TTL)
}
switch role {
case teleport.RoleNode:
namespace :... | |
c23206 |
if err := auth.KeepAliveNode(r.Context(), handle); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | |
c23207 | nodes, err := services.GetServerMarshaler().UnmarshalServers(req.Nodes)
if err != nil {
return nil, trace.Wrap(err)
}
err = auth.UpsertNodes(req.Namespace, nodes)
if err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | |
c23208 | return nil, trace.Wrap(err)
}
var opts []services.MarshalOption
if skipValidation {
opts = append(opts, services.SkipValidation())
}
servers, err := auth.GetNodes(namespace, opts...)
if err != nil {
return nil, trace.Wrap(err)
}
return marshalServers(servers, version)
} | |
c23209 |
}
err := auth.DeleteProxy(name)
if err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | |
c23210 | p httprouter.Params, version string) (interface{}, error) {
return s.upsertServer(auth, teleport.RoleAuth, w, r, p, version)
} | |
c23211 |
if err != nil {
return nil, trace.Wrap(err)
}
return marshalServers(servers, version)
} | |
c23212 | nil {
return nil, trace.Wrap(err)
}
if req.TTL != 0 {
tun.SetTTL(s, req.TTL)
}
if err := auth.UpsertReverseTunnel(tun); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | |
c23213 | err := services.GetReverseTunnelMarshaler().MarshalReverseTunnel(tunnel, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
} | |
c23214 | return nil, trace.Wrap(err)
}
return message(fmt.Sprintf("reverse tunnel %v deleted", domainName)), nil
} | |
c23215 | auth.GetClusterCACert()
if err != nil {
return nil, trace.Wrap(err)
}
return localCA, nil
} | |
c23216 | cap.GetU2F()
if err != nil {
return nil, trace.Wrap(err)
}
w.Header().Set("Content-Type", "application/fido.trusted-apps+json")
return universalSecondFactor.AppID, nil
} | |
c23217 |
return nil, trace.Wrap(err)
}
return &getSignupTokenDataResponse{
User: user,
QRImg: otpQRCode,
}, nil
} | |
c23218 | if err != nil {
return nil, trace.Wrap(err)
}
if err := auth.UpsertTunnelConnection(conn); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | |
c23219 | conn := range conns {
data, err := services.MarshalTunnelConnection(conn, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
} | |
c23220 | if err != nil {
return nil, trace.Wrap(err)
}
if err := auth.CreateRemoteCluster(conn); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | |
c23221 | data, err := services.MarshalRemoteCluster(cluster, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
} | |
c23222 | rawMessage(services.MarshalRemoteCluster(cluster, services.WithVersion(version), services.PreserveResourceID()))
} | |
c23223 | return nil, trace.AccessDenied("unable to map attributes to role for connector: %v", connector.GetName())
}
return roles, nil
} | |
c23224 | assr.Values {
vals = append(vals, value.Value)
}
traits[assr.Name] = vals
}
return traits
} | |
c23225 | events.LoginMethodSAML,
events.AuthAttemptSuccess: false,
events.AuthAttemptErr: err.Error(),
})
} else {
a.EmitAuditEvent(events.UserSSOLogin, events.EventFields{
events.EventUser: re.Username,
events.AuthAttemptSuccess: true,
events.LoginMethod: events.LoginMethodSAML,
... | |
c23226 | {Kind: services.KindNode},
{Kind: services.KindProxy},
{Kind: services.KindReverseTunnel},
{Kind: services.KindTunnelConnection},
}
cfg.QueueSize = defaults.AuthQueueSize
return cfg
} | |
c23227 | {Kind: services.KindAuthServer},
{Kind: services.KindReverseTunnel},
{Kind: services.KindTunnelConnection},
}
cfg.QueueSize = defaults.ProxyQueueSize
return cfg
} | |
c23228 | namespace events to avoid matching too much
// data about other namespaces or node events
{Kind: services.KindNamespace, Name: defaults.Namespace},
}
cfg.QueueSize = defaults.NodeQueueSize
return cfg
} | |
c23229 | local.NewEventsService(config.Backend),
Entry: log.WithFields(log.Fields{
trace.Component: config.Component,
}),
}
collections, err := setupCollections(cs, config.Watches)
if err != nil {
return nil, trace.Wrap(err)
}
cs.collections = collections
err = cs.fetch()
if err != nil {
// "only recen... | |
c23230 | return c.eventsCache.NewWatcher(ctx, watch)
} | |
c23231 |
}
}
c.wrapper.SetReadError(trace.ConnectionProblem(err, "cache is unavailable"))
return err
} | |
c23232 | range c.collections {
errors = append(errors, collection.erase())
}
return trace.NewAggregate(errors...)
} | |
c23233 | s.getConn(principal)
if err == nil {
return rconn, true
}
}
return nil, false
} | |
c23234 | storage.ReadIdentity(auth.IdentityCurrent, teleport.RoleAdmin)
if err != nil {
return nil, trace.Wrap(err)
}
return identity.TLSConfig(nil)
} | |
c23235 |
log: logrus.WithFields(logrus.Fields{trace.Component: "Presence"}),
Backend: b,
}
} | |
c23236 | backend.Key(localClusterPrefix, valPrefix),
Value: []byte(name),
})
return trace.Wrap(err)
} | |
c23237 | err != nil {
return "", trace.Wrap(err)
}
return string(item.Value), nil
} | |
c23238 | backend.Key(namespacesPrefix), backend.RangeEnd(backend.Key(namespacesPrefix)))
} | |
c23239 | trace.NotFound("namespace %q is not found", name)
}
return nil, trace.Wrap(err)
}
return services.UnmarshalNamespace(
item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
} | |
c23240 | nil {
if trace.IsNotFound(err) {
return trace.NotFound("namespace %q is not found", namespace)
}
}
return trace.Wrap(err)
} | |
c23241 | s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | |
c23242 | := backend.Key(nodesPrefix, namespace, name)
return s.Delete(context.TODO(), key)
} | |
c23243 | server, err := services.GetServerMarshaler().UnmarshalServer(
item.Value,
services.KindNode,
services.AddOptions(opts,
services.WithResourceID(item.ID),
services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
servers[i] = server
}
return servers, nil
} | |
c23244 | server.GetResourceID(),
})
if err != nil {
return nil, trace.Wrap(err)
}
if server.Expiry().IsZero() {
return &services.KeepAlive{}, nil
}
return &services.KeepAlive{LeaseID: lease.ID, ServerName: server.GetName()}, nil
} | |
c23245 | h.LeaseID,
Key: backend.Key(nodesPrefix, h.Namespace, h.ServerName),
}, h.Expires)
return trace.Wrap(err)
} | |
c23246 | Key: backend.Key(nodesPrefix, server.GetNamespace(), server.GetName()),
Value: value,
Expires: server.Expiry(),
ID: server.GetResourceID(),
}
}
err := batch.PutRange(context.TODO(), items)
if err != nil {
return trace.Wrap(err)
}
s.log.Debugf("UpsertNodes(%v) in %v", len(servers), time... | |
c23247 | s.getServers(services.KindAuthServer, authServersPrefix)
} | |
c23248 | s.upsertServer(authServersPrefix, server)
} | |
c23249 | s.upsertServer(proxiesPrefix, server)
} | |
c23250 | s.getServers(services.KindProxy, proxiesPrefix)
} | |
c23251 | backend.Key(proxiesPrefix, name)
return s.Delete(context.TODO(), key)
} | |
c23252 | s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | |
c23253 |
Key: backend.Key(reverseTunnelsPrefix, tunnel.GetName()),
Value: value,
Expires: tunnel.Expiry(),
ID: tunnel.GetResourceID(),
})
return trace.Wrap(err)
} | |
c23254 | item.Value, services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
tunnels[i] = tunnel
}
// sorting helps with tests and makes it all deterministic
sort.Sort(services.SortedReverseTunnels(tunnels))
return tunnels, n... | |
c23255 | backend.Key(reverseTunnelsPrefix, clusterName))
return trace.Wrap(err)
} | |
c23256 | backend.Item{
Key: backend.Key(trustedClustersPrefix, trustedCluster.GetName()),
Value: value,
Expires: trustedCluster.Expiry(),
ID: trustedCluster.GetResourceID(),
})
if err != nil {
return nil, trace.Wrap(err)
}
return trustedCluster, nil
} | |
c23257 | }
return services.GetTrustedClusterMarshaler().Unmarshal(item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
} | |
c23258 | err := services.GetTrustedClusterMarshaler().Unmarshal(item.Value,
services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
out[i] = tc
}
sort.Sort(services.SortedTrustedCluster(out))
return out, nil
} | |
c23259 | err := s.Delete(context.TODO(), backend.Key(trustedClustersPrefix, name))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("trusted cluster %q is not found", name)
}
}
return trace.Wrap(err)
} | |
c23260 |
Key: backend.Key(tunnelConnectionsPrefix, conn.GetClusterName(), conn.GetName()),
Value: value,
Expires: conn.Expiry(),
ID: conn.GetResourceID(),
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23261 |
if trace.IsNotFound(err) {
return nil, trace.NotFound("trusted cluster connection %q is not found", connectionName)
}
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalTunnelConnection(item.Value,
services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.Expires))...... | |
c23262 | backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
conns := make([]services.TunnelConnection, len(result.Items))
for i, item := range result.Items {
conn, err := services.UnmarshalTunnelConnection(item.Value,
services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.E... | |
c23263 |
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | |
c23264 |
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | |
c23265 | value,
Expires: rc.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23266 | startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | |
c23267 |
// move cursor to -10:0
esc(fmt.Sprintf("[%d;%df", 0, int(sz.Width)-len(message)))
os.Stdout.WriteString(message)
} | |
c23268 |
iter.ReadVal(v)
if iter.Error != nil {
return trace.Wrap(iter.Error)
}
return nil
} | |
c23269 |
if err != nil {
return nil, trace.Wrap(err)
}
return data, nil
} | |
c23270 | > 10 {
return false
}
}
return val.Kind() == reflect.Struct || val.Kind() == reflect.Map
} | |
c23271 | trace.Wrap(err)
}
_, err = w.Write(data)
return trace.Wrap(err)
} | |
c23272 | }
if len(values) == 1 {
return values[0], nil
}
return values, nil
}
return nil, trace.Wrap(err)
}
values = append(values, val)
}
} | |
c23273 | responseC: make(chan *auth.SSHLoginResponse, 1),
errorC: make(chan error, 1),
}
// callback is a callback URL communicated to the Teleport proxy,
// after SAML/OIDC login, the teleport will redirect user's browser
// to this laptop-local URL
rd.mux.Handle("/callback", rd.wrapCallback(rd.callback))
// s... | |
c23274 | ConnectorID: rd.ConnectorID,
Compatibility: rd.Compatibility,
})
if err != nil {
return trace.Wrap(err)
}
var re *SSOLoginConsoleResponse
err = json.Unmarshal(out.Bytes(), &re)
if err != nil {
return trace.Wrap(err)
}
// notice late binding of the redirect URL here, it is referenced
// in the callbac... | |
c23275 |
return utils.ClickableURL(rd.server.URL + rd.shortPath)
} | |
c23276 | %v", r.URL.String(), err)
}
var re *auth.SSHLoginResponse
err = json.Unmarshal(plaintext, &re)
if err != nil {
return nil, trace.BadParameter("failed to decrypt response: in %v, err: %v", r.URL.String(), err)
}
return re, nil
} | |
c23277 |
if rd.server != nil {
rd.server.Close()
}
return nil
} | |
c23278 | response, err := fn(w, r)
if err != nil {
if trace.IsNotFound(err) {
http.NotFound(w, r)
return
}
select {
case rd.errorC <- err:
case <-rd.context.Done():
http.Redirect(w, r, errorURL, http.StatusFound)
return
}
http.Redirect(w, r, errorURL, http.StatusFound)
return
}
sel... | |
c23279 | name,
Namespace: defaults.Namespace,
},
Spec: spec,
}, nil
} | |
c23280 | map[string]string) {
c.Metadata.Labels = labels
} | |
c23281 | features = append(features, "supports kubernetes")
}
if c.Spec.AWSProductID != "" {
features = append(features, fmt.Sprintf("is limited to AWS product ID %q", c.Spec.AWSProductID))
}
if c.Spec.AWSAccountID != "" {
features = append(features, fmt.Sprintf("is limited to AWS account ID %q", c.Spec.AWSAccountID))... | |
c23282 | }
if license.Version != V3 {
return nil, trace.BadParameter("unsupported version %v, expected version %v", license.Version, V3)
}
if err := license.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &license, nil
} | |
c23283 | if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *resource
copy.SetResourceID(0)
resource = ©
}
return utils.FastMarshal(resource)
default:
return nil, trace.BadParameter("unrecognized resource version %T", license)
}
} | |
c23284 | discoveryC: make(chan *discoveryRequest),
}
pool.Entry = log.WithFields(log.Fields{
trace.Component: teleport.ComponentReverseTunnelAgent,
trace.ComponentFields: log.Fields{
"cluster": cfg.Cluster,
},
})
return pool, nil
} | |
c23285 | countPerState[a.getState()]++
}
for state, count := range countPerState {
gauge, err := trustedClustersStats.GetMetricWithLabelValues(key.tunnelID, state)
if err != nil {
m.Warningf("Failed to get gauge: %v.", err)
continue
}
gauge.Set(float64(count))
}
if logReport {
m.WithFields(log.... | |
c23286 | agent key with filter applied.
if len(validAgents) > 0 {
m.agents[agentKey] = validAgents
} else {
delete(m.agents, agentKey)
}
}
} | |
c23287 |
return trace.Wrap(err)
}
err = ioutil.WriteFile(fs.filePath, bytes, 0666)
if err != nil {
log.Error(err)
return trace.ConvertSystemError(err)
}
return nil
} | |
c23288 | json.Unmarshal(bytes, &addrs)
if err != nil {
return nil, trace.Wrap(err)
}
}
return addrs, nil
} | |
c23289 | if err != nil {
plainConn.Close()
return nil, trace.Wrap(err)
}
case <-ctx.Done():
plainConn.Close()
return nil, trace.BadParameter("tls handshake has been cancelled due to timeout")
}
if tlsConfig.InsecureSkipVerify {
return conn, nil
}
if err := conn.VerifyHostname(tlsConfig.ServerName); err !=... | |
c23290 | isSSO := len(user.GetOIDCIdentities()) > 0 ||
len(user.GetGithubIdentities()) > 0 ||
len(user.GetSAMLIdentities()) > 0
if isSSO {
// SSO user
authType = authSSO
}
return &userContext{
Name: user.GetName(),
ACL: acl,
AuthType: authType,
Version: teleport.Version,
}, nil
} | |
c23291 | t.Server.Serve(tls.NewListener(listener, t.TLS))
} | |
c23292 | sure that this user does not have system role
// the local auth server can not truste remote servers
// to issue certificates with system roles (e.g. Admin),
// to get unrestricted access to the local cluster
systemRole := findSystemRole(identity.Groups)
if systemRole != nil {
return RemoteBuiltinRole{
... | |
c23293 | determine authenticated user based on the request parameters
requestWithContext := r.WithContext(context.WithValue(baseContext, ContextUser, user))
a.Handler.ServeHTTP(w, requestWithContext)
} | |
c23294 | {
hostCA, err := client.GetCertAuthority(
services.CertAuthID{Type: services.HostCA, DomainName: clusterName},
false, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
userCA, err := client.GetCertAuthority(
services.CertAuthID{Type: services.UserCA, DomainName: clusterName},... | |
c23295 | configuration but this \n" +
"Teleport binary was built without PAM support. To continue either download a \n" +
"Teleport binary build with PAM support from https://gravitational.com/teleport \n" +
"or disable PAM in file configuration."
return trace.BadParameter(errorMessage)
}
if !pam.Syste... | |
c23296 | clusterName,
nil,
[][]byte{ssh.MarshalAuthorizedKey(pubkey)},
nil)
// transform old allowed logins into roles
role := services.RoleForCertAuthority(ca)
role.SetLogins(services.Allow, allowedLogins)
ca.AddRole(role.GetName())
return ca, role, nil
} | |
c23297 | 0 {
return nil, nil, trace.BadParameter("key without cluster_name")
}
const prefix = "*."
domainName := strings.TrimPrefix(options[0], prefix)
v1 := &services.CertAuthorityV1{
AllowedLogins: utils.CopyStrings(allowedLogins),
DomainName: domainName,
Type: authType,
CheckingKeys: [][]byte{ssh... | |
c23298 | "", trace.BadParameter("unknown ca format")
}
return teleport.KnownHosts, nil
}
return teleport.AuthorizedKeys, nil
} | |
c23299 | == teleport.AuthorizedKeys {
return parseAuthorizedKeys(bytes, allowedLogins)
}
return parseKnownHosts(bytes, allowedLogins)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.