Debian Codegraph @

bin/crypt/cmd.go

raw
1 package main
2
3 import (
4 "errors"
5 "flag"
6 "fmt"
7 "io/ioutil"
8 "log"
9 "os"
10
11 "github.com/xordataexchange/crypt/backend"
12 "github.com/xordataexchange/crypt/backend/consul"
13 "github.com/xordataexchange/crypt/backend/etcd"
14 "github.com/xordataexchange/crypt/encoding/secconf"
15 )
16
17 func getCmd(flagset *flag.FlagSet) {
18 flagset.Usage = func() {
19 fmt.Fprintf(os.Stderr, "usage: %s get [args...] key\n", os.Args[0])
20 flagset.PrintDefaults()
21 }
22 flagset.StringVar(&secretKeyring, "secret-keyring", ".secring.gpg", "path to armored secret keyring")
23 flagset.Parse(os.Args[2:])
24 key := flagset.Arg(0)
25 if key == "" {
26 flagset.Usage()
27 os.Exit(1)
28 }
29 backendStore, err := getBackendStore(backendName, endpoint)
30 if err != nil {
31 log.Fatal(err)
32 }
33 if plaintext {
34 value, err := getPlain(key, backendStore)
35 if err != nil {
36 log.Fatal(err)
37 }
38 fmt.Printf("%s\n", value)
39 return
40 }
41 value, err := getEncrypted(key, secretKeyring, backendStore)
42
43 if err != nil {
44 log.Fatal(err)
45 }
46 fmt.Printf("%s\n", value)
47 }
48
49 func getEncrypted(key, keyring string, store backend.Store) ([]byte, error) {
50 var value []byte
51 kr, err := os.Open(secretKeyring)
52 if err != nil {
53 return value, err
54 }
55 defer kr.Close()
56 data, err := store.Get(key)
57 if err != nil {
58 return value, err
59 }
60 value, err = secconf.Decode(data, kr)
61 if err != nil {
62 return value, err
63 }
64 return value, err
65
66 }
67
68 func getPlain(key string, store backend.Store) ([]byte, error) {
69 var value []byte
70 data, err := store.Get(key)
71 if err != nil {
72 return value, err
73 }
74 return data, err
75 }
76
77 func listCmd(flagset *flag.FlagSet) {
78 flagset.Usage = func() {
79 fmt.Fprintf(os.Stderr, "usage: %s list [args...] key\n", os.Args[0])
80 flagset.PrintDefaults()
81 }
82 flagset.StringVar(&secretKeyring, "secret-keyring", ".secring.gpg", "path to armored secret keyring")
83 flagset.Parse(os.Args[2:])
84 key := flagset.Arg(0)
85 if key == "" {
86 flagset.Usage()
87 os.Exit(1)
88 }
89 backendStore, err := getBackendStore(backendName, endpoint)
90 if err != nil {
91 log.Fatal(err)
92 }
93 if plaintext {
94 list, err := listPlain(key, backendStore)
95 if err != nil {
96 log.Fatal(err)
97 }
98 for _, kv := range list {
99 fmt.Printf("%s: %s", kv.Key, kv.Value)
100 }
101 return
102 }
103 list, err := listEncrypted(key, secretKeyring, backendStore)
104
105 if err != nil {
106 log.Fatal(err)
107 }
108 for _, kv := range list {
109 fmt.Printf("%s: %s", kv.Key, kv.Value)
110 }
111 }
112
113 func listEncrypted(key, keyring string, store backend.Store) (backend.KVPairs, error) {
114 kr, err := os.Open(secretKeyring)
115 if err != nil {
116 return nil, err
117 }
118 defer kr.Close()
119
120 data, err := store.List(key)
121 if err != nil {
122 return nil, err
123 }
124 for i, kv := range data {
125 data[i].Value, err = secconf.Decode(kv.Value, kr)
126 kr.Seek(0, 0)
127 if err != nil {
128 return nil, err
129 }
130 }
131 return data, err
132 }
133
134 func listPlain(key string, store backend.Store) (backend.KVPairs, error) {
135 data, err := store.List(key)
136 if err != nil {
137 return nil, err
138 }
139 return data, err
140 }
141
142 func setCmd(flagset *flag.FlagSet) {
143 flagset.Usage = func() {
144 fmt.Fprintf(os.Stderr, "usage: %s set [args...] key file\n", os.Args[0])
145 flagset.PrintDefaults()
146 }
147 flagset.StringVar(&keyring, "keyring", ".pubring.gpg", "path to armored public keyring")
148 flagset.Parse(os.Args[2:])
149 key := flagset.Arg(0)
150 if key == "" {
151 flagset.Usage()
152 os.Exit(1)
153 }
154 data := flagset.Arg(1)
155 if data == "" {
156 flagset.Usage()
157 os.Exit(1)
158 }
159 backendStore, err := getBackendStore(backendName, endpoint)
160 if err != nil {
161 log.Fatal(err)
162 }
163 d, err := ioutil.ReadFile(data)
164 if err != nil {
165 log.Fatal(err)
166 }
167
168 if plaintext {
169 err := setPlain(key, backendStore, d)
170 if err != nil {
171 log.Fatal(err)
172 return
173 }
174 return
175 }
176 err = setEncrypted(key, keyring, d, backendStore)
177 if err != nil {
178 log.Fatal(err)
179 }
180 return
181
182 }
183 func setPlain(key string, store backend.Store, d []byte) error {
184 err := store.Set(key, d)
185 return err
186
187 }
188
189 func setEncrypted(key, keyring string, d []byte, store backend.Store) error {
190 kr, err := os.Open(keyring)
191 if err != nil {
192 return err
193 }
194 defer kr.Close()
195 secureValue, err := secconf.Encode(d, kr)
196 if err != nil {
197 return err
198 }
199 err = store.Set(key, secureValue)
200 return err
201 }
202
203 func getBackendStore(provider string, endpoint string) (backend.Store, error) {
204 if endpoint == "" {
205 switch provider {
206 case "consul":
207 endpoint = "127.0.0.1:8500"
208 case "etcd":
209 endpoint = "http://127.0.0.1:4001"
210 }
211 }
212 machines := []string{endpoint}
213 switch provider {
214 case "etcd":
215 return etcd.New(machines)
216 case "consul":
217 return consul.New(machines)
218 default:
219 return nil, errors.New("invalid backend " + provider)
220 }
221 }