id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c23300 | ca.GetClusterName())
}
authorities = append(authorities, ca)
if role != nil {
roles = append(roles, role)
}
}
conf.Auth.Authorities = append(conf.Auth.Authorities, authorities...)
conf.Auth.Roles = append(conf.Auth.Roles, roles...)
clusterName := authorities[0].GetClusterName()
// parse "t... | |
c23301 | *target = src
return true
}
return false
} | |
c23302 |
&cfg.Proxy.ReverseTunnelListenAddr,
}
for _, addr := range listeningAddresses {
replaceHost(addr, ip.String())
}
} | |
c23303 | parsing address: '%v'", addr.Addr)
}
addr.Addr = net.JoinHostPort(newHost, port)
} | |
c23304 | {
return json.Marshal(fmt.Sprintf("%v", d.Duration))
} | |
c23305 | })
if err != nil {
return "", nil, trace.Wrap(err)
}
// create QR code
var otpQRBuf bytes.Buffer
otpImage, err := otpKey.Image(456, 456)
if err != nil {
return "", nil, trace.Wrap(err)
}
png.Encode(&otpQRBuf, otpImage)
return otpKey.Secret(), otpQRBuf.Bytes(), nil
} | |
c23306 | s.initializeTOTP(accountName)
if err != nil {
return nil, trace.Wrap(err)
}
// Upsert token into backend.
err = s.UpsertSignupToken(token, *st, st.Expires.Sub(s.clock.Now()))
if err != nil {
return nil, trace.Wrap(err)
}
return st, nil
} | |
c23307 | return nil, trace.AccessDenied("failed to validate a token")
}
err = s.UpsertPassword(tokenData.User.Name, []byte(password))
if err != nil {
return nil, trace.Wrap(err)
}
// create services.User and services.WebSession
webSession, err := s.createUserAndSession(tokenData)
if err != nil {
return nil, trace.... | |
c23308 | s.GetSignupToken(token)
if err != nil {
log.Warningf("failed to get signup token: %v", err)
return nil, trace.AccessDenied("expired or incorrect signup token")
}
err = s.UpsertPassword(tokenData.User.Name, []byte(password))
if err != nil {
return nil, trace.Wrap(err)
}
// create services.User and service... | |
c23309 | },
Spec: spec,
}
if err := st.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &st, nil
} | |
c23310 | fmt.Sprintf(StaticTokensSpecSchemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, staticTokensSchema, DefaultDefinitions)
} | |
c23311 | return nil, trace.BadParameter(err.Error())
}
}
err = staticTokens.CheckAndSetDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
staticTokens.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
staticTokens.SetExpiry(cfg.Expires)
}
return &staticTokens, nil
} | |
c23312 | *StaticTokensV2:
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", c)
... | |
c23313 | return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | |
c23314 |
item := backend.Item{
Key: backend.Key(authoritiesPrefix, string(ca.GetType()), ca.GetName()),
Value: value,
Expires: ca.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
if trace.IsAlreadyExists(err) {
return trace.AlreadyExists("cluster %q already exists", ca.GetName())
}
... | |
c23315 | backend.Key(authoritiesPrefix, string(ca.GetType()), ca.GetName()),
Value: value,
Expires: ca.Expiry(),
ID: ca.GetResourceID(),
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23316 | string(existing.GetType()), existing.GetName()),
Value: existingValue,
Expires: existing.Expiry(),
}
_, err = s.CompareAndSwap(context.TODO(), existingItem, newItem)
if err != nil {
if trace.IsCompareFailed(err) {
return trace.CompareFailed("cluster %v settings have been updated, try again", new.GetName... | |
c23317 | !trace.IsNotFound(err) {
return trace.Wrap(err)
}
}
err = s.Delete(context.TODO(), backend.Key(authoritiesPrefix, string(id.Type), id.DomainName))
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23318 | s.UpsertCertAuthority(certAuthority)
if err != nil {
return trace.Wrap(err)
}
err = s.Delete(context.TODO(), backend.Key(authoritiesPrefix, deactivatedPrefix, string(id.Type), id.DomainName))
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23319 | Key: backend.Key(authoritiesPrefix, deactivatedPrefix, string(id.Type), id.DomainName),
Value: value,
Expires: certAuthority.Expiry(),
ID: certAuthority.GetResourceID(),
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23320 | client.Namespace,
closer: utils.NewCloseBroadcaster(),
}
// if we're joining an existing session, we need to assume that session's
// existing/current terminal size:
if joinSession != nil {
ns.id = joinSession.ID
ns.namespace = joinSession.Namespace
tsize := joinSession.TerminalParams.Winsize()
if ns... | |
c23321 | call the passed callback and give them the established
// ssh session:
if err := callback(sess, remoteTerm); err != nil {
return trace.Wrap(err)
}
// Catch term signals, but only if we're attached to a real terminal
if ns.isTerminalAttached() {
ns.watchSignals(remoteTerm)
}
// start piping input into the ... | |
c23322 |
if err := s.Shell(); err != nil {
return trace.Wrap(err)
}
// call the client-supplied callback
if callback != nil {
exit, err := callback(s, ns.NodeClient().Client, shell)
if exit {
return trace.Wrap(err)
}
}
return nil
})
} | |
c23323 | }
}
}()
// Catch Ctrl-Z signal
ctrlZSignal := make(chan os.Signal, 1)
signal.Notify(ctrlZSignal, syscall.SIGTSTP)
go func() {
for {
<-ctrlZSignal
_, err := shell.Write([]byte{26})
if err != nil {
log.Errorf(err.Error())
}
}
}()
} | |
c23324 | c.ReadDeadline = defaults.ReadHeadersTimeout
}
if c.Clock == nil {
c.Clock = clockwork.NewRealClock()
}
return nil
} | |
c23325 | cancel,
sshListener: newListener(ctx, cfg.Listener.Addr()),
tlsListener: newListener(ctx, cfg.Listener.Addr()),
waitContext: waitContext,
waitCancel: waitCancel,
}, nil
} | |
c23326 | return nil
}
select {
case <-backoffTimer.C:
m.Debugf("backoff on accept error: %v", trace.DebugReport(err))
case <-m.context.Done():
return nil
}
}
} | |
c23327 | err != nil {
g.Debugf("Failed to receive heartbeat: %v", err)
return trail.ToGRPC(err)
}
err = auth.KeepAliveNode(stream.Context(), *keepAlive)
if err != nil {
return trail.ToGRPC(err)
}
}
} | |
c23328 | kind.Name,
Kind: kind.Kind,
LoadSecrets: kind.LoadSecrets,
})
}
watcher, err := auth.NewWatcher(stream.Context(), servicesWatch)
if err != nil {
return trail.ToGRPC(err)
}
defer watcher.Close()
for {
select {
case <-stream.Context().Done():
return nil
case <-watcher.Done():
retur... | |
c23329 | if err != nil {
return nil, trail.ToGRPC(err)
}
keepAlive, err := auth.UpsertNode(server)
if err != nil {
return nil, trail.ToGRPC(err)
}
return keepAlive, nil
} | |
c23330 | {
log.Warn(trace.DebugReport(err))
}
return nil, trace.AccessDenied("[10] access denied")
}
return &grpcContext{
AuthContext: authContext,
AuthWithRoles: &AuthWithRoles{
authServer: g.AuthServer,
user: authContext.User,
checker: authContext.Checker,
sessions: g.SessionService,
al... | |
c23331 |
grpcHandler: grpc.NewServer(),
}
proto.RegisterAuthServiceServer(authServer.grpcHandler, authServer)
return authServer
} | |
c23332 |
if r.ProtoMajor == 2 && strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
g.grpcHandler.ServeHTTP(w, r)
} else {
g.httpHandler.ServeHTTP(w, r)
}
} | |
c23333 | s.GetStatus(),
LastConnected: s.GetLastConnected(),
})
}
// serialize them into JSON and write back:
data, err := json.Marshal(retval)
if err != nil {
return trace.Wrap(err)
}
if _, err := ch.Write(data); err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23334 | range m.loggers {
errors = append(errors, log.Close())
}
return trace.NewAggregate(errors...)
} | |
c23335 | false)
if err != nil {
return nil, trace.Wrap(err)
}
siteNodes, err := site.GetNodes(namespace, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
// look at every node on this site and see which ones match:
for _, node := range siteNodes {
if node.MatchAgainst(labels) {
nodes =... | |
c23336 | the current cluster:
cluster, err := proxy.currentCluster()
if err != nil {
return nil, trace.Wrap(err)
}
return proxy.ClusterAccessPoint(ctx, cluster.Name, quiet)
} | |
c23337 | proxy.ConnectToCluster(ctx, clusterName, quiet)
if err != nil {
return nil, trace.Wrap(err)
}
return proxy.teleportClient.accessPoint(clt, proxy.proxyAddress, clusterName)
} | |
c23338 |
cluster, err := proxy.currentCluster()
if err != nil {
return nil, trace.Wrap(err)
}
return proxy.ConnectToCluster(ctx, cluster.Name, quiet)
} | |
c23339 | trace.Wrap(err, "failed to parse TLS cert and key")
}
tlsConfig.Certificates = append(tlsConfig.Certificates, tlsCert)
}
if len(tlsConfig.Certificates) == 0 {
return nil, trace.BadParameter("no TLS keys found for user %v, please relogin to get new credentials", proxy.teleportClient.Username)
}
clt, err := au... | |
c23340 | = append(c.closers, closer)
} | |
c23341 | != nil {
return node
}
return n
} | |
c23342 | if err != nil {
responseCh <- proxyResponse{isRecord: false, err: trace.Wrap(err)}
return
}
if !ok {
responseCh <- proxyResponse{isRecord: false, err: trace.AccessDenied("unable to determine proxy type")}
return
}
recordingProxy, err := strconv.ParseBool(string(responseBytes))
if err != nil {
... | |
c23343 | != nil {
// read the stderr output from the failed SSH session and append
// it to the end of our own message:
serverErrorMsg, _ := ioutil.ReadAll(proxyErr)
return nil, trace.ConnectionProblem(err, "failed connecting to node %v. %s",
nodeName(strings.Split(address, "@")[0]), serverErrorMsg)
}
return utils... | |
c23344 | nil, trace.Wrap(resp.err, "failed to connect to %q", nodeAddress)
}
return resp.conn, resp.chanCh, resp.reqCh, nil
case <-ctx.Done():
errClose := conn.Close()
if errClose != nil {
log.Error(errClose)
}
// drain the channel
resp := <-respCh
return nil, nil, nil, trace.ConnectionProblem(resp.err, "fa... | |
c23345 | func() {
err := c.proxyConnection(ctx, conn, remoteAddr)
if err != nil {
log.Warnf("Failed to proxy connection: %v.", err)
}
}()
}
} | |
c23346 | := socks.Handshake(conn)
if err != nil {
log.Errorf("SOCKS5 handshake failed: %v.", err)
break
}
log.Debugf("SOCKS5 proxy forwarding requests to %v.", remoteAddr)
// Proxy the connection to the remote address.
go func() {
err := c.proxyConnection(ctx, conn, remoteAddr)
if err != nil {
log.Wa... | |
c23347 | }
for _, site := range sites {
if site.Name == proxy.siteName {
return &site, nil
}
}
return nil, trace.NotFound("cluster %v not found", proxy.siteName)
} | |
c23348 | err != nil {
return nil, trace.Wrap(err)
}
return cmd, nil
} | |
c23349 | trace.ComponentFields: log.Fields{
"LocalAddr": cfg.Flags.LocalAddr,
"RemoteAddr": cfg.Flags.RemoteAddr,
"Target": cfg.Flags.Target,
"User": cfg.User,
"RunOnServer": cfg.RunOnServer,
"RemoteLocation": cfg.RemoteLocation,
},
})
return &cmd, nil
} | |
c23350 | len(message)+2)
bytes = append(bytes, ErrByte)
bytes = append(bytes, message...)
bytes = append(bytes, []byte{'\n'}...)
_, writeErr := ch.Write(bytes)
if writeErr != nil {
cmd.log.Error(writeErr)
}
return trace.Wrap(err)
} | |
c23351 |
r.s.Scan()
if err := r.s.Err(); err != nil {
return trace.Wrap(err)
}
return trace.Errorf(r.s.Text())
}
return trace.Errorf("unrecognized command: %#v", r.b)
} | |
c23352 |
if err = writeBytes(username+fileExtTLSCert, key.TLSCert); err != nil {
return trace.Wrap(err)
}
if err = writeBytes(username+fileExtPub, key.Pub); err != nil {
return trace.Wrap(err)
}
if err = writeBytes(username, key.Priv); err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23353 |
filepath.Join(dirPath, username),
}
for _, fn := range files {
if err = os.Remove(fn); err != nil {
return trace.Wrap(err)
}
}
return nil
} | |
c23354 | sessionKeyDir)
err := os.RemoveAll(dirPath)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23355 | // KeyStore should return expired certificates as well
if !utils.IsCertExpiredError(err) {
return nil, trace.Wrap(err)
}
}
sshCertExpiration, err := key.CertValidBefore()
if err != nil {
return nil, trace.Wrap(err)
}
tlsCertExpiration, err := key.TLSCertValidBefore()
if err != nil {
return nil, trace.... | |
c23356 |
_, err := fp.Write(cert)
if err != nil {
return trace.ConvertSystemError(err)
}
_, err = fp.WriteString("\n")
if err != nil {
return trace.ConvertSystemError(err)
}
}
}
return nil
} | |
c23357 | return nil, trace.Wrap(err)
}
return ioutil.ReadFile(filepath.Join(dir, fileNameTLSCerts))
} | |
c23358 | PEM block type=%v headers=%v.", block.Type, block.Headers)
continue
}
cert, err := x509.ParseCertificate(block.Bytes)
if err != nil {
return nil, trace.BadParameter("failed to parse certificate: %v", err)
}
fs.log.Debugf("Adding trusted cluster certificate authority %q to trusted pool.", cert.Issuer)
... | |
c23359 | exists := entries[line]; !exists {
output = append(output, line)
entries[line] = 1
}
}
// add every host key to the list of entries
for i := range hostKeys {
fs.log.Debugf("Adding known host %s with key: %v", hostname, sshutils.Fingerprint(hostKeys[i]))
bytes := ssh.MarshalAuthorizedKey(hostKeys[i])
l... | |
c23360 | err == nil {
hostMatch = (hostname == "")
if !hostMatch {
for i := range hosts {
if hosts[i] == hostname {
hostMatch = true
break
}
}
}
if hostMatch {
retval = append(retval, pubKey)
}
}
}
if err != io.EOF {
return nil, trace.Wrap(err)
}
return retval, nil
} | |
c23361 | provided").StringVar(&c.token)
c.nodeAdd.Flag("format", "Output format, 'text' or 'json'").Hidden().Default("text").StringVar(&c.format)
c.nodeAdd.Alias(AddNodeHelp)
c.nodeList = nodes.Command("ls", "List all active SSH nodes within the cluster")
c.nodeList.Flag("namespace", "Namespace of the nodes").Default(defa... | |
c23362 | strings.ToLower(roles.String()),
token,
caPin,
authServers[0].GetAddr(),
int(c.ttl.Minutes()),
authServers[0].GetAddr(),
)
}
} else {
// Always return a list, otherwise we'll break users tooling. See #1846 for
// more details.
tokens := []string{token}
out, err := json.Marshal(token... | |
c23363 | return trace.Wrap(err)
}
coll := &serverCollection{servers: nodes}
coll.writeText(os.Stdout)
return nil
} | |
c23364 | err = otp.SaveToFile(path)
if err != nil {
return "", trace.Wrap(err)
}
return token, nil
} | |
c23365 | no host part, likely the entry is malformed; ignore.
continue
}
if p[0] == '.' && (strings.HasSuffix(addr, p) || addr == p[1:]) {
// no_proxy ".foo.com" matches "bar.foo.com" or "foo.com"
return false
}
if p[0] != '.' && strings.HasSuffix(addr, p) && addr[len(addr)-len(p)-1] == '.' {
// no_proxy "f... | |
c23366 | != nil {
return nil, trace.Wrap(err)
}
return conn, nil
} | |
c23367 | Teleport's debug level ones
g.Entry.Debug(fmt.Sprintln(args...))
} | |
c23368 | statements as Teleport's debug level ones
g.Entry.Debugf(format, args...)
} | |
c23369 | g.Entry.Warning(fmt.Sprintln(args...))
} | |
c23370 | g.Entry.Warningf(format, args...)
} | |
c23371 | g.Entry.Error(fmt.Sprintln(args...))
} | |
c23372 | writeMethodSelection(conn)
if err != nil {
return "", trace.Wrap(err)
}
// Read in the request from the client and make sure the requested command
// is supported and extract the remote address. If everything is good, write
// out a success response.
remoteAddr, err := readRequest(conn)
if err != nil {
ret... | |
c23373 | authMethods := make([]byte, nmethods)
for i := byte(0); i < nmethods; i++ {
method, err := readByte(conn)
if err != nil {
return nil, trace.Wrap(err)
}
authMethods = append(authMethods, method)
}
return authMethods, nil
} | |
c23374 |
return trace.BadParameter("wrote: %v wanted to write: %v", n, len(message))
}
return nil
} | |
c23375 | net.IPv6len, nil
case socks5AddressTypeDomainName:
len, err := readByte(conn)
if err != nil {
return 0, trace.Wrap(err)
}
return int(len), nil
default:
return 0, trace.BadParameter("unsupported address type: %v", addrType)
}
} | |
c23376 | BDN.PORT even though they are ignored
// because Teleport only supports CONNECT.
message = []byte{0, 0, 0, 0, 0, 0}
n, err = conn.Write(message)
if err != nil {
return trace.Wrap(err)
}
if n != len(message) {
return trace.BadParameter("wrote: %v wanted to write: %v", n, len(message))
}
return nil
} | |
c23377 | != nil {
return 0, trace.Wrap(err)
}
return b[0], nil
} | |
c23378 | v := range a {
if v == b {
return true
}
}
return false
} | |
c23379 | username, DefaultShell)
return DefaultShell, nil
}
return "", trace.Wrap(err)
}
return shellcmd, nil
} | |
c23380 | services.UserCA {
continue
}
role := services.RoleForCertAuthority(ca)
role.SetLogins(services.Allow, s.AllowedLogins())
roles = append(roles, role)
}
return roles
} | |
c23381 |
if err != nil {
return trace.Wrap(err)
}
err = tc.AddTrustedCA(creds.HostCA)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23382 | trace.Wrap(err)
}
teleUser.AddRole(role.GetMetadata().Name)
roles = append(roles, role)
} else {
for _, role := range roles {
err := auth.UpsertRole(role)
if err != nil {
return trace.Wrap(err)
}
teleUser.AddRole(role.GetName())
}
}
err = auth.UpsertUser(teleUser)
if err != nil {
return... | |
c23383 |
Type: services.HostCA,
DomainName: clusterName.GetClusterName(),
}, false)
if err != nil {
return nil, trace.Wrap(err)
}
return &UserCreds{
HostCA: ca,
Key: client.Key{
Priv: priv,
Pub: pub,
Cert: sshCert,
TLSCert: x509Cert,
},
}, nil
} | |
c23384 | err := service.NewTeleport(tconf)
if err != nil {
return nil, trace.Wrap(err)
}
i.Nodes = append(i.Nodes, process)
// Build a list of expected events to wait for before unblocking based off
// the configuration passed in.
expectedEvents := []string{
service.NodeSSHReady,
}
// Start the process and block ... | |
c23385 |
}
// Create a new Teleport process and add it to the list of nodes that
// compose this "cluster".
process, err := service.NewTeleport(tconf)
if err != nil {
return trace.Wrap(err)
}
i.Nodes = append(i.Nodes, process)
// Build a list of expected events to wait for before unblocking based off
// the config... | |
c23386 | and add it to the list of nodes that
// compose this "cluster".
process, err := service.NewTeleport(tconf)
if err != nil {
return trace.Wrap(err)
}
i.Nodes = append(i.Nodes, process)
// Build a list of expected events to wait for before unblocking based off
// the configuration passed in.
expectedEvents := ... | |
c23387 | err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23388 | Roles: []services.Role{role},
}
i.Secrets.Users[username] = user
return user
} | |
c23389 | &User{
Username: username,
AllowedLogins: mappings,
}
i.Secrets.Users[username] = user
return user
} | |
c23390 | }
if i.Config.SSH.Enabled {
expectedEvents = append(expectedEvents, service.NodeSSHReady)
}
// Start the process and block until the expected events have arrived.
receivedEvents, err := startAndWait(i.Process, expectedEvents)
if err != nil {
return trace.Wrap(err)
}
// Extract and set reversetunnel.Server... | |
c23391 | if err != nil {
return nil, trace.Wrap(err)
}
err = SetupUserCreds(clt, i.Config.Proxy.SSHAddr.Addr, creds)
if err != nil {
return nil, trace.Wrap(err)
}
return clt, nil
} | |
c23392 |
log.Errorf("Failed closing extra proxy: %v.", err)
}
if err := p.Wait(); err != nil {
errors = append(errors, err)
log.Errorf("Failed to stop extra proxy: %v.", err)
}
}
}
return trace.NewAggregate(errors...)
} | |
c23393 | node.Wait(); err != nil {
errors = append(errors, err)
log.Errorf("failed stopping extra node %v", err)
}
}
return trace.NewAggregate(errors...)
} | |
c23394 | return
}
defer sconn.Close()
// Success, we're proxying data now.
p.Lock()
p.count = p.count + 1
p.Unlock()
// Copy from src to dst and dst to src.
errc := make(chan error, 2)
replicate := func(dst io.Writer, src io.Reader) {
_, err := io.Copy(dst, src)
errc <- err
}
go replicate(sconn, dconn)
go re... | |
c23395 | defer p.Unlock()
return p.count
} | |
c23396 | agent can understand
publicKey, _, _, _, err := ssh.ParseAuthorizedKey(certificateBytes)
if err != nil {
return nil, "", "", trace.Wrap(err)
}
privateKey, err := ssh.ParseRawPrivateKey(privateKeyByte)
if err != nil {
return nil, "", "", trace.Wrap(err)
}
agentKey := agent.AddedKey{
PrivateKey: priva... | |
c23397 | {
return func(k *Keygen) error {
k.clock = clock
return nil
}
} | |
c23398 |
k.precomputeCount = count
return nil
}
} | |
c23399 |
log.Debugf("SSH cert authority is going to pre-compute %v keys.", k.precomputeCount)
k.keysCh = make(chan keyPair, k.precomputeCount)
go k.precomputeKeys()
} else {
log.Debugf("SSH cert authority started with no keys pre-compute.")
}
return k, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.