func NewCmdPGPVerify(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "verify",
Usage: "PGP verify message or file signatures for keybase users",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdPGPVerify{Contextified: libkb.NewContextified(g)}, "verify", c)
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "l, local",
Usage: "Only track locally, don't send a statement to the server.",
},
cli.BoolFlag{
Name: "y",
Usage: "Approve remote tracking without prompting.",
},
cli.StringFlag{
Name: "m, message",
Usage: "Provide the message on the command line.",
},
cli.StringFlag{
Name: "i, infile",
Usage: "Specify an input file.",
},
cli.StringFlag{
Name: "d, detached",
Usage: "Specify a detached signature file.",
},
cli.StringFlag{
Name: "S, signed-by",
Usage: "Assert signed by the given user (can use user assertion format).",
},
},
}
}
func NewConfigHandler(xp rpc.Transporter, g *libkb.GlobalContext, svc *Service) *ConfigHandler {
return &ConfigHandler{
Contextified: libkb.NewContextified(g),
xp: xp,
svc: svc,
}
}
func NewCmdSign(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "sign",
Usage: "Sign a document",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdSign{Contextified: libkb.NewContextified(g)}, "sign", c)
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "b, binary",
Usage: "Output binary message (default is armored).",
},
cli.BoolFlag{
Name: "d, detached",
Usage: "Detached signature (default is attached).",
},
cli.StringFlag{
Name: "i, infile",
Usage: "Specify an input file.",
},
cli.StringFlag{
Name: "m, message",
Usage: "Provide the message to sign on the command line.",
},
cli.StringFlag{
Name: "o, outfile",
Usage: "Specify an outfile (default is STDOUT).",
},
},
}
}
// NewLogHandler creates a LogHandler for the xp transport.
func NewLogHandler(xp rpc.Transporter, logReg *logRegister, g *libkb.GlobalContext) *LogHandler {
return &LogHandler{
BaseHandler: NewBaseHandler(xp),
logReg: logReg,
Contextified: libkb.NewContextified(g),
}
}
func NewRevokeKeyEngine(kid keybase1.KID, g *libkb.GlobalContext) *RevokeEngine {
return &RevokeEngine{
kid: kid,
mode: RevokeKey,
Contextified: libkb.NewContextified(g),
}
}
func NewSecretEntry(g *libkb.GlobalContext, t *Terminal, tty string) *SecretEntry {
return &SecretEntry{
Contextified: libkb.NewContextified(g),
terminal: t,
tty: tty,
}
}
// NewXLogin creates a XLogin engine. username is optional.
// deviceType should be libkb.DeviceTypeDesktop or
// libkb.DeviceTypeMobile.
func NewXLogin(g *libkb.GlobalContext, deviceType, username string) *XLogin {
return &XLogin{
Contextified: libkb.NewContextified(g),
deviceType: deviceType,
username: username,
}
}
func NewLocksmith(arg *LocksmithArg, g *libkb.GlobalContext) *Locksmith {
return &Locksmith{
Contextified: libkb.NewContextified(g),
arg: arg,
canceled: make(chan struct{}),
}
}
func NewPGPKeyExportByKIDEngine(arg keybase1.PGPExportByKIDArg, g *libkb.GlobalContext) *PGPKeyExportEngine {
return &PGPKeyExportEngine{
arg: arg.Options,
qtype: kid,
Contextified: libkb.NewContextified(g),
}
}
func NewBTCEngine(address string, force bool, g *libkb.GlobalContext) *BTCEngine {
return &BTCEngine{
address: address,
force: force,
Contextified: libkb.NewContextified(g),
}
}
func NewResolveThenIdentify2WithTrack(g *libkb.GlobalContext, arg *keybase1.Identify2Arg, topts keybase1.TrackOptions) *ResolveThenIdentify2 {
return &ResolveThenIdentify2{
Contextified: libkb.NewContextified(g),
arg: arg,
trackOptions: topts,
}
}
func (c *CmdDecrypt) ParseArgv(ctx *cli.Context) error {
if len(ctx.Args()) > 0 {
return UnexpectedArgsError("decrypt")
}
interactive := ctx.Bool("interactive")
c.spui = &SaltpackUI{
Contextified: libkb.NewContextified(c.G()),
interactive: interactive,
force: ctx.Bool("force"),
}
c.opts.Interactive = interactive
c.opts.UsePaperKey = ctx.Bool("paperkey")
msg := ctx.String("message")
outfile := ctx.String("outfile")
infile := ctx.String("infile")
senderfile := ctx.String("encryptor-outfile")
if err := c.filter.FilterInit(msg, infile, outfile); err != nil {
return err
}
if senderfile != "" {
c.senderfile = NewFileSink(senderfile)
}
return nil
}
func NewCmdTestFSNotify(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "test-fsnotify",
Usage: "Test kbfs notifications",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdTestFSNotify{Contextified: libkb.NewContextified(g)}, "test-fsnotify", c)
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "p, public",
Usage: "public top level folder",
},
cli.StringFlag{
Name: "f, filename",
Usage: "filename",
},
cli.StringFlag{
Name: "a, action",
Usage: "[encrypting|decrypting|signing|verifying|rekeying]",
},
cli.StringFlag{
Name: "delay",
Usage: "delay between start and finish calls",
},
},
}
}
func NewCmdVersionRunner(g *libkb.GlobalContext) *CmdVersion {
return &CmdVersion{
mode: modeNormal,
svc: true,
Contextified: libkb.NewContextified(g),
}
}
func NewIdentifyUIHandler(g *libkb.GlobalContext, connID libkb.ConnectionID) IdentifyUIHandler {
return IdentifyUIHandler{
Contextified: libkb.NewContextified(g),
connID: connID,
alwaysAlive: false,
}
}
func NewPGPKeyExportByFingerprintEngine(arg keybase1.PGPExportByFingerprintArg, g *libkb.GlobalContext) *PGPKeyExportEngine {
return &PGPKeyExportEngine{
arg: arg.Options,
qtype: fingerprint,
Contextified: libkb.NewContextified(g),
}
}
func newGregorFirehoseHandler(g *libkb.GlobalContext, connID libkb.ConnectionID, xp rpc.Transporter) *gregorFirehoseHandler {
return &gregorFirehoseHandler{
Contextified: libkb.NewContextified(g),
connID: connID,
cli: keybase1.GregorUIClient{Cli: rpc.NewClient(xp, libkb.ErrorUnwrapper{})},
}
}
func NewCmdLoginRunner(g *libkb.GlobalContext) *CmdLogin {
return &CmdLogin{
Contextified: libkb.NewContextified(g),
clientType: keybase1.ClientType_CLI,
done: make(chan struct{}, 1),
}
}
func NewRevokeKeyEngine(kid string, g *libkb.GlobalContext) *RevokeEngine {
return &RevokeEngine{
kidString: kid,
mode: RevokeKey,
Contextified: libkb.NewContextified(g),
}
}
func NewCtlHandler(xp rpc.Transporter, v *Service, g *libkb.GlobalContext) *CtlHandler {
return &CtlHandler{
BaseHandler: NewBaseHandler(xp),
Contextified: libkb.NewContextified(g),
service: v,
}
}
func NewCmdPGPDecrypt(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "decrypt",
Usage: "PGP decrypt messages or files for keybase users",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdPGPDecrypt{Contextified: libkb.NewContextified(g)}, "decrypt", c)
},
Flags: []cli.Flag{
cli.StringFlag{
Name: "i, infile",
Usage: "Specify an input file.",
},
cli.StringFlag{
Name: "m, message",
Usage: "Provide the message on the command line.",
},
cli.StringFlag{
Name: "o, outfile",
Usage: "Specify an outfile (stdout by default).",
},
cli.BoolFlag{
Name: "s, signed",
Usage: "Assert signed.",
},
cli.StringFlag{
Name: "S, signed-by",
Usage: "Assert signed by the given user (can use user assertion format).",
},
},
Description: `Use of this command requires at least one PGP secret key imported
into the local Keybase keyring. It will try all secret keys in the local keyring that match the
given ciphertext, and will succeed so long as one such key is available.`,
}
}
// NewKex2Provisioner creates a Kex2Provisioner engine.
func NewKex2Provisioner(g *libkb.GlobalContext, secret kex2.Secret) *Kex2Provisioner {
return &Kex2Provisioner{
Contextified: libkb.NewContextified(g),
secret: secret,
secretCh: make(chan kex2.Secret),
}
}
func getUserCard(g *libkb.GlobalContext, uid keybase1.UID, useSession bool) (ret *keybase1.UserCard, err error) {
defer g.Trace("getUserCard", func() error { return err })()
arg := libkb.APIArg{
Endpoint: "user/card",
NeedSession: useSession,
Contextified: libkb.NewContextified(g),
Args: libkb.HTTPArgs{"uid": libkb.S{Val: uid.String()}},
}
var card card
if err = g.API.GetDecode(arg, &card); err != nil {
g.Log.Warning("error getting user/card for %s: %s\n", uid, err)
return nil, err
}
g.Log.Debug("user card: %+v", card)
ret = &keybase1.UserCard{
Following: card.FollowSummary.Following,
Followers: card.FollowSummary.Followers,
Uid: uid,
FullName: card.Profile.FullName,
Location: card.Profile.Location,
Bio: card.Profile.Bio,
Website: card.Profile.Website,
Twitter: card.Profile.Twitter,
YouFollowThem: card.YouFollowThem,
TheyFollowYou: card.TheyFollowYou,
}
return ret, nil
}
func NewPGPPullEngine(arg *PGPPullEngineArg, g *libkb.GlobalContext) *PGPPullEngine {
return &PGPPullEngine{
listTrackingEngine: NewListTrackingEngine(&ListTrackingEngineArg{}, g),
userAsserts: arg.UserAsserts,
Contextified: libkb.NewContextified(g),
}
}
// NewDeviceKeyfinder creates a DeviceKeyfinder engine.
func NewDeviceKeyfinder(g *libkb.GlobalContext, arg DeviceKeyfinderArg) *DeviceKeyfinder {
return &DeviceKeyfinder{
Contextified: libkb.NewContextified(g),
arg: arg,
userMap: make(map[keybase1.UID](*keybase1.UserPlusKeys)),
}
}
func (a *APIServerHandler) setupArg(arg GenericArg) libkb.APIArg {
// Form http arg dict
kbargs := make(libkb.HTTPArgs)
for _, harg := range arg.GetHTTPArgs() {
kbargs[harg.Key] = libkb.S{Val: harg.Value}
}
// Acceptable http status list
var httpStatuses []int
for _, hstat := range arg.GetHttpStatuses() {
httpStatuses = append(httpStatuses, hstat)
}
// Acceptable app status code list
var appStatusCodes []int
for _, ac := range arg.GetAppStatusCodes() {
appStatusCodes = append(appStatusCodes, ac)
}
// Do the API call
kbarg := libkb.APIArg{
Endpoint: arg.GetEndpoint(),
NeedSession: true,
Args: kbargs,
HTTPStatus: httpStatuses,
AppStatusCodes: appStatusCodes,
Contextified: libkb.NewContextified(a.G()),
}
return kbarg
}
// NewDelegateUICtlHandler creates a new handler for setting up notification
// channels
func NewDelegateUICtlHandler(xp rpc.Transporter, id libkb.ConnectionID, g *libkb.GlobalContext) *DelegateUICtlHandler {
return &DelegateUICtlHandler{
Contextified: libkb.NewContextified(g),
BaseHandler: NewBaseHandler(xp),
id: id,
}
}
func newGregorRPCHandler(xp rpc.Transporter, g *libkb.GlobalContext, gh *gregorHandler) *gregorRPCHandler {
return &gregorRPCHandler{
Contextified: libkb.NewContextified(g),
xp: xp,
gh: gh,
}
}
func (e *Kex2Provisionee) dhKeyProof(dh libkb.GenericKey, eldestKID keybase1.KID, seqno int, linkID libkb.LinkID) (sig string, sigID keybase1.SigID, err error) {
delg := libkb.Delegator{
ExistingKey: e.eddsa,
NewKey: dh,
DelegationType: libkb.SubkeyType,
Expire: libkb.NaclDHExpireIn,
EldestKID: eldestKID,
Device: e.device,
LastSeqno: libkb.Seqno(seqno),
PrevLinkID: linkID,
SigningUser: e,
Contextified: libkb.NewContextified(e.G()),
}
jw, err := libkb.KeyProof(delg)
if err != nil {
return "", "", err
}
e.G().Log.Debug("dh key proof: %s", jw.MarshalPretty())
dhSig, dhSigID, _, err := libkb.SignJSON(jw, e.eddsa)
if err != nil {
return "", "", err
}
return dhSig, dhSigID, nil
}
func (h *BaseHandler) getSecretUI(sessionID int, g *libkb.GlobalContext) libkb.SecretUI {
return &SecretUI{
sessionID: sessionID,
cli: h.getSecretUICli(),
Contextified: libkb.NewContextified(g),
}
}
