From 96173b86a178fc9b9d0ae807e635544de0053d99 Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Tue, 13 Feb 2018 01:44:27 +0100 Subject: ... --- cmd_check.go | 20 ++++++++-------- cmd_generate.go | 34 +++++++++++++------------- cmd_sign.go | 64 ++++++++++++++++++++++++------------------------- cmd_verify.go | 74 ++++++++++++++++++++++++++++----------------------------- main.go | 8 +++---- 5 files changed, 100 insertions(+), 100 deletions(-) diff --git a/cmd_check.go b/cmd_check.go index 2dfb786..bae501b 100644 --- a/cmd_check.go +++ b/cmd_check.go @@ -10,26 +10,26 @@ import ( // Usage: signify -C [-q] -p pubkey -x sigfile [file ...] -type checkCommand struct { +type checkCmd struct { quiet bool pubFile string sigFile string } -func (c *checkCommand) Name() string { return "check" } -func (c *checkCommand) Synopsis() string { return "check signatures" } -func (c *checkCommand) Usage() string { +func (m *checkCmd) Name() string { return "check" } +func (m *checkCmd) Synopsis() string { return "check signatures" } +func (m *checkCmd) Usage() string { return "check [-q] -p pubkey -x sigfile [file ...]\n" } -func (c *checkCommand) SetFlags(f *flag.FlagSet) { - f.BoolVar(&c.quiet, "q", false, "quiet mode") - f.StringVar(&c.pubFile, "p", "", "public key file (required)") - f.StringVar(&c.sigFile, "x", "", "signature file (required)") +func (m *checkCmd) SetFlags(f *flag.FlagSet) { + f.BoolVar(&m.quiet, "q", false, "quiet mode") + f.StringVar(&m.pubFile, "p", "", "public key file (required)") + f.StringVar(&m.sigFile, "x", "", "signature file (required)") } -func (c *checkCommand) Execute(ctx context.Context, f *flag.FlagSet, args ...interface{}) subcommands.ExitStatus { - if c.pubFile == "" || c.sigFile == "" { +func (m *checkCmd) Execute(ctx context.Context, f *flag.FlagSet, args ...interface{}) subcommands.ExitStatus { + if m.pubFile == "" || m.sigFile == "" { f.Usage() return subcommands.ExitUsageError } diff --git a/cmd_generate.go b/cmd_generate.go index 3d0e826..57391f6 100644 --- a/cmd_generate.go +++ b/cmd_generate.go @@ -15,38 +15,38 @@ import ( // Usage: signify -G [-n] [-c comment] -p pubkey -s seckey -type generateCommand struct { +type generateCmd struct { nopass bool comment string pubFile string secFile string } -func (g *generateCommand) Name() string { return "generate" } -func (g *generateCommand) Synopsis() string { return "generate key" } -func (g *generateCommand) Usage() string { +func (m *generateCmd) Name() string { return "generate" } +func (m *generateCmd) Synopsis() string { return "generate key" } +func (m *generateCmd) Usage() string { return "generate [-n] [-c comment] -p pubkey -s seckey\n" } -func (g *generateCommand) SetFlags(f *flag.FlagSet) { - f.BoolVar(&g.nopass, "n", false, "no key passphrase") - f.StringVar(&g.comment, "c", "signify", "comment") - f.StringVar(&g.pubFile, "p", "", "public key file (required)") - f.StringVar(&g.secFile, "s", "", "secret key file (required)") +func (m *generateCmd) SetFlags(f *flag.FlagSet) { + f.BoolVar(&m.nopass, "n", false, "no key passphrase") + f.StringVar(&m.comment, "c", "signify", "comment") + f.StringVar(&m.pubFile, "p", "", "public key file (required)") + f.StringVar(&m.secFile, "s", "", "secret key file (required)") } -func (g *generateCommand) Execute(ctx context.Context, f *flag.FlagSet, args ...interface{}) subcommands.ExitStatus { - if g.pubFile == "" || g.secFile == "" { +func (m *generateCmd) Execute(ctx context.Context, f *flag.FlagSet, args ...interface{}) subcommands.ExitStatus { + if m.pubFile == "" || m.secFile == "" { f.Usage() return subcommands.ExitUsageError } - if err := ValidateNames(g.pubFile, g.secFile); err != nil { + if err := ValidateNames(m.pubFile, m.secFile); err != nil { log.Println(err) return subcommands.ExitFailure } var der key.Deriver - if !g.nopass { + if !m.nopass { der = ask.Confirmed{} } @@ -56,11 +56,11 @@ func (g *generateCommand) Execute(ctx context.Context, f *flag.FlagSet, args ... return subcommands.ExitFailure } - if err := g.writeFile(g.secFile, "secret key", secKey, ModeSec); err != nil { + if err := m.writeFile(m.secFile, "secret key", secKey, ModeSec); err != nil { log.Println(err) return subcommands.ExitFailure } - if err := g.writeFile(g.pubFile, "public key", pubKey, ModePub); err != nil { + if err := m.writeFile(m.pubFile, "public key", pubKey, ModePub); err != nil { log.Println(err) return subcommands.ExitFailure } @@ -68,11 +68,11 @@ func (g *generateCommand) Execute(ctx context.Context, f *flag.FlagSet, args ... return subcommands.ExitSuccess } -func (g *generateCommand) writeFile(fname, comment string, u encoding.BinaryMarshaler, mode os.FileMode) error { +func (m *generateCmd) writeFile(fname, comment string, u encoding.BinaryMarshaler, mode os.FileMode) error { fd, err := Create(fname, mode) if err != nil { return err } defer fd.Close() - return b64file.Encode(fd, u, g.comment+" "+comment, nil) + return b64file.Encode(fd, u, m.comment+" "+comment, nil) } diff --git a/cmd_sign.go b/cmd_sign.go index 958e42f..e1d687c 100644 --- a/cmd_sign.go +++ b/cmd_sign.go @@ -15,7 +15,7 @@ import ( // Usage: signify -S [-ez] [-x sigfile] -s seckey -m message -type signCommand struct { +type signCmd struct { embed bool zip bool sigFile string @@ -23,40 +23,40 @@ type signCommand struct { msgFile string } -func (s *signCommand) Name() string { return "sign" } -func (s *signCommand) Synopsis() string { return "sign file" } -func (s *signCommand) Usage() string { +func (m *signCmd) Name() string { return "sign" } +func (m *signCmd) Synopsis() string { return "sign file" } +func (m *signCmd) Usage() string { return "sign [-ez] [-x sigfile] -s seckey -m message\n" } -func (s *signCommand) SetFlags(f *flag.FlagSet) { - f.BoolVar(&s.embed, "e", false, "embed the message") - f.BoolVar(&s.zip, "z", false, "sign gzip archive") // TODO - f.StringVar(&s.sigFile, "x", "", "signature file") - f.StringVar(&s.secFile, "s", "", "secret file (required)") - f.StringVar(&s.msgFile, "m", "", "message file (required)") +func (m *signCmd) SetFlags(f *flag.FlagSet) { + f.BoolVar(&m.embed, "e", false, "embed the message") + f.BoolVar(&m.zip, "z", false, "sign gzip archive") // TODO + f.StringVar(&m.sigFile, "x", "", "signature file") + f.StringVar(&m.secFile, "s", "", "secret file (required)") + f.StringVar(&m.msgFile, "m", "", "message file (required)") } -func (s *signCommand) Execute(ctx context.Context, f *flag.FlagSet, args ...interface{}) subcommands.ExitStatus { - if s.secFile == "" || s.msgFile == "" { +func (m *signCmd) Execute(ctx context.Context, f *flag.FlagSet, args ...interface{}) subcommands.ExitStatus { + if m.secFile == "" || m.msgFile == "" { f.Usage() return subcommands.ExitUsageError } - if s.sigFile == "" { - s.sigFile = SigName(s.msgFile) + if m.sigFile == "" { + m.sigFile = SigName(m.msgFile) } var err error switch { - case s.zip && s.embed: + case m.zip && m.embed: f.Usage() return subcommands.ExitUsageError - case s.zip: - err = s.zipped() - case s.embed: - err = s.embedded() + case m.zip: + err = m.zipped() + case m.embed: + err = m.embedded() default: - err = s.plain() + err = m.plain() } if err != nil { log.Println(err) @@ -66,18 +66,18 @@ func (s *signCommand) Execute(ctx context.Context, f *flag.FlagSet, args ...inte return subcommands.ExitSuccess } -func (s *signCommand) plain() error { - sec, err := openSec(s.secFile) +func (m *signCmd) plain() error { + sec, err := openSec(m.secFile) if err != nil { return err } - msg, err := ioutil.ReadFile(s.msgFile) + msg, err := ioutil.ReadFile(m.msgFile) if err != nil { return err } sig := sec.Sign(msg) - comment := VerifyWith(s.secFile) - fd, err := Create(s.sigFile, ModeSig) + comment := VerifyWith(m.secFile) + fd, err := Create(m.sigFile, ModeSig) if err != nil { return err } @@ -85,18 +85,18 @@ func (s *signCommand) plain() error { return b64file.Encode(fd, sig, comment, nil) } -func (s *signCommand) embedded() error { - sec, err := openSec(s.secFile) +func (m *signCmd) embedded() error { + sec, err := openSec(m.secFile) if err != nil { return err } - msg, err := ioutil.ReadFile(s.msgFile) + msg, err := ioutil.ReadFile(m.msgFile) if err != nil { return err } sig := sec.Sign(msg) - comment := VerifyWith(s.secFile) - fd, err := Create(s.sigFile, ModeSig) + comment := VerifyWith(m.secFile) + fd, err := Create(m.sigFile, ModeSig) if err != nil { return err } @@ -105,8 +105,8 @@ func (s *signCommand) embedded() error { } // TODO -func (s *signCommand) zipped() error { - fd, err := Open(s.msgFile) +func (m *signCmd) zipped() error { + fd, err := Open(m.msgFile) if err != nil { return err } diff --git a/cmd_verify.go b/cmd_verify.go index eaa25cf..148c75f 100644 --- a/cmd_verify.go +++ b/cmd_verify.go @@ -16,7 +16,7 @@ import ( // Usage: signify -V [-eqz] [-p pubkey] [-t keytype] [-x sigfile] -m message -type verifyCommand struct { +type verifyCmd struct { embed bool quiet bool zip bool @@ -26,82 +26,82 @@ type verifyCommand struct { msgFile string } -func (v *verifyCommand) Name() string { return "verify" } -func (v *verifyCommand) Synopsis() string { return "verify signature" } -func (v *verifyCommand) Usage() string { +func (m *verifyCmd) Name() string { return "verify" } +func (m *verifyCmd) Synopsis() string { return "verify signature" } +func (m *verifyCmd) Usage() string { return "verify [-eqz] [-p pubkey] [-t keytype] [-x sigfile] -m message\n" } -func (v *verifyCommand) SetFlags(f *flag.FlagSet) { - f.BoolVar(&v.embed, "e", false, "embed message") - f.BoolVar(&v.quiet, "q", false, "quiet mode") - f.BoolVar(&v.zip, "z", false, "verify gzip archive") // TODO - f.StringVar(&v.pubFile, "p", "", "public key file") - f.StringVar(&v.keyFile, "t", "", "key type") // TODO - f.StringVar(&v.sigFile, "x", "", "signature file") - f.StringVar(&v.msgFile, "m", "", "message file (required)") +func (m *verifyCmd) SetFlags(f *flag.FlagSet) { + f.BoolVar(&m.embed, "e", false, "embed message") + f.BoolVar(&m.quiet, "q", false, "quiet mode") + f.BoolVar(&m.zip, "z", false, "verify gzip archive") // TODO + f.StringVar(&m.pubFile, "p", "", "public key file") + f.StringVar(&m.keyFile, "t", "", "key type") // TODO + f.StringVar(&m.sigFile, "x", "", "signature file") + f.StringVar(&m.msgFile, "m", "", "message file (required)") } -func (v *verifyCommand) Execute(ctx context.Context, f *flag.FlagSet, args ...interface{}) subcommands.ExitStatus { - if v.msgFile == "" { +func (m *verifyCmd) Execute(ctx context.Context, f *flag.FlagSet, args ...interface{}) subcommands.ExitStatus { + if m.msgFile == "" { f.Usage() return subcommands.ExitUsageError } - if v.sigFile == "" { - v.sigFile = SigName(v.msgFile) + if m.sigFile == "" { + m.sigFile = SigName(m.msgFile) } // TODO keyType var err error switch { - case v.zip && v.embed: + case m.zip && m.embed: f.Usage() return subcommands.ExitUsageError - case v.zip: - err = v.zipped() - case v.embed: - err = v.embedded() + case m.zip: + err = m.zipped() + case m.embed: + err = m.embedded() default: - err = v.plain() + err = m.plain() } if err != nil { log.Println(err) return subcommands.ExitFailure } - if !v.quiet { + if !m.quiet { fmt.Println("Signature Verified") } return subcommands.ExitSuccess } -func (v *verifyCommand) plain() error { - msg, err := ioutil.ReadFile(v.msgFile) +func (m *verifyCmd) plain() error { + msg, err := ioutil.ReadFile(m.msgFile) if err != nil { return err } - sig, _, verifyWith, err := openSig(v.sigFile) + sig, _, verifyWith, err := openSig(m.sigFile) if err != nil { return err } - if v.pubFile == "" { - v.pubFile = verifyWith + if m.pubFile == "" { + m.pubFile = verifyWith } - pub, err := openPub(v.pubFile) + pub, err := openPub(m.pubFile) if err != nil { return err } return sig.Verify(msg, pub) } -func (v *verifyCommand) embedded() error { - sig, msg, verifyWith, err := openSig(v.sigFile) +func (m *verifyCmd) embedded() error { + sig, msg, verifyWith, err := openSig(m.sigFile) if err != nil { return err } - if v.pubFile == "" { - v.pubFile = verifyWith + if m.pubFile == "" { + m.pubFile = verifyWith } - pub, err := openPub(v.pubFile) + pub, err := openPub(m.pubFile) if err != nil { return err } @@ -109,8 +109,8 @@ func (v *verifyCommand) embedded() error { } // TODO ugly work-in-progress -func (v *verifyCommand) zipped() error { - fd, err := Open(v.sigFile) +func (m *verifyCmd) zipped() error { + fd, err := Open(m.sigFile) if err != nil { return err } @@ -129,7 +129,7 @@ func (v *verifyCommand) zipped() error { return err } - pub, err := openPub(v.pubFile) + pub, err := openPub(m.pubFile) if err != nil { return err } diff --git a/main.go b/main.go index 1c6a0b6..5d11c58 100644 --- a/main.go +++ b/main.go @@ -24,10 +24,10 @@ func main() { subcommands.Register(subcommands.FlagsCommand(), "") subcommands.Register(subcommands.HelpCommand(), "") - subcommands.Register(&checkCommand{}, "") - subcommands.Register(&generateCommand{}, "") - subcommands.Register(&signCommand{}, "") - subcommands.Register(&verifyCommand{}, "") + subcommands.Register(&checkCmd{}, "") + subcommands.Register(&generateCmd{}, "") + subcommands.Register(&signCmd{}, "") + subcommands.Register(&verifyCmd{}, "") flag.Parse() -- cgit v1.2.3