/
cmd_pgp_sign.go
138 lines (119 loc) · 3.33 KB
/
cmd_pgp_sign.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
// Copyright 2015 Keybase, Inc. All rights reserved. Use of
// this source code is governed by the included BSD license.
package client
import (
"fmt"
"golang.org/x/net/context"
"github.com/keybase/cli"
"github.com/keybase/client/go/engine"
"github.com/keybase/client/go/libcmdline"
"github.com/keybase/client/go/libkb"
keybase1 "github.com/keybase/client/go/protocol/keybase1"
"github.com/keybase/go-framed-msgpack-rpc/rpc"
)
func NewCmdPGPSign(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "sign",
Usage: "PGP sign a document.",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdPGPSign{Contextified: libkb.NewContextified(g)}, "sign", c)
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "b, binary",
Usage: "Output binary message (default is armored).",
},
cli.BoolFlag{
Name: "c, clearsign",
Usage: "Generate a clearsigned text signature.",
},
cli.BoolFlag{
Name: "d, detached",
Usage: "Detached signature (default is attached).",
},
cli.StringFlag{
Name: "i, infile",
Usage: "Specify an input file.",
},
cli.StringFlag{
Name: "k, key",
Usage: "Specify a key to use for signing (otherwise most recent PGP key is used).",
},
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).",
},
cli.BoolFlag{
Name: "t, text",
Usage: "Treat input data as text and canonicalize.",
},
},
Description: `Use the PGP secret key in your local Keybase keyring to PGP sign
a file. If you have several keys, you can specify a particular signing key with
the "--key" flag; otherwise, the most recent PGP key is used.
Since this command uses only your Keybase keyring, it does not access the GnuPG
keyring.`,
}
}
type CmdPGPSign struct {
libkb.Contextified
UnixFilter
msg string
opts keybase1.PGPSignOptions
arg engine.PGPSignArg
}
func (s *CmdPGPSign) ParseArgv(ctx *cli.Context) error {
if len(ctx.Args()) > 0 {
return UnexpectedArgsError("pgp sign")
}
s.opts.BinaryOut = ctx.Bool("binary")
s.opts.BinaryIn = !ctx.Bool("text")
msg := ctx.String("message")
outfile := ctx.String("outfile")
infile := ctx.String("infile")
clr := ctx.Bool("clearsign")
dtch := ctx.Bool("detached")
if clr && dtch {
return fmt.Errorf("Can't specify both -c and -d")
}
if clr {
s.opts.Mode = keybase1.SignMode_CLEAR
} else if dtch {
s.opts.Mode = keybase1.SignMode_DETACHED
} else {
s.opts.Mode = keybase1.SignMode_ATTACHED
}
s.opts.KeyQuery = ctx.String("key")
return s.FilterInit(s.G(), msg, infile, outfile)
}
func (s *CmdPGPSign) Run() (err error) {
protocols := []rpc.Protocol{
NewStreamUIProtocol(s.G()),
NewSecretUIProtocol(s.G()),
}
cli, err := GetPGPClient(s.G())
if err != nil {
return err
}
if err = RegisterProtocolsWithContext(protocols, s.G()); err != nil {
return err
}
snk, src, err := s.ClientFilterOpen(s.G())
if err == nil {
arg := keybase1.PGPSignArg{Source: src, Sink: snk, Opts: s.opts}
err = cli.PGPSign(context.TODO(), arg)
}
cerr := s.Close(err)
return libkb.PickFirstError(err, cerr)
}
func (s *CmdPGPSign) GetUsage() libkb.Usage {
return libkb.Usage{
Config: true,
API: true,
KbKeyring: true,
}
}