2pass 2.1.0 → 2.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/README.md +421 -7
- data/bin/2pass +331 -6
- data/lib/2pass/approvals.rb +128 -0
- data/lib/2pass/broker.rb +462 -0
- data/lib/2pass/bundle.rb +289 -0
- data/lib/2pass/device.rb +207 -0
- data/lib/2pass/device_cache.rb +85 -0
- data/lib/2pass/device_registry.rb +131 -0
- data/lib/2pass/encryption.rb +277 -0
- data/lib/2pass/envelope.rb +323 -0
- data/lib/2pass/locked_json_file.rb +33 -0
- data/lib/2pass/policy.rb +128 -0
- data/lib/2pass/remote.rb +387 -0
- data/lib/2pass/replay_cache.rb +27 -0
- data/lib/2pass/server.rb +84 -0
- data/lib/2pass/version.rb +1 -1
- data/lib/2pass.rb +296 -19
- metadata +15 -2
data/lib/2pass.rb
CHANGED
|
@@ -10,6 +10,18 @@ require "rubygems/version"
|
|
|
10
10
|
require "terminal-table"
|
|
11
11
|
|
|
12
12
|
require_relative "2pass/version"
|
|
13
|
+
require_relative "2pass/encryption"
|
|
14
|
+
require_relative "2pass/device"
|
|
15
|
+
require_relative "2pass/device_registry"
|
|
16
|
+
require_relative "2pass/envelope"
|
|
17
|
+
require_relative "2pass/locked_json_file"
|
|
18
|
+
require_relative "2pass/approvals"
|
|
19
|
+
require_relative "2pass/device_cache"
|
|
20
|
+
require_relative "2pass/replay_cache"
|
|
21
|
+
require_relative "2pass/server"
|
|
22
|
+
require_relative "2pass/remote"
|
|
23
|
+
require_relative "2pass/bundle"
|
|
24
|
+
require_relative "2pass/policy"
|
|
13
25
|
|
|
14
26
|
module TwoPass
|
|
15
27
|
VAULT_DIR = "#{Dir.home}/.2pass"
|
|
@@ -17,8 +29,12 @@ module TwoPass
|
|
|
17
29
|
class << self
|
|
18
30
|
def create_symlink(vault_name, target_path, env: nil)
|
|
19
31
|
FileUtils.mkdir_p(VAULT_DIR)
|
|
20
|
-
symlink_path = vault_file_path(vault_name, env: env)
|
|
21
32
|
expanded_target_path = File.expand_path(target_path)
|
|
33
|
+
symlink_path = if expanded_target_path.end_with?(Encryption::FILE_SUFFIX)
|
|
34
|
+
encrypted_vault_file_path(vault_name, env: env)
|
|
35
|
+
else
|
|
36
|
+
vault_file_path(vault_name, env: env)
|
|
37
|
+
end
|
|
22
38
|
|
|
23
39
|
unless File.exist?(expanded_target_path)
|
|
24
40
|
raise "Target vault file does not exist: #{expanded_target_path}"
|
|
@@ -46,14 +62,184 @@ module TwoPass
|
|
|
46
62
|
puts "Created symlink: #{symlink_path} -> #{expanded_target_path}"
|
|
47
63
|
end
|
|
48
64
|
|
|
65
|
+
# Saves in the vault's current format. A new vault is created encrypted
|
|
66
|
+
# when a master key is configured (`2pass key init`), plaintext otherwise.
|
|
67
|
+
# A new vault goes to the shared folder when one is set, so the other
|
|
68
|
+
# primary machines see it.
|
|
49
69
|
def save_vault(vault_name, data, env: nil)
|
|
50
70
|
FileUtils.mkdir_p(VAULT_DIR)
|
|
51
|
-
file_path =
|
|
52
|
-
|
|
71
|
+
file_path, format = existing_vault_file(vault_name, env: env)
|
|
72
|
+
format ||= Encryption.enabled? ? :encrypted : :plain
|
|
73
|
+
new_dir = shared_dir || VAULT_DIR
|
|
74
|
+
|
|
75
|
+
if format == :encrypted
|
|
76
|
+
file_path ||= encrypted_vault_file_path(vault_name, env: env, dir: new_dir)
|
|
77
|
+
Encryption.write_atomic(
|
|
78
|
+
file_path,
|
|
79
|
+
Encryption.encrypt(YAML.dump(data), vault: vault_name, env: env)
|
|
80
|
+
)
|
|
81
|
+
else
|
|
82
|
+
File.write(file_path || vault_file_path(vault_name, env: env, dir: new_dir), YAML.dump(data))
|
|
83
|
+
end
|
|
84
|
+
end
|
|
85
|
+
|
|
86
|
+
# Folder shared by the primary machines (e.g. in iCloud Drive) holding
|
|
87
|
+
# vaults, devices.yml and broker-policy.yml. Keys, approvals and the replay
|
|
88
|
+
# cache always stay in ~/.2pass.
|
|
89
|
+
def shared_dir
|
|
90
|
+
dir = Encryption.config["shared_dir"]
|
|
91
|
+
dir && File.expand_path(dir)
|
|
92
|
+
end
|
|
93
|
+
|
|
94
|
+
SHARED_FILES = %w[devices.yml broker-policy.yml].freeze
|
|
95
|
+
|
|
96
|
+
def share_state(dir)
|
|
97
|
+
dir = File.expand_path(dir)
|
|
98
|
+
raise "Shared folder does not exist: #{dir}" unless File.directory?(dir)
|
|
99
|
+
|
|
100
|
+
moved = []
|
|
101
|
+
SHARED_FILES.each do |file|
|
|
102
|
+
local = File.join(VAULT_DIR, file)
|
|
103
|
+
shared = File.join(dir, file)
|
|
104
|
+
next unless File.file?(local) && !File.symlink?(local)
|
|
105
|
+
|
|
106
|
+
if File.exist?(shared)
|
|
107
|
+
raise "Both #{local} and #{shared} exist. Merge them by hand, delete the local one, then run this again."
|
|
108
|
+
end
|
|
109
|
+
FileUtils.mv(local, shared)
|
|
110
|
+
moved << file
|
|
111
|
+
end
|
|
112
|
+
|
|
113
|
+
Encryption.save_config(Encryption.config.merge("shared_dir" => dir))
|
|
114
|
+
message = +"This machine now reads vaults, approved devices and the broker policy from #{dir}."
|
|
115
|
+
message << "\nMoved: #{moved.join(', ')}." if moved.any?
|
|
116
|
+
message << "\nRun the same command on your other primary machine(s), pointing at the same synced folder."
|
|
117
|
+
if Encryption.enabled?
|
|
118
|
+
message << "\nWarning: vault encryption is on, but devices.yml and the policy are not signed yet;"
|
|
119
|
+
message << "\nanyone able to write to the shared folder could approve a device."
|
|
120
|
+
end
|
|
121
|
+
message
|
|
122
|
+
end
|
|
123
|
+
|
|
124
|
+
def init_device(name: nil, key_store: nil)
|
|
125
|
+
Device.init(name: name, key_store: key_store)
|
|
126
|
+
Device.describe_local
|
|
127
|
+
end
|
|
128
|
+
|
|
129
|
+
# Approves a device on the hub. `confirm` receives the pairing code and must
|
|
130
|
+
# return true only if a human checked it matches the code on the device.
|
|
131
|
+
# Approves a device on the hub and makes sure broker-policy.yml has an
|
|
132
|
+
# entry for it. Access is never granted implicitly: `grants` (vault/env
|
|
133
|
+
# specs) or the `choose` callback (interactive pick) decide what it gets.
|
|
134
|
+
def approve_device(token, name: nil, expires_in: nil, confirm:, grants: [], choose: nil)
|
|
135
|
+
identity = Device.parse_token(token)
|
|
136
|
+
targets = grants.map { |spec| Policy.parse_target(spec) }
|
|
137
|
+
missing = targets - Policy.available_targets
|
|
138
|
+
raise "Vault not found on this machine: #{missing.join(', ')}" if missing.any?
|
|
139
|
+
unless confirm.call(identity.pairing_code, name || identity.name)
|
|
140
|
+
raise "Pairing cancelled: the pairing code was not confirmed"
|
|
141
|
+
end
|
|
142
|
+
|
|
143
|
+
entry = DeviceRegistry.new.approve(identity, name: name, expires_in_days: parse_expiry(expires_in))
|
|
144
|
+
message = +"Approved #{entry['name']} (#{identity.pairing_code}), expires #{entry['expires_at'] || 'never'}."
|
|
145
|
+
message << "\n#{update_policy_for(entry['name'], targets, choose)}"
|
|
146
|
+
if Device.configured?
|
|
147
|
+
message << "\n\nOn #{entry['name']}, trust this machine with:"
|
|
148
|
+
message << "\n 2pass hub trust #{Device.local_identity.pairing_token}"
|
|
149
|
+
message << "\nand check it shows pairing code #{Device.local_identity.public_identity.pairing_code}."
|
|
150
|
+
message << "\nThat is enough for bundles (2pass bundle export #{entry['name']}). To let it connect here"
|
|
151
|
+
message << "\ninstead, add --ssh 2pass-hub (a Host alias in its ~/.ssh/config; see README)."
|
|
152
|
+
else
|
|
153
|
+
message << "\nThis hub has no device identity yet; run `2pass device init` here before devices can trust it."
|
|
154
|
+
end
|
|
155
|
+
message
|
|
156
|
+
end
|
|
157
|
+
|
|
158
|
+
def grant_access(actor, specs)
|
|
159
|
+
added = Policy.new.grant(actor, specs.map { |spec| Policy.parse_target(spec) })
|
|
160
|
+
return "#{actor} already had read access to #{specs.join(', ')}." if added.empty?
|
|
161
|
+
|
|
162
|
+
"Granted #{actor} read access to #{added.join(', ')} (all secrets, get/list)."
|
|
163
|
+
end
|
|
164
|
+
|
|
165
|
+
def update_policy_for(actor, targets, choose)
|
|
166
|
+
policy = Policy.new
|
|
167
|
+
path = Broker.default_policy_path
|
|
168
|
+
if policy.actor?(actor)
|
|
169
|
+
added = targets.any? ? policy.grant(actor, targets) : []
|
|
170
|
+
text = +"#{path} already has an entry for #{actor} (#{policy.grants(actor).size} grant(s)); left as is."
|
|
171
|
+
text = +"Added to the existing entry for #{actor}: #{added.join(', ')}." if added.any?
|
|
172
|
+
return text
|
|
173
|
+
end
|
|
174
|
+
|
|
175
|
+
targets = choose.call(actor, Policy.available_targets) if targets.empty? && choose
|
|
176
|
+
added = policy.grant(actor, Array(targets))
|
|
177
|
+
if added.any?
|
|
178
|
+
"New policy entry for #{actor}: read access to #{added.join(', ')} (all secrets, get/list)."
|
|
179
|
+
else
|
|
180
|
+
"New policy entry for #{actor}, with no access yet. Grant some with: 2pass policy grant #{actor} <vault[:env]>"
|
|
181
|
+
end
|
|
182
|
+
end
|
|
183
|
+
|
|
184
|
+
def revoke_device(name)
|
|
185
|
+
DeviceRegistry.new.revoke(name)
|
|
186
|
+
"Revoked #{name}. Rotate any secret this device was able to read."
|
|
187
|
+
end
|
|
188
|
+
|
|
189
|
+
def renew_device(name, expires_in: nil)
|
|
190
|
+
entry = DeviceRegistry.new.renew(name, expires_in_days: parse_expiry(expires_in))
|
|
191
|
+
"Renewed #{name}, expires #{entry['expires_at'] || 'never'}."
|
|
192
|
+
end
|
|
193
|
+
|
|
194
|
+
def init_encryption(key_store: nil)
|
|
195
|
+
store = Encryption.init(key_store: key_store || Encryption.default_key_store)
|
|
196
|
+
message = +"Master key created in #{store.description}."
|
|
197
|
+
message << "\nNew vaults will be encrypted. Encrypt existing ones with: 2pass migrate encrypt <vault_name> [env]"
|
|
198
|
+
message << "\nBack up this key now: without it, encrypted vaults cannot be recovered."
|
|
199
|
+
message
|
|
200
|
+
end
|
|
201
|
+
|
|
202
|
+
# Converts a plaintext vault to an encrypted one, verifies the result, then
|
|
203
|
+
# removes the local plaintext entry unless keep_plaintext is set.
|
|
204
|
+
def encrypt_vault(vault_name, env: nil, keep_plaintext: false)
|
|
205
|
+
plain_path = vault_file_path(vault_name, env: env)
|
|
206
|
+
encrypted_path = encrypted_vault_file_path(vault_name, env: env)
|
|
207
|
+
|
|
208
|
+
raise "Encryption is not configured. Run: 2pass key init" unless Encryption.enabled?
|
|
209
|
+
raise "Vault is already encrypted: #{encrypted_path}" if File.exist?(encrypted_path) || File.symlink?(encrypted_path)
|
|
210
|
+
raise missing_vault_error_message(vault_name, plain_path, env: env) unless File.exist?(plain_path)
|
|
211
|
+
|
|
212
|
+
data = load_vault(vault_name, env: env)
|
|
213
|
+
Encryption.write_atomic(encrypted_path, Encryption.encrypt(YAML.dump(data), vault: vault_name, env: env))
|
|
214
|
+
|
|
215
|
+
decrypted = YAML.load(Encryption.decrypt(File.read(encrypted_path), vault: vault_name, env: env), symbolize_names: true)
|
|
216
|
+
unless decrypted == data
|
|
217
|
+
FileUtils.rm_f(encrypted_path)
|
|
218
|
+
raise "Verification failed after encrypting #{vault_name}; plaintext vault left untouched"
|
|
219
|
+
end
|
|
220
|
+
|
|
221
|
+
message = +"Encrypted #{data.size} secret(s) into #{encrypted_path}"
|
|
222
|
+
if keep_plaintext
|
|
223
|
+
message << "\nPlaintext copy kept at #{plain_path}. Remove it once you no longer need it."
|
|
224
|
+
elsif File.symlink?(plain_path)
|
|
225
|
+
target = File.expand_path(File.readlink(plain_path), File.dirname(plain_path))
|
|
226
|
+
File.unlink(plain_path)
|
|
227
|
+
message << "\nRemoved symlink #{plain_path}."
|
|
228
|
+
message << "\nThe plaintext file it pointed to still exists: #{target}"
|
|
229
|
+
message << "\nDelete it (and from any synced location) once other devices no longer depend on it."
|
|
230
|
+
else
|
|
231
|
+
File.delete(plain_path)
|
|
232
|
+
message << "\nRemoved plaintext file #{plain_path}."
|
|
233
|
+
end
|
|
234
|
+
message
|
|
53
235
|
end
|
|
54
236
|
|
|
55
|
-
def list_content(vault_name, env: nil, format: :table)
|
|
56
|
-
vault =
|
|
237
|
+
def list_content(vault_name, env: nil, format: :table, purpose: nil, **remote_options)
|
|
238
|
+
vault = if Remote.trusts_hubs?
|
|
239
|
+
Remote.list(vault_name, env: env, purpose: purpose, **remote_options)
|
|
240
|
+
else
|
|
241
|
+
load_vault(vault_name, env: env)
|
|
242
|
+
end
|
|
57
243
|
if format == :table
|
|
58
244
|
rows = vault
|
|
59
245
|
.sort_by { |hash| hash[:id] }
|
|
@@ -80,11 +266,15 @@ module TwoPass
|
|
|
80
266
|
end
|
|
81
267
|
|
|
82
268
|
def add_secret(vault_name, id, value, env: nil)
|
|
269
|
+
if Remote.trusts_hubs?
|
|
270
|
+
raise "This device reads secrets from its primaries (hub or bundle); add secrets on a primary."
|
|
271
|
+
end
|
|
272
|
+
|
|
83
273
|
new_secret = {
|
|
84
274
|
id: id,
|
|
85
275
|
value: value
|
|
86
276
|
}
|
|
87
|
-
data = load_vault(vault_name, env: env)
|
|
277
|
+
data = load_vault(vault_name, env: env, allow_missing: true)
|
|
88
278
|
existing_entry_id = data.find_index { |hash| hash[:id] == new_secret[:id] }
|
|
89
279
|
if existing_entry_id
|
|
90
280
|
raise "The secret already exists"
|
|
@@ -93,14 +283,18 @@ module TwoPass
|
|
|
93
283
|
save_vault(vault_name, data, env: env)
|
|
94
284
|
end
|
|
95
285
|
|
|
96
|
-
def get_secret(vault_name, id, env: nil)
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
286
|
+
def get_secret(vault_name, id, env: nil, purpose: nil, **remote_options)
|
|
287
|
+
return Remote.get(vault_name, id, env: env, purpose: purpose, **remote_options) if Remote.trusts_hubs?
|
|
288
|
+
|
|
289
|
+
local_secret(vault_name, id, env: env)
|
|
290
|
+
end
|
|
291
|
+
|
|
292
|
+
def use_action(vault_name, action, env: nil, purpose: nil, **remote_options)
|
|
293
|
+
unless Remote.configured?
|
|
294
|
+
raise "`use` runs actions on a hub this device can reach (bundles can't run actions). Locally, use `2pass broker`."
|
|
103
295
|
end
|
|
296
|
+
|
|
297
|
+
Remote.use(vault_name, action, env: env, purpose: purpose, **remote_options)
|
|
104
298
|
end
|
|
105
299
|
|
|
106
300
|
def update_cli
|
|
@@ -121,11 +315,30 @@ module TwoPass
|
|
|
121
315
|
|
|
122
316
|
private
|
|
123
317
|
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
318
|
+
# Reads a secret from this machine's own vault files (never the hub).
|
|
319
|
+
def local_secret(vault_name, id, env: nil)
|
|
320
|
+
entry = load_vault(vault_name, env: env).find { |hash| hash[:id] == id }
|
|
321
|
+
raise "Entry not found" unless entry
|
|
322
|
+
|
|
323
|
+
entry[:value]
|
|
324
|
+
end
|
|
127
325
|
|
|
128
|
-
|
|
326
|
+
def load_vault(vault_name, env: nil, allow_missing: false)
|
|
327
|
+
file_path, format = existing_vault_file(vault_name, env: env)
|
|
328
|
+
unless file_path
|
|
329
|
+
return [] if allow_missing
|
|
330
|
+
|
|
331
|
+
raise missing_vault_error_message(vault_name, vault_file_path(vault_name, env: env), env: env)
|
|
332
|
+
end
|
|
333
|
+
|
|
334
|
+
if format == :encrypted
|
|
335
|
+
plaintext = Encryption.decrypt(File.read(file_path), vault: vault_name, env: env)
|
|
336
|
+
YAML.load(plaintext, symbolize_names: true) || []
|
|
337
|
+
else
|
|
338
|
+
YAML.load_file(file_path, symbolize_names: true) || []
|
|
339
|
+
end
|
|
340
|
+
rescue Encryption::Error => e
|
|
341
|
+
raise "#{e.message} (#{file_path})"
|
|
129
342
|
rescue Errno::EACCES, Errno::EPERM => e
|
|
130
343
|
raise permission_error_message(file_path, e)
|
|
131
344
|
rescue Psych::SyntaxError => e
|
|
@@ -133,13 +346,75 @@ module TwoPass
|
|
|
133
346
|
[]
|
|
134
347
|
end
|
|
135
348
|
|
|
136
|
-
|
|
349
|
+
# Returns [path, :encrypted | :plain] for the vault on disk, or nil.
|
|
350
|
+
# When both exist (e.g. `migrate encrypt --keep-plaintext`), the encrypted
|
|
351
|
+
# file wins and a reminder about the plaintext copy goes to STDERR.
|
|
352
|
+
# Looks in ~/.2pass first (files and `link` symlinks), then in the shared
|
|
353
|
+
# folder when one is set (`2pass hub share`).
|
|
354
|
+
def existing_vault_file(vault_name, env: nil)
|
|
355
|
+
[VAULT_DIR, shared_dir].compact.uniq.each do |dir|
|
|
356
|
+
plain_path = vault_file_path(vault_name, env: env, dir: dir)
|
|
357
|
+
encrypted_path = encrypted_vault_file_path(vault_name, env: env, dir: dir)
|
|
358
|
+
|
|
359
|
+
if File.exist?(encrypted_path)
|
|
360
|
+
if File.exist?(plain_path)
|
|
361
|
+
$stderr.puts "Warning: plaintext copy of an encrypted vault still exists: #{plain_path}"
|
|
362
|
+
end
|
|
363
|
+
return [encrypted_path, :encrypted]
|
|
364
|
+
elsif File.exist?(plain_path)
|
|
365
|
+
return [plain_path, :plain]
|
|
366
|
+
end
|
|
367
|
+
end
|
|
368
|
+
nil
|
|
369
|
+
end
|
|
370
|
+
|
|
371
|
+
def missing_vault_error_message(vault_name, file_path, env: nil)
|
|
372
|
+
link_args = [vault_name, "<path-to-vault>", env].compact.join(" ")
|
|
373
|
+
add_args = [vault_name, "<id>", "<value>", env].compact.join(" ")
|
|
374
|
+
|
|
375
|
+
encrypted_path = encrypted_vault_file_path(vault_name, env: env)
|
|
376
|
+
file_path = encrypted_path if File.symlink?(encrypted_path)
|
|
377
|
+
|
|
378
|
+
if File.symlink?(file_path)
|
|
379
|
+
target = File.expand_path(File.readlink(file_path), File.dirname(file_path))
|
|
380
|
+
message = +"Vault symlink is broken: #{file_path} -> #{target}"
|
|
381
|
+
message << "\nThe symlink exists but its target is missing."
|
|
382
|
+
message << "\nIf the vault is in a synced location (iCloud, Dropbox, etc.), it may not have"
|
|
383
|
+
message << "\ndownloaded yet, or it was moved or deleted."
|
|
384
|
+
message << "\nRe-create the link once the file is available:"
|
|
385
|
+
message << "\n 2pass link #{link_args}"
|
|
386
|
+
return message
|
|
387
|
+
end
|
|
388
|
+
|
|
389
|
+
message = +"Vault not found: #{file_path}"
|
|
390
|
+
message << "\nNo vault file or symlink exists at this path."
|
|
391
|
+
message << "\nCreate it by adding your first secret:"
|
|
392
|
+
message << "\n 2pass add #{add_args}"
|
|
393
|
+
message << "\nOr, if the vault already lives in a synced location (iCloud, Dropbox, etc.), link it:"
|
|
394
|
+
message << "\n 2pass link #{link_args}"
|
|
395
|
+
message
|
|
396
|
+
end
|
|
397
|
+
|
|
398
|
+
def vault_file_path(vault_name, env: nil, dir: VAULT_DIR)
|
|
137
399
|
[
|
|
138
|
-
|
|
400
|
+
dir,
|
|
139
401
|
[vault_name, env].compact.join(".")
|
|
140
402
|
].join("/") + ".yml"
|
|
141
403
|
end
|
|
142
404
|
|
|
405
|
+
def parse_expiry(value)
|
|
406
|
+
return DeviceRegistry::DEFAULT_EXPIRY_DAYS if value.nil?
|
|
407
|
+
return nil if value.to_s == "never"
|
|
408
|
+
|
|
409
|
+
Integer(value.to_s, 10)
|
|
410
|
+
rescue ArgumentError
|
|
411
|
+
raise "Invalid --expires-in value #{value.inspect}: use a number of days or 'never'"
|
|
412
|
+
end
|
|
413
|
+
|
|
414
|
+
def encrypted_vault_file_path(vault_name, env: nil, dir: VAULT_DIR)
|
|
415
|
+
vault_file_path(vault_name, env: env, dir: dir) + Encryption::FILE_SUFFIX
|
|
416
|
+
end
|
|
417
|
+
|
|
143
418
|
def permission_error_message(file_path, error)
|
|
144
419
|
message = +"Unable to read vault file: #{file_path}\n#{error.class}: #{error.message}"
|
|
145
420
|
symlink_target = nil
|
|
@@ -191,3 +466,5 @@ module TwoPass
|
|
|
191
466
|
end
|
|
192
467
|
end
|
|
193
468
|
end
|
|
469
|
+
|
|
470
|
+
require_relative "2pass/broker"
|
metadata
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: 2pass
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 2.
|
|
4
|
+
version: 2.3.0
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- Olivier
|
|
@@ -99,6 +99,19 @@ files:
|
|
|
99
99
|
- bin/console
|
|
100
100
|
- bin/setup
|
|
101
101
|
- lib/2pass.rb
|
|
102
|
+
- lib/2pass/approvals.rb
|
|
103
|
+
- lib/2pass/broker.rb
|
|
104
|
+
- lib/2pass/bundle.rb
|
|
105
|
+
- lib/2pass/device.rb
|
|
106
|
+
- lib/2pass/device_cache.rb
|
|
107
|
+
- lib/2pass/device_registry.rb
|
|
108
|
+
- lib/2pass/encryption.rb
|
|
109
|
+
- lib/2pass/envelope.rb
|
|
110
|
+
- lib/2pass/locked_json_file.rb
|
|
111
|
+
- lib/2pass/policy.rb
|
|
112
|
+
- lib/2pass/remote.rb
|
|
113
|
+
- lib/2pass/replay_cache.rb
|
|
114
|
+
- lib/2pass/server.rb
|
|
102
115
|
- lib/2pass/version.rb
|
|
103
116
|
homepage: https://2pass.xyz
|
|
104
117
|
licenses:
|
|
@@ -118,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
|
|
|
118
131
|
- !ruby/object:Gem::Version
|
|
119
132
|
version: '0'
|
|
120
133
|
requirements: []
|
|
121
|
-
rubygems_version: 4.0.
|
|
134
|
+
rubygems_version: 4.0.23
|
|
122
135
|
specification_version: 4
|
|
123
136
|
summary: A CLI app for managing secrets
|
|
124
137
|
test_files: []
|