id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c23600 | playback control goroutine
go func() {
defer player.Stop()
key := make([]byte, 1)
for {
_, err = os.Stdin.Read(key)
if err != nil {
return
}
switch key[0] {
// Ctrl+C or Ctrl+D
case keyCtrlC, keyCtrlD:
return
// Space key
case keySpace:
player.TogglePause()
// <- arrow
... | |
c23601 | }
nodeClient, err := proxyClient.ConnectToNode(
ctx,
nodeAddrs[0]+"@"+tc.Namespace+"@"+clusterInfo.Name,
tc.Config.HostLogin,
false)
if err != nil {
tc.ExitStatus = 1
return trace.Wrap(err)
}
err = nodeClient.ExecuteSCP(cmd)
if err != nil {
// converts SSH error code to tc.ExitStatus
exitError, ... | |
c23602 | := tc.ConnectToProxy(ctx)
if err != nil {
return nil, trace.Wrap(err)
}
defer proxyClient.Close()
return proxyClient.FindServersByLabels(ctx, tc.Namespace, tc.Labels)
} | |
c23603 | originErr := trace.Unwrap(err)
exitErr, ok := originErr.(*ssh.ExitError)
if ok {
tc.ExitStatus = exitErr.ExitStatus()
} else {
// if an error occurs, but no exit status is passed back, GoSSH returns
// a generic error like this. in this case the error message is printed
// to stderr by ... | |
c23604 |
if !tc.Config.SkipLocalAuth && tc.LocalAgent() != nil {
signers, err := tc.LocalAgent().Signers()
if err != nil || len(signers) == 0 {
return proxyPrincipal
}
cert, ok := signers[0].PublicKey().(*ssh.Certificate)
if ok && len(cert.ValidPrincipals) > 0 {
return cert.ValidPrincipals[0]
}
}
return pr... | |
c23605 | return proxyClient, trace.Wrap(err)
// The passed in context timed out. This is often due to the network being
// down and the user hitting Ctrl-C.
case <-ctx.Done():
return nil, trace.ConnectionProblem(ctx.Err(), "connection canceled")
}
} | |
c23606 | sshConfig.Auth = []ssh.AuthMethod{m}
sshClient, err = ssh.Dial("tcp", tc.Config.SSHProxyAddr, sshConfig)
if err != nil {
return nil, trace.Wrap(err)
}
log.Infof(successMsg)
return makeProxyClient(sshClient, m), nil
}
// we have exhausted all auth existing auth methods and local login
// is disabled in... | |
c23607 |
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23608 | nil {
return trace.Wrap(err)
}
return nil
} | |
c23609 |
if err != nil {
return nil, trace.Wrap(err)
}
defer proxyClient.Close()
// Get a client to the Auth Server.
clt, err := proxyClient.ClusterAccessPoint(ctx, clusterName, true)
if err != nil {
return nil, trace.Wrap(err)
}
// Get the list of host certificates that this cluster knows about.
return clt.GetC... | |
c23610 | tc.WebProxyAddr = net.JoinHostPort(addr.Host(), strconv.Itoa(addr.Port(defaults.HTTPListenPort)))
// Update local agent (that reads/writes to ~/.tsh) with the new address
// of the web proxy. This will control where the keys are stored on disk
// after login.
tc.localAgent.UpdateProxyHost(addr.Host())
}
//... | |
c23611 |
// only host CA has TLS certificates, user CA will overwrite trusted certs
// to empty file if called
if ca.GetType() == services.HostCA {
err = tc.LocalAgent().SaveCerts(auth.AuthoritiesToTrustedCerts([]services.CertAuthority{ca}))
if err != nil {
return trace.Wrap(err)
}
}
return nil
} | |
c23612 | trace.Wrap(err)
}
}
// ask the CA (via proxy) to sign our public key:
response, err := tc.credClient.SSHAgentLogin(
ctx,
tc.Config.Username,
password,
otpToken,
pub,
tc.KeyTTL,
tc.CertificateFormat)
return response, trace.Wrap(err)
} | |
c23613 | TTL: tc.KeyTTL,
Protocol: protocol,
Compatibility: tc.CertificateFormat,
BindAddr: tc.BindAddr,
})
return response, trace.Wrap(err)
} | |
c23614 | {
return nil, trace.Wrap(err)
}
password, err := tc.AskPassword()
if err != nil {
return nil, trace.Wrap(err)
}
response, err := tc.credClient.SSHAgentU2FLogin(
ctx,
tc.Config.Username,
password,
pub,
tc.KeyTTL,
tc.CertificateFormat)
return response, trace.Wrap(err)
} | |
c23615 | blocking, keep blocking until
// the passed in context in canceled.
select {
case tc.eventsCh <- e:
return nil
case <-ctx.Done():
return trace.Wrap(ctx.Err())
}
} | |
c23616 |
block, pemByte = pem.Decode(pemByte)
if block == nil {
break
}
cert, err := x509.ParseCertificate(block.Bytes)
if err != nil {
log.Debugf("could not parse cert in: %v, err: %v", certPath, err)
return nil
}
certPool.AddCert(cert)
}
log.Debugf("using local pool for loopback proxy: %v, err: %v", ... | |
c23617 | nil
}
log.Infof("[KEY AGENT] Connected to the system agent: %q", socketPath)
return agent.NewClient(conn)
} | |
c23618 | "", trace.Wrap(err)
}
return u.Username, nil
} | |
c23619 | nil {
fmt.Fprintln(tc.Stderr, err)
return "", trace.Wrap(err)
}
return token, nil
} | |
c23620 | err != nil {
fmt.Fprintln(tc.Stderr, err)
return "", trace.Wrap(err)
}
return pwd, nil
} | |
c23621 | reading terminal state: %v", err)
} else {
signal.Notify(sigCh, syscall.SIGINT)
go func() {
select {
case <-sigCh:
terminal.Restore(int(fd), state)
os.Exit(1)
case <-closeCh:
}
}()
}
defer func() {
close(closeCh)
}()
bytes, err := terminal.ReadPassword(int(fd))
return string(bytes), ... | |
c23622 | bufio.NewReader(os.Stdin).ReadLine()
return string(bytes), err
} | |
c23623 |
retval = append(retval, p.ToString())
}
return retval
} | |
c23624 | remote net.Addr, key ssh.PublicKey) error {
return nil
} | |
c23625 | != nil {
return nil, trace.Wrap(err)
}
return channel, nil
} | |
c23626 | utils.NewChConn(c.sconn, channel)
} | |
c23627 | {
return nil
}
c.log.Debugf("Proxy %v sending %v discovery request with tunnel ID: %v and disconnected proxies: %v.",
c.proxyName, string(c.tunnelType), c.tunnelID, Proxies(disconnectedProxies))
req := discoveryRequest{
TunnelID: c.tunnelID,
Type: string(c.tunnelType),
Proxies: disconnectedProxies,... | |
c23628 | err := c.accessPoint.GetProxies()
if err != nil {
return nil, trace.Wrap(err)
}
for i := range proxies {
proxy := proxies[i]
// A proxy should never add itself to the list of missing proxies.
if proxy.GetName() == c.proxyName {
continue
}
if !connected[proxy.GetName()] {
missing = append(missing... | |
c23629 | marshalDiscoveryRequest(req)
if err != nil {
return trace.Wrap(err)
}
_, err = discoveryCh.SendRequest(chanDiscoveryReq, false, payload)
if err != nil {
c.markInvalid(err)
return trace.Wrap(err)
}
return nil
} | |
c23630 | nil {
return nil, trace.Wrap(err)
}
conn, err := connectProxyTransport(sconn.Conn, RemoteAuthServer)
if err != nil {
return nil, trace.Wrap(err)
}
return conn, nil
}
} | |
c23631 |
// Pull the error message from the tunnel client (remote cluster)
// passed to us via stderr.
errMessage, _ := ioutil.ReadAll(channel.Stderr())
if errMessage == nil {
errMessage = []byte("failed connecting to " + addr)
}
return nil, trace.Errorf(strings.TrimSpace(string(errMessage)))
}
return utils.... | |
c23632 |
return c.Close()
}
return nil
} | |
c23633 | range process.connectors {
out = append(out, process.connectors[role])
}
return out
} | |
c23634 |
process.connectors[connector.ClientIdentity.ID.Role] = connector
} | |
c23635 | srv, err = waitAndReload(ctx, cfg, srv, newTeleport)
if err != nil {
// This error means that was a clean shutdown
// and no reload is necessary.
if err == ErrTeleportExited {
return nil
}
return trace.Wrap(err)
}
}
} | |
c23636 | := process.Close(); err != nil {
process.Warningf("Failed to shutdown process: %v.", err)
}
return
}
if err := process.writeToSignalPipe(signalPipe, fmt.Sprintf("Process %v has started.", os.Getpid())); err != nil {
process.Warningf("Failed to write to signal pipe: %v", err)
// despite the failure, it's ... | |
c23637 | nil, trace.Wrap(err)
}
if !isAdmin {
return nil, nil, nil
}
uid := os.Getuid()
gid := teleport.LinuxAdminGID
return &uid, &gid, nil
} | |
c23638 |
handler, err := filesessions.NewHandler(filesessions.Config{
Directory: uri.Path,
})
if err != nil {
return nil, trace.Wrap(err)
}
return handler, nil
default:
return nil, trace.BadParameter(
"unsupported scheme for audit_sesions_uri: %q, currently supported schemes are %q and %q",
uri.Scheme,... | |
c23639 | return nil, trace.BadParameter(
"unsupported scheme for audit_events_uri: %q, currently supported schemes are %q and %q",
uri.Scheme, dynamo.GetName(), teleport.SchemeFile)
}
}
// only file external loggers are prohibited (they are not supposed
// to be used on their own, only in combo with external logge... | |
c23640 | process.WaitForEvent(context.TODO(), TeleportExitEvent, eventC)
select {
case event := <-eventC:
callback(event.Payload)
}
return nil
})
} | |
c23641 | nil, trace.Wrap(err)
}
return cache.New(cfg.setup(cache.Config{
Context: process.ExitContext(),
Backend: reporter,
Events: cfg.services,
ClusterConfig: cfg.services,
Provisioner: cfg.services,
Trust: cfg.services,
Users: cfg.services,
Access: ... | |
c23642 | NeverExpires: process.Config.CachePolicy.NeverExpires,
MaxTTL: process.Config.CachePolicy.TTL,
}
return config
}
} | |
c23643 |
return process.newLocalCache(clt, cache.ForProxy, cacheName)
} | |
c23644 |
setup: process.setupCachePolicy(setupConfig),
cacheName: cacheName,
})
if err != nil {
return nil, trace.Wrap(err)
}
return auth.NewWrapper(clt, cache), nil
} | |
c23645 | if err != nil {
return trace.Wrap(err)
}
process.onExit(fmt.Sprintf("auth.client.%v", serviceName), func(interface{}) {
process.Debugf("Closed client for %v.", role)
err := connector.Client.Close()
if err != nil {
process.Debugf("Failed to close client: %v", err)
}
})
process.BroadcastEvent(... | |
c23646 |
addrs = process.Config.Auth.PublicAddrs
case teleport.RoleNode:
addrs = process.Config.SSH.PublicAddrs
// If advertise IP is set, add it to the list of principals. Otherwise
// add in the default (0.0.0.0) which will be replaced by the Auth Server
// when a host certificate is issued.
if process.Config.Ad... | |
c23647 |
bk = litebk
// DynamoDB backend:
case dynamo.GetName():
bk, err = dynamo.New(context.TODO(), bc.Params)
// etcd backend:
case etcdbk.GetName():
bk, err = etcdbk.New(context.TODO(), bc.Params)
default:
err = trace.BadParameter("unsupported secrets storage type: %q", bc.Type)
}
if err != nil {
return ni... | |
c23648 |
process.Supervisor.Wait()
}()
select {
case <-local.Done():
return
}
} | |
c23649 | localAuth != nil {
if err := process.localAuth.Close(); err != nil {
process.Warningf("Failed closing auth server: %v.", err)
}
}
}()
go process.printShutdownStatus(localCtx)
return localCtx
} | |
c23650 | {
case <-localCtx.Done():
process.Debugf("Process completed.")
}
} | |
c23651 | if process.storage != nil {
errors = append(errors, process.storage.Close())
}
return trace.NewAggregate(errors...)
} | |
c23652 | %v.", keyPath, certPath)
creds, err := utils.GenerateSelfSignedCert([]string{cfg.Hostname, "localhost"})
if err != nil {
return trace.Wrap(err)
}
if err := ioutil.WriteFile(keyPath, creds.PrivateKey, 0600); err != nil {
return trace.Wrap(err, "error writing key PEM")
}
if err := ioutil.WriteFile(certPath, ... | |
c23653 | err = rest.InClusterConfig()
if err != nil {
return nil, nil, trace.Wrap(err)
}
}
client, err = kubernetes.NewForConfig(config)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return client, config, nil
} | |
c23654 | {
return clientcmd.BuildConfigFromFlags("", configPath)
}
return rest.InClusterConfig()
} | |
c23655 | ProvisionToken {
t, err := NewProvisionToken(token, roles, expires)
if err != nil {
panic(err)
}
return t
} | |
c23656 |
Namespace: defaults.Namespace,
},
Spec: ProvisionTokenSpecV2{
Roles: roles,
},
}
if err := t.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return t, nil
} | |
c23657 | := make([]ProvisionTokenV1, len(in))
for i := range in {
out[i] = *in[i].V1()
}
return out
} | |
c23658 | := make([]ProvisionToken, len(in))
for i := range in {
out[i] = in[i].V2()
}
return out
} | |
c23659 | teleport.Roles) {
p.Spec.Roles = r
} | |
c23660 |
} else {
if err := utils.UnmarshalWithSchema(GetProvisionTokenSchema(), &p, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := p.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
p.SetResourceID(cfg.ID)
}
return &p, nil
}
retur... | |
c23661 | return utils.FastMarshal(v.V1())
case V2:
v, ok := t.(token2)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V2)
}
return utils.FastMarshal(v.V2())
default:
return nil, trace.BadParameter("version %v is not supported", version)
}
} | |
c23662 | return nil, err
}
if config.Timeout > 0 {
conn.SetReadDeadline(time.Time{})
}
return ssh.NewClient(c, chans, reqs), nil
} | |
c23663 | nil {
return nil, err
}
return NewClientConnWithDeadline(conn, addr, config)
} | |
c23664 |
return DialWithDeadline(network, addr, config)
} | |
c23665 |
if config.Timeout > 0 {
pconn.SetReadDeadline(time.Now().Add(config.Timeout))
}
// Do the same as ssh.Dial but pass in proxy connection.
c, chans, reqs, err := ssh.NewClientConn(pconn, addr, config)
if err != nil {
return nil, trace.Wrap(err)
}
if config.Timeout > 0 {
pconn.SetReadDeadline(time.Time{})
}... | |
c23666 | proxy set in environment, returning direct dialer.")
return directDial{}
}
log.Debugf("Found proxy %q in environment, returning proxy dialer.", proxyAddr)
return proxyDial{proxyHost: proxyAddr}
} | |
c23667 | cfg.Nodes,
cancelC: make(chan bool, 1),
stopC: make(chan bool, 1),
clock: clockwork.NewRealClock(),
cancel: cancel,
ctx: closeCtx,
watchStarted: watchStarted,
signalWatchStart: signalWatchStart,
buf: buf,
}
if err = b.reconnect(... | |
c23668 | happen in case of lease keep-alive
var opts []clientv3.OpOption
var newLease backend.Lease
if err := b.setupLease(ctx, backend.Item{Expires: expires}, &newLease, &opts); err != nil {
return trace.Wrap(err)
}
opts = append(opts, clientv3.WithIgnoreValue())
kv := re.Kvs[0]
_, err = b.client.Put(ctx, string(kv.K... | |
c23669 |
if i <= 0 {
i = 1
}
return i
} | |
c23670 | err != nil {
return trace.Wrap(err)
}
err = ioutil.WriteFile(a.genPubPath, pubBytes, 0600)
if err != nil {
return trace.Wrap(err)
}
err = ioutil.WriteFile(a.genPrivPath, privBytes, 0600)
if err != nil {
return trace.Wrap(err)
}
fmt.Printf("wrote public key to: %v and private key to: %v\n", a.genPubPath... | |
c23671 | "":
return a.generateHostKeys(clusterApi)
default:
return trace.BadParameter("--user or --host must be specified")
}
} | |
c23672 | else {
req.Mode = services.RotationModeAuto
}
if err := client.RotateCertAuthority(req); err != nil {
return err
}
if a.rotateTargetPhase != "" {
fmt.Printf("Updated rotation phase to %q. To check status use 'tctl status'\n", a.rotateTargetPhase)
} else {
fmt.Printf("Initiated certificate authority rotati... | |
c23673 | _, o := range opts {
if err := o(&cfg); err != nil {
return nil, trace.Wrap(err)
}
}
return &cfg, nil
} | |
c23674 | return trace.BadParameter("locks cannot exceed %v", MaxLockDuration)
}
return nil
} | |
c23675 | := t.UTC().Sub(clock.Now().UTC())
if diff < 0 {
return Forever
}
return diff
} | |
c23676 |
if !t.IsZero() {
return TTL(clock, t)
}
}
return Forever
} | |
c23677 |
return nil, trace.Wrap(err)
}
limiter.ConnLimiter, err = connlimit.New(
nil, ipExtractor, config.MaxConnections)
if err != nil {
return nil, trace.Wrap(err)
}
return &limiter, nil
} | |
c23678 |
l.ConnLimiter.Wrap(h)
} | |
c23679 | l.maxConnections {
return trace.LimitExceeded(
"too many connections from %v: %v, max is %v",
token, numberOfConnections, l.maxConnections)
}
l.connections[token] = numberOfConnections + 1
return nil
} | |
c23680 | {
if numberOfConnections <= 1 {
delete(l.connections, token)
} else {
l.connections[token] = numberOfConnections - 1
}
}
} | |
c23681 | {
return b
}
if b == 0 {
return a
}
if a < b {
return a
}
return b
} | |
c23682 | tm.IsZero() || tm.Before(now) {
return 0
}
return tm.Sub(now)
} | |
c23683 | for tests
*t = time.Time{}
return
}
*t = t.UTC()
} | |
c23684 | return trace.BadParameter("missing U2F sign response")
}
return s.CheckU2FSignResponse(userID, req.U2FSignResponse)
}
return trace.BadParameter("unsupported second factor method: %q", secondFactor)
}
err = s.WithUserLock(userID, fn)
if err != nil {
return trace.Wrap(err)
}
return trace.Wrap(s.Up... | |
c23685 | fakePasswordHash
}
if err = bcrypt.CompareHashAndPassword(hash, password); err != nil {
log.Debugf("Password for %q does not match", user)
return trace.BadParameter(errMsg)
}
return nil
} | |
c23686 |
// create the qr code
otpQR, err := utils.GenerateQRCode(otpURL)
if err != nil {
return "", nil, trace.Wrap(err)
}
return otpURL, otpQR, nil
} | |
c23687 | resource, err := ctx.GetResource()
if err != nil {
if trace.IsNotFound(err) {
return "", nil
}
return nil, trace.Wrap(err)
}
ca, ok := resource.(CertAuthority)
if !ok {
return "", nil
}
return string(ca.GetType()), nil
},
},
GetIdentifier: ctx.GetIdentifier,
G... | |
c23688 | NewLogActionFn(ctx),
},
GetIdentifier: ctx.GetIdentifier,
GetProperty: predicate.GetStringMapValue,
})
} | |
c23689 | && writer != nil {
l.writer = writer
}
return l.Log
} | |
c23690 | writer = log.StandardLogger().WriterLevel(ilevel)
}
writer.Write([]byte(fmt.Sprintf(format, args...)))
return true
}
} | |
c23691 | resource: %v", ctx.User, ctx.Resource)
} | |
c23692 | not set in the context")
}
return ctx.Resource, nil
} | |
c23693 |
case ResourceIdentifier:
var resource Resource
if ctx.Resource == nil {
resource = emptyResource
} else {
resource = ctx.Resource
}
return predicate.GetFieldByTag(resource, "json", fields[1:])
default:
return nil, trace.NotFound("%v is not defined", strings.Join(fields, "."))
}
} | |
c23694 | nil, trace.Wrap(err)
}
return Key(key), nil
} | |
c23695 |
nonce := make([]byte, aesgcm.NonceSize())
_, err = io.ReadFull(rand.Reader, nonce)
if err != nil {
return nil, trace.Wrap(err)
}
ciphertext, err := json.Marshal(&sealedData{
Ciphertext: aesgcm.Seal(nil, nonce, plaintext, nil),
Nonce: nonce,
})
if err != nil {
return nil, trace.Wrap(err)
}
retu... | |
c23696 | err != nil {
return nil, trace.Wrap(err)
}
aesgcm, err := cipher.NewGCM(block)
if err != nil {
return nil, trace.Wrap(err)
}
plaintext, err := aesgcm.Open(nil, data.Nonce, data.Ciphertext, nil)
if err != nil {
return nil, trace.Wrap(err)
}
return plaintext, nil
} | |
c23697 | cfg.ServerID,
Clock: cfg.Clock,
})
if err != nil {
return nil, trace.Wrap(err)
}
return &Forwarder{
ForwarderConfig: cfg,
sessionLogger: diskLogger,
}, nil
} | |
c23698 | }
l.isClosed = true
return l.sessionLogger.Finalize()
} | |
c23699 | l.ForwardTo.WaitForDelivery(ctx)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.