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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
#!/bin/bash
# Tests for list command
this_dir="$(cd "$(dirname "$0")" && pwd)"
source "${this_dir}/common.sh"
test_list_shows_secrets() {
echo "value1" | szecret put "secret-a"
echo "value2" | szecret put "secret-b"
echo "value3" | szecret put "secret-c"
local list_output
list_output="$(szecret list)"
assert_contains "${list_output}" "secret-a" "list output"
assert_contains "${list_output}" "secret-b" "list output"
assert_contains "${list_output}" "secret-c" "list output"
pass "list shows all secrets"
}
test_list_empty_store() {
local list_output
list_output="$(szecret list)"
assert_equals "" "${list_output}" "empty list"
pass "list handles empty store"
}
test_list_sorted() {
echo "v" | szecret put "zebra"
echo "v" | szecret put "apple"
echo "v" | szecret put "mango"
local list_output
list_output="$(szecret list)"
# Check that apple comes before mango comes before zebra
local apple_pos mango_pos zebra_pos
apple_pos=$(echo "${list_output}" | grep -n "apple" | cut -d: -f1)
mango_pos=$(echo "${list_output}" | grep -n "mango" | cut -d: -f1)
zebra_pos=$(echo "${list_output}" | grep -n "zebra" | cut -d: -f1)
if [[ "${apple_pos}" -lt "${mango_pos}" && "${mango_pos}" -lt "${zebra_pos}" ]]; then
pass "list is sorted"
else
fail "list is not sorted: apple=${apple_pos}, mango=${mango_pos}, zebra=${zebra_pos}"
fi
}
# --- Buckets, at a terminal and in JSON --------------------------------------
# buckets_setup: this machine ("me"), another host and two admins, one named
# by a "# <name>" line in the admins command's output and one not; buckets
# mine (me, other), theirs (other) and admin-only, keyed, a secret in each.
buckets_setup() {
export SZECRET_BUCKETS="${TEST_DIR}/buckets"
export SZECRET_IDENTITY="${TEST_DIR}/me/identity"
mkdir -p "${SZECRET_BUCKETS}"
szecret enrol >/dev/null 2>&1
me="$(cat "${SZECRET_IDENTITY}.pub")"
age-keygen -o "${TEST_DIR}/other" 2>/dev/null
other="$(age-keygen -y "${TEST_DIR}/other")"
age-keygen -o "${TEST_DIR}/admin" 2>/dev/null
admin="$(age-keygen -y "${TEST_DIR}/admin")"
age-keygen -o "${TEST_DIR}/admin2" 2>/dev/null
admin2="$(age-keygen -y "${TEST_DIR}/admin2")"
# admin2 has no "# <name>" line directly above it: the blank line ends it.
printf '# The admins\n# alice phone\n%s\n\n%s\n' "${admin}" "${admin2}" > "${TEST_DIR}/admins"
export SZECRET_ADMINS_COMMAND="cat '${TEST_DIR}/admins'"
local b row
for b in "mine:me ${me}:other ${other}" "theirs:other ${other}" "admin-only"; do
mkdir -p "${SZECRET_BUCKETS}/${b%%:*}"
{
echo "# Written by szecret-buckets"
IFS=: read -r -a rows <<<"${b#*:}"
if [[ "${b}" == *:* ]]; then
for row in "${rows[@]}"; do
echo "# ${row%% *}"
echo "${row#* }"
done
fi
} > "${SZECRET_BUCKETS}/${b%%:*}/recipients"
szecret rekey --add-ok "${b%%:*}" >/dev/null
done
echo v | szecret put mine/mine-a
echo v | szecret put mine/mine-b
echo v | szecret put theirs/their-t
echo v | szecret put admin-only/admin-a
}
# Plain list piped, and --names, are what scripts read: unchanged, byte for byte.
test_list_scripts_unchanged() {
assert_equals "$(printf '%s\n' apple mango mine-a mine-b secret-a secret-b secret-c zebra)" \
"$(szecret list)" "piped list"
assert_equals "$(printf '%s\n' mine/mine-a mine/mine-b '(old store)/apple' '(old store)/mango' \
'(old store)/secret-a' '(old store)/secret-b' '(old store)/secret-c' '(old store)/zebra')" \
"$(szecret list --names)" "list --names"
assert_contains "$(szecret list --names --all)" "theirs/their-t"
assert_contains "$(szecret list --names --all)" "admin-only/admin-a"
pass "list: piped and --names output unchanged"
}
test_list_terminal() {
local out
out="$(SZECRET_FORCE_TTY=80 szecret list)"
assert_contains "${out}" "mine 2 secrets"
assert_contains "${out}" " read by me, other, the admins"
assert_contains "${out}" " mine-a mine-b"
assert_contains "${out}" "(old store) 6 secrets"
assert_contains "${out}" "me reads 2 buckets, 8 secrets"
assert_contains "${out}" "The admins read every bucket: alice phone, unnamed admin"
assert_contains "${out}" "2 buckets not read here: szecret list --all"
[[ "${out}" != *theirs* ]] || fail "list shows a bucket not read here: ${out}"
[[ "${out}" != *age1* ]] || fail "list shows a key without --keys: ${out}"
[[ "${out}" != *$'\033'* ]] || fail "colour without a terminal: ${out}"
pass "list: at a terminal, buckets with readers by name, and a summary"
}
test_list_terminal_all_and_keys() {
local out
out="$(SZECRET_FORCE_TTY=80 szecret list --all)"
assert_contains "${out}" "Not read here 2 buckets"
assert_contains "${out}" "theirs 1 secret"
assert_contains "${out}" " read by the admins only"
assert_contains "${out}" "me reads 2 of 4 buckets, 8 of 10 secrets"
out="$(SZECRET_FORCE_TTY=80 szecret list --keys)"
assert_contains "${out}" "me ${me}"
assert_contains "${out}" "unnamed admin ${admin2}"
pass "list: --all adds the buckets not read here, --keys the keys"
}
test_list_narrow() {
local out long
out="$(SZECRET_FORCE_TTY=44 szecret list --all)"
long="$(awk 'length > 44' <<<"${out}")"
assert_equals "" "${long}" "lines over 44 columns"
assert_contains "${out}" "The admins read every bucket: alice phone,"
assert_contains "${out}" " unnamed admin"
pass "list: fits a narrow terminal"
}
test_list_json() {
local out
out="$(szecret list --json)"
assert_contains "${out}" '{"buckets":[{"name":"mine","old_store":false,"readable":true,"keyed":true,"readers":['
assert_contains "${out}" "{\"name\":\"me\",\"key\":\"${me}\",\"admin\":false,\"this_machine\":true}"
assert_contains "${out}" "{\"name\":\"alice phone\",\"key\":\"${admin}\",\"admin\":true,\"this_machine\":false}"
assert_contains "${out}" '"secrets":["mine-a","mine-b"],"problems":[]}'
assert_contains "${out}" '"machine":"me","admins_known":true}'
[[ "${out}" != *theirs* ]] || fail "--json shows a bucket not read here"
assert_contains "$(szecret list --json --all)" '"name":"theirs","old_store":false,"readable":false'
if command -v python3 >/dev/null; then
python3 -c 'import json,sys; json.load(sys.stdin)' <<<"${out}" || fail "--json is not JSON: ${out}"
fi
assert_failure szecret list --json --names
pass "list: --json, keys included"
}
test_list_problems() {
local out
age-keygen -o "${TEST_DIR}/newhost" 2>/dev/null
printf '# newhost\n%s\n' "$(age-keygen -y "${TEST_DIR}/newhost")" >> "${SZECRET_BUCKETS}/mine/recipients"
echo "not age" > "${SZECRET_BUCKETS}/mine/junk.age"
out="$(SZECRET_FORCE_TTY=80 szecret list)"
assert_contains "${out}" " ! readers changed since its last rekey: +newhost"
assert_contains "${out}" " fix: szecret rekey mine"
assert_contains "${out}" " ! junk: not an age file"
assert_contains "${out}" "! 2 problems in mine"
assert_contains "$(szecret list --json)" '{"problem":"readers changed since its last rekey: +newhost","fix":"szecret rekey mine"}'
out="$(SZECRET_FORCE_TTY=80 SZECRET_ADMINS_COMMAND=false szecret list)"
assert_contains "${out}" "! the admins are unknown"
pass "list: says what is wrong, and how to fix it"
}
test_list_reads_nothing() {
local out
out="$(SZECRET_FORCE_TTY=80 SZECRET_STORE= SZECRET_IDENTITY="${TEST_DIR}/stranger/identity" szecret list)"
assert_contains "${out}" "This machine reads none of the 3 buckets here."
assert_contains "${out}" "szecret enrol"
pass "list: says what to do when this machine reads nothing"
}
run_tests() {
test_list_empty_store
test_list_shows_secrets
test_list_sorted
buckets_setup
test_list_scripts_unchanged
test_list_terminal
test_list_terminal_all_and_keys
test_list_narrow
test_list_json
test_list_problems
test_list_reads_nothing
}
[[ "${BASH_SOURCE[0]}" == "${0}" ]] && run_tests
|