revault_api 0.5.1-aarch64-linux → 0.6.1-aarch64-linux
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 +140 -423
- data/lib/revault/binding_operations.rb +1255 -0
- data/lib/revault/domain_models.rb +808 -0
- data/lib/revault/native_library.rb +80 -0
- data/lib/revault/vault.rb +1600 -0
- data/native/linux-aarch64-gnu/librevault_api.so +0 -0
- data/native/linux-aarch64-gnu/librevault_ruby_shim.so +0 -0
- data/native/revault_ruby_shim.c +557 -0
- data/revault_api.rb +11 -0
- metadata +25 -3
|
@@ -0,0 +1,1255 @@
|
|
|
1
|
+
# Generated complete binary operation layer. Do not edit.
|
|
2
|
+
require 'fiddle'
|
|
3
|
+
require 'fiddle/import'
|
|
4
|
+
require_relative 'domain_models'
|
|
5
|
+
require_relative 'native_library'
|
|
6
|
+
|
|
7
|
+
module Revault
|
|
8
|
+
module Native
|
|
9
|
+
extend Fiddle::Importer
|
|
10
|
+
dlload Revault::NativeLibrary.path
|
|
11
|
+
BufferStruct = struct ['void *ptr', 'size_t len']
|
|
12
|
+
extern 'uint32_t api_abi_version(void)'
|
|
13
|
+
extern 'const char * buffer_last_error(void)'
|
|
14
|
+
extern 'bool secret_len(void *, size_t *)'
|
|
15
|
+
extern 'bool secret_copy(void *, void *, size_t)'
|
|
16
|
+
extern 'void secret_free(void *)'
|
|
17
|
+
extern 'uint16_t lockbox_format_version(void)'
|
|
18
|
+
extern 'uint16_t lockbox_probe_format_version(void *, size_t)'
|
|
19
|
+
extern 'void * lockbox_create(void *, size_t)'
|
|
20
|
+
extern 'void * lockbox_create_with_options(void *, size_t, void *, size_t, uint64_t, void *, size_t, void *, size_t, size_t)'
|
|
21
|
+
extern 'void * lockbox_create_password(void *, size_t)'
|
|
22
|
+
extern 'void * lockbox_create_password_with_signing_key(void *, size_t, void *)'
|
|
23
|
+
extern 'void * lockbox_create_contact(void *)'
|
|
24
|
+
extern 'void * lockbox_create_contact_with_signing_key(void *, void *)'
|
|
25
|
+
extern 'void * lockbox_create_with_signing_key(void *, size_t, void *)'
|
|
26
|
+
# BEGIN generated file operation abi
|
|
27
|
+
extern 'void * lockbox_file(void *, size_t, void *, size_t, void *, size_t, void *, size_t, void *, void *, void *, size_t, uint64_t, void *, size_t, void *, size_t, size_t)'
|
|
28
|
+
# END generated file operation abi
|
|
29
|
+
extern 'void * lockbox_open(void *, size_t, void *, size_t)'
|
|
30
|
+
extern 'void * lockbox_open_with_options(void *, size_t, void *, size_t, void *, size_t, uint64_t, void *, size_t, void *, size_t, size_t)'
|
|
31
|
+
extern 'void * lockbox_open_password_with_budget(void *, size_t, void *, size_t, uint32_t)'
|
|
32
|
+
extern 'bool lockbox_extract_file_with_policy(void *, void *, size_t, void *, size_t, uint64_t, uint64_t, size_t, bool, bool)'
|
|
33
|
+
extern 'void * lockbox_open_password(void *, size_t, void *, size_t)'
|
|
34
|
+
extern 'void * lockbox_open_contact(void *, size_t, void *)'
|
|
35
|
+
extern 'bool lockbox_add_file(void *, void *, size_t, void *, size_t, bool)'
|
|
36
|
+
extern 'bool lockbox_add_file_with_permissions(void *, void *, size_t, void *, size_t, uint32_t, bool)'
|
|
37
|
+
extern 'bool lockbox_extract_file(void *, void *, size_t, void *, size_t, bool)'
|
|
38
|
+
extern 'bool lockbox_extract_directory(void *, void *, size_t, uint64_t, uint64_t, size_t, bool, bool, bool)'
|
|
39
|
+
extern 'bool lockbox_reset_import_stats(void *)'
|
|
40
|
+
extern 'uint64_t lockbox_storage_len(void *)'
|
|
41
|
+
extern 'bool lockbox_set_workload_profile(void *, void *, size_t)'
|
|
42
|
+
extern 'bool lockbox_set_cache_limit(void *, void *, size_t, uint64_t)'
|
|
43
|
+
extern 'bool lockbox_set_worker_policy(void *, void *, size_t, size_t)'
|
|
44
|
+
extern 'bool lockbox_commit(void *)'
|
|
45
|
+
extern 'bool lockbox_create_dir(void *, void *, size_t, bool)'
|
|
46
|
+
extern 'bool lockbox_delete(void *, void *, size_t)'
|
|
47
|
+
extern 'bool lockbox_remove_dir(void *, void *, size_t, bool)'
|
|
48
|
+
extern 'bool lockbox_create_parent_dirs(void *, void *, size_t)'
|
|
49
|
+
extern 'bool lockbox_rename(void *, void *, size_t, void *, size_t)'
|
|
50
|
+
extern 'bool lockbox_set_variable(void *, void *, size_t, void *, size_t)'
|
|
51
|
+
extern 'bool lockbox_set_secret_variable(void *, void *, size_t, void *, size_t)'
|
|
52
|
+
extern 'bool lockbox_get_secret_variable(void *, void *, size_t, void *)'
|
|
53
|
+
extern 'bool lockbox_delete_variable(void *, void *, size_t)'
|
|
54
|
+
extern 'bool lockbox_move_variables(void *, void *, size_t)'
|
|
55
|
+
extern 'bool lockbox_add_symlink(void *, void *, size_t, void *, size_t, bool)'
|
|
56
|
+
extern 'bool lockbox_exists(void *, void *, size_t)'
|
|
57
|
+
extern 'bool lockbox_is_dir(void *, void *, size_t)'
|
|
58
|
+
extern 'uint32_t lockbox_permissions(void *, void *, size_t)'
|
|
59
|
+
extern 'bool lockbox_set_permissions(void *, void *, size_t, uint32_t)'
|
|
60
|
+
extern 'void * lockbox_recovery_salvage(void *, size_t, void *, size_t, void *)'
|
|
61
|
+
extern 'uint64_t lockbox_add_password(void *, void *, size_t)'
|
|
62
|
+
extern 'uint64_t lockbox_add_contact(void *, void *, void *, size_t)'
|
|
63
|
+
extern 'bool lockbox_delete_key(void *, uint64_t)'
|
|
64
|
+
extern 'bool lockbox_set_owner_signing_key(void *, void *)'
|
|
65
|
+
extern 'bool lockbox_set_form_field(void *, void *, size_t, void *, size_t, void *, size_t)'
|
|
66
|
+
extern 'bool lockbox_set_secret_form_field(void *, void *, size_t, void *, size_t, void *, size_t)'
|
|
67
|
+
extern 'bool lockbox_get_secret_form_field(void *, void *, size_t, void *, size_t, void *)'
|
|
68
|
+
extern 'bool lockbox_delete_form_record(void *, void *, size_t)'
|
|
69
|
+
extern 'bool lockbox_move_form_records(void *, void *, size_t)'
|
|
70
|
+
extern 'void lockbox_free(void *)'
|
|
71
|
+
extern 'bool vault_is_running(void)'
|
|
72
|
+
extern 'bool vault_forget_all(void)'
|
|
73
|
+
extern 'void * key_contact_generate(void)'
|
|
74
|
+
extern 'void * key_contact_from_private(void *, size_t)'
|
|
75
|
+
extern 'void * key_contact_public_from_bytes(void *, size_t)'
|
|
76
|
+
extern 'void key_contact_public_free(void *)'
|
|
77
|
+
extern 'void key_contact_free(void *)'
|
|
78
|
+
extern 'void * key_contact_encrypt(void *, void *, size_t)'
|
|
79
|
+
extern 'void key_contact_wrapped_free(void *)'
|
|
80
|
+
extern 'void * key_signing_generate(void)'
|
|
81
|
+
extern 'void * key_signing_from_private(void *, size_t)'
|
|
82
|
+
extern 'void * key_signing_public_from_bytes(void *, size_t)'
|
|
83
|
+
extern 'void key_signing_public_free(void *)'
|
|
84
|
+
extern 'void key_signing_free(void *)'
|
|
85
|
+
extern 'void * vault_key_import_private(void *, size_t)'
|
|
86
|
+
extern 'void * vault_key_import_public(void *, size_t)'
|
|
87
|
+
extern 'void * vault_directory_open(void *, size_t, void *, size_t)'
|
|
88
|
+
extern 'void * contact_exchange_open(void *, size_t, void *, size_t)'
|
|
89
|
+
extern 'uint32_t vault_structure_version_current(void)'
|
|
90
|
+
extern 'uint32_t vault_directory_probe_structure_version(void *, size_t, void *, size_t)'
|
|
91
|
+
extern 'void * vault_directory_open_or_create_default(void *, size_t)'
|
|
92
|
+
extern 'void * vault_directory_replace_default(void *, size_t)'
|
|
93
|
+
extern 'bool vault_directory_change_password(void *, size_t, void *, size_t, void *, size_t)'
|
|
94
|
+
extern 'bool vault_directory_change_default_password(void *, size_t, void *, size_t)'
|
|
95
|
+
extern 'void * vault_directory_replace(void *, size_t, void *, size_t)'
|
|
96
|
+
extern 'void * vault_directory_open_or_create(void *, size_t, void *, size_t)'
|
|
97
|
+
extern 'uint32_t vault_directory_structure_version(void *)'
|
|
98
|
+
extern 'bool vault_directory_private_key_exists(void *, void *, size_t)'
|
|
99
|
+
extern 'bool vault_directory_delete_private_key(void *, void *, size_t)'
|
|
100
|
+
extern 'bool vault_directory_store_private_key(void *, void *, size_t, void *)'
|
|
101
|
+
extern 'void * vault_directory_load_private_key(void *, void *, size_t)'
|
|
102
|
+
extern 'void * vault_directory_load_private_key_generation(void *, void *, size_t, uint16_t)'
|
|
103
|
+
extern 'bool vault_directory_store_contact(void *, void *, size_t, void *)'
|
|
104
|
+
extern 'void * vault_directory_load_contact(void *, void *, size_t)'
|
|
105
|
+
extern 'bool vault_directory_contact_exists(void *, void *, size_t)'
|
|
106
|
+
extern 'bool vault_directory_delete_contact(void *, void *, size_t)'
|
|
107
|
+
extern 'bool vault_directory_store_profile_email(void *, void *, size_t, void *, size_t)'
|
|
108
|
+
extern 'bool vault_directory_store_backup(void *, void *, size_t, void *, size_t)'
|
|
109
|
+
extern 'uint64_t vault_directory_backup_count(void *)'
|
|
110
|
+
extern 'bool vault_directory_restore_private_key(void *, void *, size_t, void *, void *, bool)'
|
|
111
|
+
extern 'void * vault_directory_load_owner_signing_key(void *, void *, size_t)'
|
|
112
|
+
extern 'void * vault_directory_load_owner_signing_key_generation(void *, void *, size_t, uint16_t)'
|
|
113
|
+
extern 'bool vault_directory_store_contact_signing_key(void *, void *, size_t, void *)'
|
|
114
|
+
extern 'void * vault_directory_load_contact_signing_key(void *, void *, size_t)'
|
|
115
|
+
extern 'bool vault_directory_remember_lockbox(void *, void *, size_t, void *, size_t)'
|
|
116
|
+
extern 'bool vault_directory_forget_lockbox(void *, void *, size_t)'
|
|
117
|
+
extern 'bool vault_directory_remember_access_slot_label(void *, void *, size_t, uint64_t, void *, size_t)'
|
|
118
|
+
extern 'bool vault_directory_forget_access_slot_label(void *, void *, size_t, uint64_t)'
|
|
119
|
+
extern 'size_t vault_directory_seed_forms(void *)'
|
|
120
|
+
extern 'bool vault_directory_remember_password(void *, void *, size_t, void *, size_t)'
|
|
121
|
+
extern 'void vault_directory_free(void *)'
|
|
122
|
+
extern 'void contact_exchange_free(void *)'
|
|
123
|
+
extern 'void * vault_read_only_open(void *, size_t, void *, size_t)'
|
|
124
|
+
extern 'void * vault_read_only_open_default(void *, size_t)'
|
|
125
|
+
extern 'void * vault_read_only_load_private_key(void *, void *, size_t)'
|
|
126
|
+
extern 'void * vault_read_only_load_private_key_generation(void *, void *, size_t, uint16_t)'
|
|
127
|
+
extern 'void * vault_read_only_load_owner_signing_key(void *, void *, size_t)'
|
|
128
|
+
extern 'void * vault_read_only_load_owner_signing_key_generation(void *, void *, size_t, uint16_t)'
|
|
129
|
+
extern 'void * vault_read_only_load_profile_password(void *, void *, size_t)'
|
|
130
|
+
extern 'bool vault_read_only_remembered_password(void *, void *, size_t, void *)'
|
|
131
|
+
extern 'void vault_read_only_free(void *)'
|
|
132
|
+
extern 'bool vault_agent_serve(void)'
|
|
133
|
+
extern 'bool vault_agent_verify_transport(void)'
|
|
134
|
+
extern 'bool vault_agent_put(void *, size_t, void *, size_t)'
|
|
135
|
+
extern 'bool vault_agent_forget(void *, size_t)'
|
|
136
|
+
extern 'bool vault_agent_stop(void)'
|
|
137
|
+
extern 'bool vault_agent_start(void)'
|
|
138
|
+
extern 'bool vault_platform_set_scope(void *, size_t)'
|
|
139
|
+
extern 'bool vault_platform_forget_password(void)'
|
|
140
|
+
extern 'bool vault_platform_put_password(void *, size_t)'
|
|
141
|
+
extern 'bool vault_platform_enable(void)'
|
|
142
|
+
extern 'bool vault_platform_disable(void)'
|
|
143
|
+
extern 'bool vault_platform_disabled(void)'
|
|
144
|
+
extern 'bool vault_agent_put_vault_unlock_key(void *, size_t, void *, size_t, uint64_t)'
|
|
145
|
+
extern 'bool vault_agent_forget_vault_unlock_key(void *, size_t)'
|
|
146
|
+
extern 'void * vault_agent_get_owner_signing_key(void *, size_t, void *, size_t)'
|
|
147
|
+
extern 'bool vault_agent_put_owner_signing_key(void *, size_t, void *, size_t, void *, uint64_t)'
|
|
148
|
+
extern 'bool vault_agent_forget_owner_signing_key(void *, size_t, void *, size_t)'
|
|
149
|
+
extern 'void * vault_agent_begin_activity(void *, size_t)'
|
|
150
|
+
extern 'void vault_agent_end_activity(void *)'
|
|
151
|
+
extern 'void * vault_local(void)'
|
|
152
|
+
extern 'void * vault_create_lockbox_password(void *, void *, size_t, void *, size_t)'
|
|
153
|
+
extern 'void * vault_open_lockbox_password(void *, void *, size_t, void *, size_t)'
|
|
154
|
+
extern 'void * vault_create_lockbox_content_key(void *, void *, size_t, void *, size_t, void *)'
|
|
155
|
+
extern 'void * vault_create_lockbox_contact(void *, void *, size_t, void *, void *, size_t, void *)'
|
|
156
|
+
extern 'void * vault_open_lockbox_content_key(void *, void *, size_t, void *, size_t, void *)'
|
|
157
|
+
extern 'bool vault_cache_lockbox_password(void *, void *, size_t, void *, size_t, uint64_t)'
|
|
158
|
+
extern 'bool vault_close_lockbox(void *, void *, size_t)'
|
|
159
|
+
extern 'bool vault_close_all(void *)'
|
|
160
|
+
extern 'char vault_directory_set_lockbox_alias(void *, void *, size_t, void *, size_t)'
|
|
161
|
+
extern 'char vault_directory_remove_lockbox_alias(void *, void *, size_t)'
|
|
162
|
+
extern 'void vault_free(void *)'
|
|
163
|
+
end
|
|
164
|
+
|
|
165
|
+
module Shim
|
|
166
|
+
extend Fiddle::Importer
|
|
167
|
+
dlload Revault::NativeLibrary.shim_path
|
|
168
|
+
extern 'void ruby_buffer_free(void *)'
|
|
169
|
+
extern 'void ruby_buffer_last_error_details(void *)'
|
|
170
|
+
extern 'void ruby_lockbox_get_file(void *, void *, size_t, void *)'
|
|
171
|
+
extern 'void ruby_lockbox_stream_content(void *, bool, void *)'
|
|
172
|
+
extern 'void ruby_lockbox_cache_stats(void *, void *)'
|
|
173
|
+
extern 'void ruby_lockbox_import_stats(void *, void *)'
|
|
174
|
+
extern 'void ruby_lockbox_inspect_file(void *, size_t, void *)'
|
|
175
|
+
extern 'void ruby_lockbox_page_inspection(void *, void *)'
|
|
176
|
+
extern 'void ruby_lockbox_recovery_report(void *, void *)'
|
|
177
|
+
extern 'void ruby_lockbox_recovery_report_render(void *, bool, size_t, void *)'
|
|
178
|
+
extern 'void ruby_lockbox_recovery_scan_path(void *, size_t, void *, size_t, void *)'
|
|
179
|
+
extern 'void ruby_lockbox_runtime_options(void *, void *)'
|
|
180
|
+
extern 'void ruby_lockbox_list(void *, void *, size_t, bool, void *)'
|
|
181
|
+
extern 'void ruby_lockbox_list_with_options(void *, void *, size_t, void *, size_t, bool, bool, bool, bool, size_t, void *)'
|
|
182
|
+
extern 'void ruby_lockbox_stat(void *, void *, size_t, void *)'
|
|
183
|
+
extern 'void ruby_lockbox_get_variable(void *, void *, size_t, void *)'
|
|
184
|
+
extern 'void ruby_contact_exchange_execute(void *, void *, size_t, void *)'
|
|
185
|
+
extern 'void ruby_lockbox_item_description(void *, void *, size_t, void *)'
|
|
186
|
+
extern 'void ruby_vault_directory_item_description(void *, void *, size_t, void *)'
|
|
187
|
+
extern 'void ruby_lockbox_list_variables(void *, void *)'
|
|
188
|
+
extern 'void ruby_lockbox_variable_sensitivity(void *, void *, size_t, void *)'
|
|
189
|
+
extern 'void ruby_lockbox_get_symlink_target(void *, void *, size_t, void *)'
|
|
190
|
+
extern 'void ruby_lockbox_id(void *, void *)'
|
|
191
|
+
extern 'void ruby_lockbox_read_range(void *, void *, size_t, uint64_t, uint64_t, void *)'
|
|
192
|
+
extern 'void ruby_lockbox_recovery_scan(void *, size_t, void *, size_t, void *)'
|
|
193
|
+
extern 'void ruby_lockbox_list_key_slots(void *, void *)'
|
|
194
|
+
extern 'void ruby_lockbox_owner_inspection(void *, void *)'
|
|
195
|
+
extern 'void ruby_lockbox_define_form(void *, void *, size_t, void *, size_t, void *, size_t, void *, size_t, void *)'
|
|
196
|
+
extern 'void ruby_lockbox_list_form_definitions(void *, void *)'
|
|
197
|
+
extern 'void ruby_lockbox_resolve_form(void *, void *, size_t, void *)'
|
|
198
|
+
extern 'void ruby_lockbox_list_form_revisions(void *, void *, size_t, void *)'
|
|
199
|
+
extern 'void ruby_lockbox_create_form_record(void *, void *, size_t, void *, size_t, void *, size_t, void *)'
|
|
200
|
+
extern 'void ruby_lockbox_list_form_records(void *, void *)'
|
|
201
|
+
extern 'void ruby_lockbox_get_form_record(void *, void *, size_t, void *)'
|
|
202
|
+
extern 'void ruby_lockbox_get_form_field(void *, void *, size_t, void *, size_t, void *)'
|
|
203
|
+
extern 'void ruby_lockbox_to_bytes(void *, void *)'
|
|
204
|
+
extern 'void ruby_key_contact_public(void *, void *)'
|
|
205
|
+
extern 'void ruby_key_contact_private(void *, void *)'
|
|
206
|
+
extern 'void ruby_key_contact_decrypt(void *, void *, void *)'
|
|
207
|
+
extern 'void ruby_key_contact_wrapped_public(void *, void *)'
|
|
208
|
+
extern 'void ruby_key_contact_wrapped_ciphertext(void *, void *)'
|
|
209
|
+
extern 'void ruby_key_contact_wrapped_encrypted(void *, void *)'
|
|
210
|
+
extern 'void ruby_key_signing_public(void *, void *)'
|
|
211
|
+
extern 'void ruby_key_signing_private(void *, void *)'
|
|
212
|
+
extern 'void ruby_vault_key_export_private(void *, void *, size_t, void *)'
|
|
213
|
+
extern 'void ruby_vault_key_export_public(void *, void *, size_t, void *)'
|
|
214
|
+
extern 'void ruby_vault_key_fingerprint(void *, void *)'
|
|
215
|
+
extern 'void ruby_vault_key_format_hex(void *, size_t, void *)'
|
|
216
|
+
extern 'void ruby_vault_key_decode_hex(void *, size_t, void *)'
|
|
217
|
+
extern 'void ruby_vault_key_format_crockford(void *, size_t, void *)'
|
|
218
|
+
extern 'void ruby_vault_key_format_crockford_reading(void *, size_t, void *)'
|
|
219
|
+
extern 'void ruby_vault_key_decode_crockford(void *, size_t, void *)'
|
|
220
|
+
extern 'void ruby_vault_key_hex_encode(void *, size_t, void *)'
|
|
221
|
+
extern 'void ruby_vault_key_hex_decode(void *, size_t, void *)'
|
|
222
|
+
extern 'void ruby_vault_directory_root(void *, void *)'
|
|
223
|
+
extern 'void ruby_vault_directory_list_private_keys(void *, void *)'
|
|
224
|
+
extern 'void ruby_vault_directory_list_private_key_names(void *, void *)'
|
|
225
|
+
extern 'void ruby_vault_directory_list_contact_names(void *, void *)'
|
|
226
|
+
extern 'void ruby_vault_directory_list_form_aliases(void *, void *)'
|
|
227
|
+
extern 'void ruby_vault_directory_list_contacts(void *, void *)'
|
|
228
|
+
extern 'void ruby_vault_directory_profile_email(void *, void *, size_t, void *)'
|
|
229
|
+
extern 'void ruby_vault_directory_load_backup(void *, void *, size_t, void *)'
|
|
230
|
+
extern 'void ruby_vault_directory_list_profile_generations(void *, void *, size_t, void *)'
|
|
231
|
+
extern 'void ruby_vault_directory_rotate_private_key(void *, void *, size_t, void *)'
|
|
232
|
+
extern 'void ruby_vault_directory_list_lockbox_aliases(void *, void *)'
|
|
233
|
+
extern 'void ruby_vault_directory_resolve_lockbox_alias(void *, void *, size_t, void *)'
|
|
234
|
+
extern 'void ruby_vault_read_only_list_lockbox_aliases(void *, void *)'
|
|
235
|
+
extern 'void ruby_vault_read_only_resolve_lockbox_alias(void *, void *, size_t, void *)'
|
|
236
|
+
extern 'void ruby_vault_directory_list_known_lockboxes(void *, void *)'
|
|
237
|
+
extern 'void ruby_vault_directory_list_access_slot_labels(void *, void *, size_t, void *)'
|
|
238
|
+
extern 'void ruby_vault_directory_find_access_slot_labels(void *, void *, size_t, void *, size_t, void *)'
|
|
239
|
+
extern 'void ruby_vault_directory_define_form(void *, void *, size_t, void *, size_t, void *, size_t, void *, size_t, void *)'
|
|
240
|
+
extern 'void ruby_vault_directory_resolve_form(void *, void *, size_t, void *)'
|
|
241
|
+
extern 'void ruby_vault_directory_list_forms(void *, void *)'
|
|
242
|
+
extern 'void ruby_vault_directory_list_form_revisions(void *, void *, size_t, void *)'
|
|
243
|
+
extern 'void ruby_vault_directory_remembered_password(void *, void *, size_t, void *)'
|
|
244
|
+
extern 'void ruby_vault_backup_default(void *, size_t, bool, void *)'
|
|
245
|
+
extern 'void ruby_vault_restore_default(void *, size_t, bool, void *)'
|
|
246
|
+
extern 'void ruby_vault_read_only_list_profile_names(void *, void *)'
|
|
247
|
+
extern 'void ruby_vault_read_only_list_contact_names(void *, void *)'
|
|
248
|
+
extern 'void ruby_vault_read_only_list_form_aliases(void *, void *)'
|
|
249
|
+
extern 'void ruby_vault_read_only_list_known_lockboxes(void *, void *)'
|
|
250
|
+
extern 'void ruby_vault_agent_get(void *, size_t, void *)'
|
|
251
|
+
extern 'void ruby_vault_agent_list(void *)'
|
|
252
|
+
extern 'void ruby_vault_agent_sleep_support(void *)'
|
|
253
|
+
extern 'void ruby_vault_platform_status(void *)'
|
|
254
|
+
extern 'void ruby_vault_platform_get_password(void *)'
|
|
255
|
+
extern 'void ruby_vault_default_directory(void *)'
|
|
256
|
+
extern 'void ruby_vault_default_path(void *)'
|
|
257
|
+
extern 'void ruby_vault_agent_log_path(void *)'
|
|
258
|
+
extern 'void ruby_vault_agent_log_destination(void *)'
|
|
259
|
+
extern 'void ruby_vault_agent_get_vault_unlock_key(void *, size_t, void *)'
|
|
260
|
+
end
|
|
261
|
+
|
|
262
|
+
class BindingOperations
|
|
263
|
+
def initialize = raise('revault-api native ABI mismatch; expected 3') unless Native.api_abi_version == 3
|
|
264
|
+
def last_error_message = Native.buffer_last_error.to_s
|
|
265
|
+
def require_value(value)
|
|
266
|
+
raise RevaultError, last_error_message unless value
|
|
267
|
+
value
|
|
268
|
+
end
|
|
269
|
+
def require_handle(value)
|
|
270
|
+
raise RevaultError, last_error_message if value.nil? || value.null?
|
|
271
|
+
value
|
|
272
|
+
end
|
|
273
|
+
def buffer_call(symbol, *arguments)
|
|
274
|
+
value = Native::BufferStruct.malloc
|
|
275
|
+
Shim.public_send("ruby_#{symbol}", *arguments, value)
|
|
276
|
+
value
|
|
277
|
+
end
|
|
278
|
+
def take(value)
|
|
279
|
+
raise RevaultError, last_error_message if value.ptr.null?
|
|
280
|
+
value.ptr.to_s(value.len)
|
|
281
|
+
ensure
|
|
282
|
+
Shim.ruby_buffer_free(value) if value && !value.ptr.null?
|
|
283
|
+
end
|
|
284
|
+
def with_secret(getter)
|
|
285
|
+
output = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
|
|
286
|
+
raise RevaultError, last_error_message unless getter.call(output)
|
|
287
|
+
address = output[0, Fiddle::SIZEOF_VOIDP].unpack1('J')
|
|
288
|
+
return nil if address.zero?
|
|
289
|
+
handle = Fiddle::Pointer.new(address)
|
|
290
|
+
begin
|
|
291
|
+
length_out = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SIZE_T)
|
|
292
|
+
raise RevaultError, last_error_message unless Native.secret_len(handle, length_out)
|
|
293
|
+
length = length_out[0, Fiddle::SIZEOF_SIZE_T].unpack1('J')
|
|
294
|
+
native = Fiddle::Pointer.malloc([length, 1].max)
|
|
295
|
+
raise RevaultError, last_error_message unless Native.secret_copy(handle, native, length)
|
|
296
|
+
secret = native.to_s(length)
|
|
297
|
+
begin
|
|
298
|
+
yield secret, length
|
|
299
|
+
ensure
|
|
300
|
+
secret.replace("\0" * secret.bytesize)
|
|
301
|
+
native[0, [length, 1].max] = "\0" * [length, 1].max
|
|
302
|
+
end
|
|
303
|
+
ensure
|
|
304
|
+
Native.secret_free(handle)
|
|
305
|
+
end
|
|
306
|
+
end
|
|
307
|
+
|
|
308
|
+
def buffer_last_error_details()
|
|
309
|
+
Revault::Internal::DomainCodec.decode('ErrorDetails', take(buffer_call(:buffer_last_error_details)))
|
|
310
|
+
end
|
|
311
|
+
|
|
312
|
+
def lockbox_format_version()
|
|
313
|
+
Native.lockbox_format_version()
|
|
314
|
+
end
|
|
315
|
+
|
|
316
|
+
def lockbox_probe_format_version(bytes)
|
|
317
|
+
Native.lockbox_probe_format_version(Fiddle::Pointer[bytes], bytes.bytesize)
|
|
318
|
+
end
|
|
319
|
+
|
|
320
|
+
def lockbox_create(key)
|
|
321
|
+
require_handle(Native.lockbox_create(Fiddle::Pointer[key], key.bytesize))
|
|
322
|
+
end
|
|
323
|
+
|
|
324
|
+
def lockbox_create_with_options(key, cache_mode, cache_bytes, workload, worker, jobs)
|
|
325
|
+
require_handle(Native.lockbox_create_with_options(Fiddle::Pointer[key], key.bytesize, Fiddle::Pointer[cache_mode], cache_mode.bytesize, cache_bytes, Fiddle::Pointer[workload], workload.bytesize, Fiddle::Pointer[worker], worker.bytesize, jobs))
|
|
326
|
+
end
|
|
327
|
+
|
|
328
|
+
def lockbox_create_password(password)
|
|
329
|
+
require_handle(Native.lockbox_create_password(Fiddle::Pointer[password], password.bytesize))
|
|
330
|
+
end
|
|
331
|
+
|
|
332
|
+
def lockbox_create_password_with_signing_key(password, signing_key)
|
|
333
|
+
require_handle(Native.lockbox_create_password_with_signing_key(Fiddle::Pointer[password], password.bytesize, signing_key))
|
|
334
|
+
end
|
|
335
|
+
|
|
336
|
+
def lockbox_create_contact(contact)
|
|
337
|
+
require_handle(Native.lockbox_create_contact(contact))
|
|
338
|
+
end
|
|
339
|
+
|
|
340
|
+
def lockbox_create_contact_with_signing_key(contact, signing_key)
|
|
341
|
+
require_handle(Native.lockbox_create_contact_with_signing_key(contact, signing_key))
|
|
342
|
+
end
|
|
343
|
+
|
|
344
|
+
def lockbox_create_with_signing_key(content_key, signing_key)
|
|
345
|
+
require_handle(Native.lockbox_create_with_signing_key(Fiddle::Pointer[content_key], content_key.bytesize, signing_key))
|
|
346
|
+
end
|
|
347
|
+
|
|
348
|
+
# BEGIN generated file operation route
|
|
349
|
+
def lockbox_file(path, mode, credential, secret, contact, signer, cache_mode, cache_bytes, workload, worker, jobs)
|
|
350
|
+
require_handle(Native.lockbox_file(Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[mode], mode.bytesize, Fiddle::Pointer[credential], credential.bytesize, Fiddle::Pointer[secret], secret.bytesize, contact || 0, signer || 0, Fiddle::Pointer[cache_mode], cache_mode.bytesize, cache_bytes, Fiddle::Pointer[workload], workload.bytesize, Fiddle::Pointer[worker], worker.bytesize, jobs))
|
|
351
|
+
end
|
|
352
|
+
# END generated file operation route
|
|
353
|
+
def lockbox_open(archive, key)
|
|
354
|
+
require_handle(Native.lockbox_open(Fiddle::Pointer[archive], archive.bytesize, Fiddle::Pointer[key], key.bytesize))
|
|
355
|
+
end
|
|
356
|
+
|
|
357
|
+
def lockbox_open_with_options(archive, key, cache_mode, cache_bytes, workload, worker, jobs)
|
|
358
|
+
require_handle(Native.lockbox_open_with_options(Fiddle::Pointer[archive], archive.bytesize, Fiddle::Pointer[key], key.bytesize, Fiddle::Pointer[cache_mode], cache_mode.bytesize, cache_bytes, Fiddle::Pointer[workload], workload.bytesize, Fiddle::Pointer[worker], worker.bytesize, jobs))
|
|
359
|
+
end
|
|
360
|
+
|
|
361
|
+
def lockbox_open_password_with_budget(archive, password, max_derivations)
|
|
362
|
+
raise ArgumentError, 'max_derivations must be an unsigned 32-bit integer' unless max_derivations.is_a?(Integer) && max_derivations.between?(0, 0xffffffff)
|
|
363
|
+
require_handle(Native.lockbox_open_password_with_budget(Fiddle::Pointer[archive], archive.bytesize, Fiddle::Pointer[password], password.bytesize, max_derivations))
|
|
364
|
+
end
|
|
365
|
+
def lockbox_extract_file_with_policy(handle, source, destination, max_file_bytes, max_total_bytes, max_files, restore_permissions, overwrite)
|
|
366
|
+
require_value(Native.lockbox_extract_file_with_policy(handle, Fiddle::Pointer[source], source.bytesize, Fiddle::Pointer[destination], destination.bytesize, max_file_bytes, max_total_bytes, max_files, restore_permissions, overwrite))
|
|
367
|
+
end
|
|
368
|
+
def lockbox_open_password(archive, password)
|
|
369
|
+
require_handle(Native.lockbox_open_password(Fiddle::Pointer[archive], archive.bytesize, Fiddle::Pointer[password], password.bytesize))
|
|
370
|
+
end
|
|
371
|
+
|
|
372
|
+
def lockbox_open_contact(archive, contact)
|
|
373
|
+
require_handle(Native.lockbox_open_contact(Fiddle::Pointer[archive], archive.bytesize, contact))
|
|
374
|
+
end
|
|
375
|
+
|
|
376
|
+
def lockbox_add_file(handle, path, data, replace)
|
|
377
|
+
require_value(Native.lockbox_add_file(handle, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[data], data.bytesize, replace))
|
|
378
|
+
end
|
|
379
|
+
|
|
380
|
+
def lockbox_add_file_with_permissions(handle, path, data, permissions, replace)
|
|
381
|
+
require_value(Native.lockbox_add_file_with_permissions(handle, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[data], data.bytesize, permissions, replace))
|
|
382
|
+
end
|
|
383
|
+
|
|
384
|
+
def lockbox_get_file(handle, path)
|
|
385
|
+
take(buffer_call(:lockbox_get_file, handle, Fiddle::Pointer[path], path.bytesize))
|
|
386
|
+
end
|
|
387
|
+
|
|
388
|
+
def lockbox_extract_file(handle, source, destination, replace)
|
|
389
|
+
require_value(Native.lockbox_extract_file(handle, Fiddle::Pointer[source], source.bytesize, Fiddle::Pointer[destination], destination.bytesize, replace))
|
|
390
|
+
end
|
|
391
|
+
|
|
392
|
+
def lockbox_extract_directory(handle, destination, max_file_bytes, max_total_bytes, max_files, restore_symlinks, restore_permissions, overwrite)
|
|
393
|
+
require_value(Native.lockbox_extract_directory(handle, Fiddle::Pointer[destination], destination.bytesize, max_file_bytes, max_total_bytes, max_files, restore_symlinks, restore_permissions, overwrite))
|
|
394
|
+
end
|
|
395
|
+
|
|
396
|
+
def lockbox_stream_content(handle, physical)
|
|
397
|
+
Revault::Internal::DomainCodec.decode('StreamChunkList', take(buffer_call(:lockbox_stream_content, handle, physical)))
|
|
398
|
+
end
|
|
399
|
+
|
|
400
|
+
def lockbox_cache_stats(handle)
|
|
401
|
+
Revault::Internal::DomainCodec.decode('CacheStats', take(buffer_call(:lockbox_cache_stats, handle)))
|
|
402
|
+
end
|
|
403
|
+
|
|
404
|
+
def lockbox_import_stats(handle)
|
|
405
|
+
Revault::Internal::DomainCodec.decode('ImportStats', take(buffer_call(:lockbox_import_stats, handle)))
|
|
406
|
+
end
|
|
407
|
+
|
|
408
|
+
def lockbox_reset_import_stats(handle)
|
|
409
|
+
require_value(Native.lockbox_reset_import_stats(handle))
|
|
410
|
+
end
|
|
411
|
+
|
|
412
|
+
def lockbox_inspect_file(path)
|
|
413
|
+
Revault::Internal::DomainCodec.decode('FileInspection', take(buffer_call(:lockbox_inspect_file, Fiddle::Pointer[path], path.bytesize)))
|
|
414
|
+
end
|
|
415
|
+
|
|
416
|
+
def lockbox_page_inspection(handle)
|
|
417
|
+
Revault::Internal::DomainCodec.decode('PageInspectionList', take(buffer_call(:lockbox_page_inspection, handle)))
|
|
418
|
+
end
|
|
419
|
+
|
|
420
|
+
def lockbox_recovery_report(handle)
|
|
421
|
+
Revault::Internal::DomainCodec.decode('RecoveryReport', take(buffer_call(:lockbox_recovery_report, handle)))
|
|
422
|
+
end
|
|
423
|
+
|
|
424
|
+
def lockbox_recovery_report_render(handle, verbose, max_entries)
|
|
425
|
+
take(buffer_call(:lockbox_recovery_report_render, handle, verbose, max_entries))
|
|
426
|
+
end
|
|
427
|
+
|
|
428
|
+
def lockbox_recovery_scan_path(path, key)
|
|
429
|
+
Revault::Internal::DomainCodec.decode('RecoveryReport', take(buffer_call(:lockbox_recovery_scan_path, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[key], key.bytesize)))
|
|
430
|
+
end
|
|
431
|
+
|
|
432
|
+
def lockbox_storage_len(handle)
|
|
433
|
+
Native.lockbox_storage_len(handle)
|
|
434
|
+
end
|
|
435
|
+
|
|
436
|
+
def lockbox_set_workload_profile(handle, profile)
|
|
437
|
+
require_value(Native.lockbox_set_workload_profile(handle, Fiddle::Pointer[profile], profile.bytesize))
|
|
438
|
+
end
|
|
439
|
+
|
|
440
|
+
def lockbox_set_cache_limit(handle, mode, bytes)
|
|
441
|
+
require_value(Native.lockbox_set_cache_limit(handle, Fiddle::Pointer[mode], mode.bytesize, bytes))
|
|
442
|
+
end
|
|
443
|
+
|
|
444
|
+
def lockbox_set_worker_policy(handle, mode, jobs)
|
|
445
|
+
require_value(Native.lockbox_set_worker_policy(handle, Fiddle::Pointer[mode], mode.bytesize, jobs))
|
|
446
|
+
end
|
|
447
|
+
|
|
448
|
+
def lockbox_runtime_options(handle)
|
|
449
|
+
Revault::Internal::DomainCodec.decode('RuntimeOptions', take(buffer_call(:lockbox_runtime_options, handle)))
|
|
450
|
+
end
|
|
451
|
+
|
|
452
|
+
def lockbox_commit(handle)
|
|
453
|
+
require_value(Native.lockbox_commit(handle))
|
|
454
|
+
end
|
|
455
|
+
|
|
456
|
+
def lockbox_create_dir(handle, path, create_parents)
|
|
457
|
+
require_value(Native.lockbox_create_dir(handle, Fiddle::Pointer[path], path.bytesize, create_parents))
|
|
458
|
+
end
|
|
459
|
+
|
|
460
|
+
def lockbox_delete(handle, path)
|
|
461
|
+
require_value(Native.lockbox_delete(handle, Fiddle::Pointer[path], path.bytesize))
|
|
462
|
+
end
|
|
463
|
+
|
|
464
|
+
def lockbox_remove_dir(handle, path, recursive)
|
|
465
|
+
require_value(Native.lockbox_remove_dir(handle, Fiddle::Pointer[path], path.bytesize, recursive))
|
|
466
|
+
end
|
|
467
|
+
|
|
468
|
+
def lockbox_create_parent_dirs(handle, path)
|
|
469
|
+
require_value(Native.lockbox_create_parent_dirs(handle, Fiddle::Pointer[path], path.bytesize))
|
|
470
|
+
end
|
|
471
|
+
|
|
472
|
+
def lockbox_rename(handle, from, to)
|
|
473
|
+
require_value(Native.lockbox_rename(handle, Fiddle::Pointer[from], from.bytesize, Fiddle::Pointer[to], to.bytesize))
|
|
474
|
+
end
|
|
475
|
+
|
|
476
|
+
def lockbox_list(handle, path, recursive)
|
|
477
|
+
Revault::Internal::DomainCodec.decode('LockboxEntryList', take(buffer_call(:lockbox_list, handle, Fiddle::Pointer[path], path.bytesize, recursive)))
|
|
478
|
+
end
|
|
479
|
+
|
|
480
|
+
def lockbox_list_with_options(handle, path, glob, recursive, include_files, include_symlinks, include_directories, limit)
|
|
481
|
+
Revault::Internal::DomainCodec.decode('LockboxEntryList', take(buffer_call(:lockbox_list_with_options, handle, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[glob], glob.bytesize, recursive, include_files, include_symlinks, include_directories, limit)))
|
|
482
|
+
end
|
|
483
|
+
|
|
484
|
+
def lockbox_stat(handle, path)
|
|
485
|
+
Revault::Internal::DomainCodec.decode('OptionalLockboxEntry', take(buffer_call(:lockbox_stat, handle, Fiddle::Pointer[path], path.bytesize)))
|
|
486
|
+
end
|
|
487
|
+
|
|
488
|
+
def lockbox_set_variable(handle, name, value)
|
|
489
|
+
require_value(Native.lockbox_set_variable(handle, Fiddle::Pointer[name], name.bytesize, Fiddle::Pointer[value], value.bytesize))
|
|
490
|
+
end
|
|
491
|
+
|
|
492
|
+
def lockbox_set_secret_variable(handle, name, value)
|
|
493
|
+
secret = value.dup
|
|
494
|
+
require_value(Native.lockbox_set_secret_variable(handle, Fiddle::Pointer[name], name.bytesize, Fiddle::Pointer[secret], secret.bytesize))
|
|
495
|
+
ensure
|
|
496
|
+
secret&.replace("\0" * secret.bytesize)
|
|
497
|
+
end
|
|
498
|
+
|
|
499
|
+
def lockbox_get_variable(handle, name)
|
|
500
|
+
value = Revault::Internal::DomainCodec.decode('OptionalString', take(buffer_call(:lockbox_get_variable, handle, Fiddle::Pointer[name], name.bytesize)))
|
|
501
|
+
value.present ? value.value : nil
|
|
502
|
+
end
|
|
503
|
+
def contact_exchange_execute(handle, name)
|
|
504
|
+
Revault::Internal::DomainCodec.decode('ContactExchangeStatusList', take(buffer_call(:contact_exchange_execute, handle, Fiddle::Pointer[name], name.bytesize))).values
|
|
505
|
+
end
|
|
506
|
+
def lockbox_item_description(handle, name)
|
|
507
|
+
value = Revault::Internal::DomainCodec.decode('OptionalString', take(buffer_call(:lockbox_item_description, handle, Fiddle::Pointer[name], name.bytesize)))
|
|
508
|
+
value.present ? value.value : nil
|
|
509
|
+
end
|
|
510
|
+
def vault_directory_item_description(handle, name)
|
|
511
|
+
value = Revault::Internal::DomainCodec.decode('OptionalString', take(buffer_call(:vault_directory_item_description, handle, Fiddle::Pointer[name], name.bytesize)))
|
|
512
|
+
value.present ? value.value : nil
|
|
513
|
+
end
|
|
514
|
+
|
|
515
|
+
def lockbox_get_secret_variable(handle, name, &callback)
|
|
516
|
+
with_secret(->(output) { Native.lockbox_get_secret_variable(handle, Fiddle::Pointer[name], name.bytesize, output) }, &callback)
|
|
517
|
+
end
|
|
518
|
+
|
|
519
|
+
def lockbox_delete_variable(handle, name)
|
|
520
|
+
require_value(Native.lockbox_delete_variable(handle, Fiddle::Pointer[name], name.bytesize))
|
|
521
|
+
end
|
|
522
|
+
|
|
523
|
+
def lockbox_move_variables(handle, moves_flatbuffer)
|
|
524
|
+
require_value(Native.lockbox_move_variables(handle, Fiddle::Pointer[moves_flatbuffer], moves_flatbuffer.bytesize))
|
|
525
|
+
end
|
|
526
|
+
|
|
527
|
+
def lockbox_list_variables(handle)
|
|
528
|
+
Revault::Internal::DomainCodec.decode('VariableList', take(buffer_call(:lockbox_list_variables, handle)))
|
|
529
|
+
end
|
|
530
|
+
|
|
531
|
+
def lockbox_variable_sensitivity(handle, name)
|
|
532
|
+
Revault::Internal::DomainCodec.decode('OptionalString', take(buffer_call(:lockbox_variable_sensitivity, handle, Fiddle::Pointer[name], name.bytesize)))
|
|
533
|
+
end
|
|
534
|
+
|
|
535
|
+
def lockbox_add_symlink(handle, path, target, replace)
|
|
536
|
+
require_value(Native.lockbox_add_symlink(handle, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[target], target.bytesize, replace))
|
|
537
|
+
end
|
|
538
|
+
|
|
539
|
+
def lockbox_get_symlink_target(handle, path)
|
|
540
|
+
take(buffer_call(:lockbox_get_symlink_target, handle, Fiddle::Pointer[path], path.bytesize))
|
|
541
|
+
end
|
|
542
|
+
|
|
543
|
+
def lockbox_id(handle)
|
|
544
|
+
take(buffer_call(:lockbox_id, handle))
|
|
545
|
+
end
|
|
546
|
+
|
|
547
|
+
def lockbox_exists(handle, path)
|
|
548
|
+
Native.lockbox_exists(handle, Fiddle::Pointer[path], path.bytesize)
|
|
549
|
+
end
|
|
550
|
+
|
|
551
|
+
def lockbox_is_dir(handle, path)
|
|
552
|
+
Native.lockbox_is_dir(handle, Fiddle::Pointer[path], path.bytesize)
|
|
553
|
+
end
|
|
554
|
+
|
|
555
|
+
def lockbox_permissions(handle, path)
|
|
556
|
+
Native.lockbox_permissions(handle, Fiddle::Pointer[path], path.bytesize)
|
|
557
|
+
end
|
|
558
|
+
|
|
559
|
+
def lockbox_set_permissions(handle, path, permissions)
|
|
560
|
+
require_value(Native.lockbox_set_permissions(handle, Fiddle::Pointer[path], path.bytesize, permissions))
|
|
561
|
+
end
|
|
562
|
+
|
|
563
|
+
def lockbox_read_range(handle, path, offset, len)
|
|
564
|
+
take(buffer_call(:lockbox_read_range, handle, Fiddle::Pointer[path], path.bytesize, offset, len))
|
|
565
|
+
end
|
|
566
|
+
|
|
567
|
+
def lockbox_recovery_scan(bytes, key)
|
|
568
|
+
Revault::Internal::DomainCodec.decode('RecoveryReport', take(buffer_call(:lockbox_recovery_scan, Fiddle::Pointer[bytes], bytes.bytesize, Fiddle::Pointer[key], key.bytesize)))
|
|
569
|
+
end
|
|
570
|
+
|
|
571
|
+
def lockbox_recovery_salvage(bytes, key, signing_key)
|
|
572
|
+
require_handle(Native.lockbox_recovery_salvage(Fiddle::Pointer[bytes], bytes.bytesize, Fiddle::Pointer[key], key.bytesize, signing_key))
|
|
573
|
+
end
|
|
574
|
+
|
|
575
|
+
def lockbox_add_password(handle, password)
|
|
576
|
+
Native.lockbox_add_password(handle, Fiddle::Pointer[password], password.bytesize)
|
|
577
|
+
end
|
|
578
|
+
|
|
579
|
+
def lockbox_add_contact(handle, contact, name)
|
|
580
|
+
Native.lockbox_add_contact(handle, contact, Fiddle::Pointer[name], name.bytesize)
|
|
581
|
+
end
|
|
582
|
+
|
|
583
|
+
def lockbox_delete_key(handle, id)
|
|
584
|
+
require_value(Native.lockbox_delete_key(handle, id))
|
|
585
|
+
end
|
|
586
|
+
|
|
587
|
+
def lockbox_list_key_slots(handle)
|
|
588
|
+
Revault::Internal::DomainCodec.decode('KeySlotList', take(buffer_call(:lockbox_list_key_slots, handle)))
|
|
589
|
+
end
|
|
590
|
+
|
|
591
|
+
def lockbox_set_owner_signing_key(handle, key)
|
|
592
|
+
require_value(Native.lockbox_set_owner_signing_key(handle, key))
|
|
593
|
+
end
|
|
594
|
+
|
|
595
|
+
def lockbox_owner_inspection(handle)
|
|
596
|
+
Revault::Internal::DomainCodec.decode('OwnerInspection', take(buffer_call(:lockbox_owner_inspection, handle)))
|
|
597
|
+
end
|
|
598
|
+
|
|
599
|
+
def lockbox_define_form(handle, alias_name, name, description, fields_flatbuffer)
|
|
600
|
+
Revault::Internal::DomainCodec.decode('FormDefinition', take(buffer_call(:lockbox_define_form, handle, Fiddle::Pointer[alias_name], alias_name.bytesize, Fiddle::Pointer[name], name.bytesize, Fiddle::Pointer[description], description.bytesize, Fiddle::Pointer[fields_flatbuffer], fields_flatbuffer.bytesize)))
|
|
601
|
+
end
|
|
602
|
+
|
|
603
|
+
def lockbox_list_form_definitions(handle)
|
|
604
|
+
Revault::Internal::DomainCodec.decode('FormDefinitionList', take(buffer_call(:lockbox_list_form_definitions, handle)))
|
|
605
|
+
end
|
|
606
|
+
|
|
607
|
+
def lockbox_resolve_form(handle, reference)
|
|
608
|
+
Revault::Internal::DomainCodec.decode('FormDefinition', take(buffer_call(:lockbox_resolve_form, handle, Fiddle::Pointer[reference], reference.bytesize)))
|
|
609
|
+
end
|
|
610
|
+
|
|
611
|
+
def lockbox_list_form_revisions(handle, type_id)
|
|
612
|
+
Revault::Internal::DomainCodec.decode('FormDefinitionList', take(buffer_call(:lockbox_list_form_revisions, handle, Fiddle::Pointer[type_id], type_id.bytesize)))
|
|
613
|
+
end
|
|
614
|
+
|
|
615
|
+
def lockbox_create_form_record(handle, path, type_reference, name)
|
|
616
|
+
Revault::Internal::DomainCodec.decode('FormRecord', take(buffer_call(:lockbox_create_form_record, handle, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[type_reference], type_reference.bytesize, Fiddle::Pointer[name], name.bytesize)))
|
|
617
|
+
end
|
|
618
|
+
|
|
619
|
+
def lockbox_set_form_field(handle, path, field, value)
|
|
620
|
+
require_value(Native.lockbox_set_form_field(handle, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[field], field.bytesize, Fiddle::Pointer[value], value.bytesize))
|
|
621
|
+
end
|
|
622
|
+
|
|
623
|
+
def lockbox_set_secret_form_field(handle, path, field, value)
|
|
624
|
+
secret = value.dup
|
|
625
|
+
require_value(Native.lockbox_set_secret_form_field(handle, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[field], field.bytesize, Fiddle::Pointer[secret], secret.bytesize))
|
|
626
|
+
ensure
|
|
627
|
+
secret&.replace("\0" * secret.bytesize)
|
|
628
|
+
end
|
|
629
|
+
|
|
630
|
+
def lockbox_list_form_records(handle)
|
|
631
|
+
Revault::Internal::DomainCodec.decode('FormRecordList', take(buffer_call(:lockbox_list_form_records, handle)))
|
|
632
|
+
end
|
|
633
|
+
|
|
634
|
+
def lockbox_get_form_record(handle, path)
|
|
635
|
+
Revault::Internal::DomainCodec.decode('OptionalFormRecord', take(buffer_call(:lockbox_get_form_record, handle, Fiddle::Pointer[path], path.bytesize)))
|
|
636
|
+
end
|
|
637
|
+
|
|
638
|
+
def lockbox_delete_form_record(handle, path)
|
|
639
|
+
require_value(Native.lockbox_delete_form_record(handle, Fiddle::Pointer[path], path.bytesize))
|
|
640
|
+
end
|
|
641
|
+
|
|
642
|
+
def lockbox_move_form_records(handle, moves_flatbuffer)
|
|
643
|
+
require_value(Native.lockbox_move_form_records(handle, Fiddle::Pointer[moves_flatbuffer], moves_flatbuffer.bytesize))
|
|
644
|
+
end
|
|
645
|
+
|
|
646
|
+
def lockbox_get_form_field(handle, path, field)
|
|
647
|
+
Revault::Internal::DomainCodec.decode('OptionalFormValue', take(buffer_call(:lockbox_get_form_field, handle, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[field], field.bytesize)))
|
|
648
|
+
end
|
|
649
|
+
|
|
650
|
+
def lockbox_get_secret_form_field(handle, path, field, &callback)
|
|
651
|
+
with_secret(->(output) { Native.lockbox_get_secret_form_field(handle, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[field], field.bytesize, output) }, &callback)
|
|
652
|
+
end
|
|
653
|
+
|
|
654
|
+
def lockbox_to_bytes(handle)
|
|
655
|
+
take(buffer_call(:lockbox_to_bytes, handle))
|
|
656
|
+
end
|
|
657
|
+
|
|
658
|
+
def lockbox_free(handle)
|
|
659
|
+
Native.lockbox_free(handle)
|
|
660
|
+
end
|
|
661
|
+
|
|
662
|
+
def vault_is_running()
|
|
663
|
+
Native.vault_is_running()
|
|
664
|
+
end
|
|
665
|
+
|
|
666
|
+
def vault_forget_all()
|
|
667
|
+
require_value(Native.vault_forget_all())
|
|
668
|
+
end
|
|
669
|
+
|
|
670
|
+
def key_contact_generate()
|
|
671
|
+
require_handle(Native.key_contact_generate())
|
|
672
|
+
end
|
|
673
|
+
|
|
674
|
+
def key_contact_from_private(bytes)
|
|
675
|
+
require_handle(Native.key_contact_from_private(Fiddle::Pointer[bytes], bytes.bytesize))
|
|
676
|
+
end
|
|
677
|
+
|
|
678
|
+
def key_contact_public(handle)
|
|
679
|
+
take(buffer_call(:key_contact_public, handle))
|
|
680
|
+
end
|
|
681
|
+
|
|
682
|
+
def key_contact_private(handle)
|
|
683
|
+
take(buffer_call(:key_contact_private, handle))
|
|
684
|
+
end
|
|
685
|
+
|
|
686
|
+
def key_contact_public_from_bytes(bytes)
|
|
687
|
+
require_handle(Native.key_contact_public_from_bytes(Fiddle::Pointer[bytes], bytes.bytesize))
|
|
688
|
+
end
|
|
689
|
+
|
|
690
|
+
def key_contact_public_free(handle)
|
|
691
|
+
Native.key_contact_public_free(handle)
|
|
692
|
+
end
|
|
693
|
+
|
|
694
|
+
def key_contact_free(handle)
|
|
695
|
+
Native.key_contact_free(handle)
|
|
696
|
+
end
|
|
697
|
+
|
|
698
|
+
def key_contact_encrypt(contact, content_key)
|
|
699
|
+
require_handle(Native.key_contact_encrypt(contact, Fiddle::Pointer[content_key], content_key.bytesize))
|
|
700
|
+
end
|
|
701
|
+
|
|
702
|
+
def key_contact_decrypt(contact, wrapped)
|
|
703
|
+
take(buffer_call(:key_contact_decrypt, contact, wrapped))
|
|
704
|
+
end
|
|
705
|
+
|
|
706
|
+
def key_contact_wrapped_public(wrapped)
|
|
707
|
+
take(buffer_call(:key_contact_wrapped_public, wrapped))
|
|
708
|
+
end
|
|
709
|
+
|
|
710
|
+
def key_contact_wrapped_ciphertext(wrapped)
|
|
711
|
+
take(buffer_call(:key_contact_wrapped_ciphertext, wrapped))
|
|
712
|
+
end
|
|
713
|
+
|
|
714
|
+
def key_contact_wrapped_encrypted(wrapped)
|
|
715
|
+
take(buffer_call(:key_contact_wrapped_encrypted, wrapped))
|
|
716
|
+
end
|
|
717
|
+
|
|
718
|
+
def key_contact_wrapped_free(handle)
|
|
719
|
+
Native.key_contact_wrapped_free(handle)
|
|
720
|
+
end
|
|
721
|
+
|
|
722
|
+
def key_signing_generate()
|
|
723
|
+
require_handle(Native.key_signing_generate())
|
|
724
|
+
end
|
|
725
|
+
|
|
726
|
+
def key_signing_from_private(bytes)
|
|
727
|
+
require_handle(Native.key_signing_from_private(Fiddle::Pointer[bytes], bytes.bytesize))
|
|
728
|
+
end
|
|
729
|
+
|
|
730
|
+
def key_signing_public(handle)
|
|
731
|
+
take(buffer_call(:key_signing_public, handle))
|
|
732
|
+
end
|
|
733
|
+
|
|
734
|
+
def key_signing_private(handle)
|
|
735
|
+
take(buffer_call(:key_signing_private, handle))
|
|
736
|
+
end
|
|
737
|
+
|
|
738
|
+
def key_signing_public_from_bytes(bytes)
|
|
739
|
+
require_handle(Native.key_signing_public_from_bytes(Fiddle::Pointer[bytes], bytes.bytesize))
|
|
740
|
+
end
|
|
741
|
+
|
|
742
|
+
def key_signing_public_free(handle)
|
|
743
|
+
Native.key_signing_public_free(handle)
|
|
744
|
+
end
|
|
745
|
+
|
|
746
|
+
def key_signing_free(handle)
|
|
747
|
+
Native.key_signing_free(handle)
|
|
748
|
+
end
|
|
749
|
+
|
|
750
|
+
def vault_key_export_private(key, format)
|
|
751
|
+
take(buffer_call(:vault_key_export_private, key, Fiddle::Pointer[format], format.bytesize))
|
|
752
|
+
end
|
|
753
|
+
|
|
754
|
+
def vault_key_export_public(key, format)
|
|
755
|
+
take(buffer_call(:vault_key_export_public, key, Fiddle::Pointer[format], format.bytesize))
|
|
756
|
+
end
|
|
757
|
+
|
|
758
|
+
def vault_key_import_private(bytes)
|
|
759
|
+
require_handle(Native.vault_key_import_private(Fiddle::Pointer[bytes], bytes.bytesize))
|
|
760
|
+
end
|
|
761
|
+
|
|
762
|
+
def vault_key_import_public(bytes)
|
|
763
|
+
require_handle(Native.vault_key_import_public(Fiddle::Pointer[bytes], bytes.bytesize))
|
|
764
|
+
end
|
|
765
|
+
|
|
766
|
+
def vault_key_fingerprint(key)
|
|
767
|
+
take(buffer_call(:vault_key_fingerprint, key))
|
|
768
|
+
end
|
|
769
|
+
|
|
770
|
+
def vault_key_format_hex(bytes)
|
|
771
|
+
take(buffer_call(:vault_key_format_hex, Fiddle::Pointer[bytes], bytes.bytesize))
|
|
772
|
+
end
|
|
773
|
+
|
|
774
|
+
def vault_key_decode_hex(text)
|
|
775
|
+
take(buffer_call(:vault_key_decode_hex, Fiddle::Pointer[text], text.bytesize))
|
|
776
|
+
end
|
|
777
|
+
|
|
778
|
+
def vault_key_format_crockford(bytes)
|
|
779
|
+
take(buffer_call(:vault_key_format_crockford, Fiddle::Pointer[bytes], bytes.bytesize))
|
|
780
|
+
end
|
|
781
|
+
|
|
782
|
+
def vault_key_format_crockford_reading(code)
|
|
783
|
+
take(buffer_call(:vault_key_format_crockford_reading, Fiddle::Pointer[code], code.bytesize))
|
|
784
|
+
end
|
|
785
|
+
|
|
786
|
+
def vault_key_decode_crockford(code)
|
|
787
|
+
take(buffer_call(:vault_key_decode_crockford, Fiddle::Pointer[code], code.bytesize))
|
|
788
|
+
end
|
|
789
|
+
|
|
790
|
+
def vault_key_hex_encode(bytes)
|
|
791
|
+
take(buffer_call(:vault_key_hex_encode, Fiddle::Pointer[bytes], bytes.bytesize))
|
|
792
|
+
end
|
|
793
|
+
|
|
794
|
+
def vault_key_hex_decode(text)
|
|
795
|
+
take(buffer_call(:vault_key_hex_decode, Fiddle::Pointer[text], text.bytesize))
|
|
796
|
+
end
|
|
797
|
+
|
|
798
|
+
def vault_directory_open(root, password)
|
|
799
|
+
require_handle(Native.vault_directory_open(Fiddle::Pointer[root], root.bytesize, Fiddle::Pointer[password], password.bytesize))
|
|
800
|
+
end
|
|
801
|
+
def contact_exchange_open(root, password)
|
|
802
|
+
require_handle(Native.contact_exchange_open(Fiddle::Pointer[root], root.bytesize, Fiddle::Pointer[password], password.bytesize))
|
|
803
|
+
end
|
|
804
|
+
|
|
805
|
+
def vault_structure_version_current()
|
|
806
|
+
Native.vault_structure_version_current()
|
|
807
|
+
end
|
|
808
|
+
|
|
809
|
+
def vault_directory_probe_structure_version(root, password)
|
|
810
|
+
Native.vault_directory_probe_structure_version(Fiddle::Pointer[root], root.bytesize, Fiddle::Pointer[password], password.bytesize)
|
|
811
|
+
end
|
|
812
|
+
|
|
813
|
+
def vault_directory_open_or_create_default(password)
|
|
814
|
+
require_handle(Native.vault_directory_open_or_create_default(Fiddle::Pointer[password], password.bytesize))
|
|
815
|
+
end
|
|
816
|
+
|
|
817
|
+
def vault_directory_replace_default(password)
|
|
818
|
+
require_handle(Native.vault_directory_replace_default(Fiddle::Pointer[password], password.bytesize))
|
|
819
|
+
end
|
|
820
|
+
|
|
821
|
+
def vault_directory_change_password(root, old_password, new_password)
|
|
822
|
+
require_value(Native.vault_directory_change_password(Fiddle::Pointer[root], root.bytesize, Fiddle::Pointer[old_password], old_password.bytesize, Fiddle::Pointer[new_password], new_password.bytesize))
|
|
823
|
+
end
|
|
824
|
+
|
|
825
|
+
def vault_directory_change_default_password(old_password, new_password)
|
|
826
|
+
require_value(Native.vault_directory_change_default_password(Fiddle::Pointer[old_password], old_password.bytesize, Fiddle::Pointer[new_password], new_password.bytesize))
|
|
827
|
+
end
|
|
828
|
+
|
|
829
|
+
def vault_directory_replace(root, password)
|
|
830
|
+
require_handle(Native.vault_directory_replace(Fiddle::Pointer[root], root.bytesize, Fiddle::Pointer[password], password.bytesize))
|
|
831
|
+
end
|
|
832
|
+
|
|
833
|
+
def vault_directory_open_or_create(root, password)
|
|
834
|
+
require_handle(Native.vault_directory_open_or_create(Fiddle::Pointer[root], root.bytesize, Fiddle::Pointer[password], password.bytesize))
|
|
835
|
+
end
|
|
836
|
+
|
|
837
|
+
def vault_directory_root(handle)
|
|
838
|
+
take(buffer_call(:vault_directory_root, handle))
|
|
839
|
+
end
|
|
840
|
+
|
|
841
|
+
def vault_directory_structure_version(handle)
|
|
842
|
+
Native.vault_directory_structure_version(handle)
|
|
843
|
+
end
|
|
844
|
+
|
|
845
|
+
def vault_directory_list_private_keys(handle)
|
|
846
|
+
Revault::Internal::DomainCodec.decode('StringList', take(buffer_call(:vault_directory_list_private_keys, handle)))
|
|
847
|
+
end
|
|
848
|
+
|
|
849
|
+
def vault_directory_list_private_key_names(handle)
|
|
850
|
+
Revault::Internal::DomainCodec.decode('StringList', take(buffer_call(:vault_directory_list_private_key_names, handle)))
|
|
851
|
+
end
|
|
852
|
+
|
|
853
|
+
def vault_directory_list_contact_names(handle)
|
|
854
|
+
Revault::Internal::DomainCodec.decode('StringList', take(buffer_call(:vault_directory_list_contact_names, handle)))
|
|
855
|
+
end
|
|
856
|
+
|
|
857
|
+
def vault_directory_list_form_aliases(handle)
|
|
858
|
+
Revault::Internal::DomainCodec.decode('StringList', take(buffer_call(:vault_directory_list_form_aliases, handle)))
|
|
859
|
+
end
|
|
860
|
+
|
|
861
|
+
def vault_directory_private_key_exists(handle, name)
|
|
862
|
+
Native.vault_directory_private_key_exists(handle, Fiddle::Pointer[name], name.bytesize)
|
|
863
|
+
end
|
|
864
|
+
|
|
865
|
+
def vault_directory_delete_private_key(handle, name)
|
|
866
|
+
require_value(Native.vault_directory_delete_private_key(handle, Fiddle::Pointer[name], name.bytesize))
|
|
867
|
+
end
|
|
868
|
+
|
|
869
|
+
def vault_directory_store_private_key(handle, name, key)
|
|
870
|
+
require_value(Native.vault_directory_store_private_key(handle, Fiddle::Pointer[name], name.bytesize, key))
|
|
871
|
+
end
|
|
872
|
+
|
|
873
|
+
def vault_directory_load_private_key(handle, name)
|
|
874
|
+
require_handle(Native.vault_directory_load_private_key(handle, Fiddle::Pointer[name], name.bytesize))
|
|
875
|
+
end
|
|
876
|
+
|
|
877
|
+
def vault_directory_load_private_key_generation(handle, name, index)
|
|
878
|
+
require_handle(Native.vault_directory_load_private_key_generation(handle, Fiddle::Pointer[name], name.bytesize, index))
|
|
879
|
+
end
|
|
880
|
+
|
|
881
|
+
def vault_directory_store_contact(handle, name, key)
|
|
882
|
+
require_value(Native.vault_directory_store_contact(handle, Fiddle::Pointer[name], name.bytesize, key))
|
|
883
|
+
end
|
|
884
|
+
|
|
885
|
+
def vault_directory_load_contact(handle, name)
|
|
886
|
+
require_handle(Native.vault_directory_load_contact(handle, Fiddle::Pointer[name], name.bytesize))
|
|
887
|
+
end
|
|
888
|
+
|
|
889
|
+
def vault_directory_contact_exists(handle, name)
|
|
890
|
+
Native.vault_directory_contact_exists(handle, Fiddle::Pointer[name], name.bytesize)
|
|
891
|
+
end
|
|
892
|
+
|
|
893
|
+
def vault_directory_delete_contact(handle, name)
|
|
894
|
+
require_value(Native.vault_directory_delete_contact(handle, Fiddle::Pointer[name], name.bytesize))
|
|
895
|
+
end
|
|
896
|
+
|
|
897
|
+
def vault_directory_list_contacts(handle)
|
|
898
|
+
Revault::Internal::DomainCodec.decode('ContactList', take(buffer_call(:vault_directory_list_contacts, handle)))
|
|
899
|
+
end
|
|
900
|
+
|
|
901
|
+
def vault_directory_store_profile_email(handle, name, email)
|
|
902
|
+
require_value(Native.vault_directory_store_profile_email(handle, Fiddle::Pointer[name], name.bytesize, Fiddle::Pointer[email], email.bytesize))
|
|
903
|
+
end
|
|
904
|
+
|
|
905
|
+
def vault_directory_profile_email(handle, name)
|
|
906
|
+
Revault::Internal::DomainCodec.decode('OptionalString', take(buffer_call(:vault_directory_profile_email, handle, Fiddle::Pointer[name], name.bytesize)))
|
|
907
|
+
end
|
|
908
|
+
|
|
909
|
+
def vault_directory_store_backup(handle, id, bytes)
|
|
910
|
+
require_value(Native.vault_directory_store_backup(handle, Fiddle::Pointer[id], id.bytesize, Fiddle::Pointer[bytes], bytes.bytesize))
|
|
911
|
+
end
|
|
912
|
+
|
|
913
|
+
def vault_directory_load_backup(handle, id)
|
|
914
|
+
take(buffer_call(:vault_directory_load_backup, handle, Fiddle::Pointer[id], id.bytesize))
|
|
915
|
+
end
|
|
916
|
+
|
|
917
|
+
def vault_directory_backup_count(handle)
|
|
918
|
+
Native.vault_directory_backup_count(handle)
|
|
919
|
+
end
|
|
920
|
+
|
|
921
|
+
def vault_directory_restore_private_key(handle, name, key, signing_key, overwrite)
|
|
922
|
+
require_value(Native.vault_directory_restore_private_key(handle, Fiddle::Pointer[name], name.bytesize, key, signing_key, overwrite))
|
|
923
|
+
end
|
|
924
|
+
|
|
925
|
+
def vault_directory_load_owner_signing_key(handle, name)
|
|
926
|
+
require_handle(Native.vault_directory_load_owner_signing_key(handle, Fiddle::Pointer[name], name.bytesize))
|
|
927
|
+
end
|
|
928
|
+
|
|
929
|
+
def vault_directory_load_owner_signing_key_generation(handle, name, index)
|
|
930
|
+
require_handle(Native.vault_directory_load_owner_signing_key_generation(handle, Fiddle::Pointer[name], name.bytesize, index))
|
|
931
|
+
end
|
|
932
|
+
|
|
933
|
+
def vault_directory_store_contact_signing_key(handle, name, key)
|
|
934
|
+
require_value(Native.vault_directory_store_contact_signing_key(handle, Fiddle::Pointer[name], name.bytesize, key))
|
|
935
|
+
end
|
|
936
|
+
|
|
937
|
+
def vault_directory_load_contact_signing_key(handle, name)
|
|
938
|
+
require_handle(Native.vault_directory_load_contact_signing_key(handle, Fiddle::Pointer[name], name.bytesize))
|
|
939
|
+
end
|
|
940
|
+
|
|
941
|
+
def vault_directory_list_profile_generations(handle, name)
|
|
942
|
+
Revault::Internal::DomainCodec.decode('ProfileHistory', take(buffer_call(:vault_directory_list_profile_generations, handle, Fiddle::Pointer[name], name.bytesize)))
|
|
943
|
+
end
|
|
944
|
+
|
|
945
|
+
def vault_directory_rotate_private_key(handle, name)
|
|
946
|
+
Revault::Internal::DomainCodec.decode('ProfileHistory', take(buffer_call(:vault_directory_rotate_private_key, handle, Fiddle::Pointer[name], name.bytesize)))
|
|
947
|
+
end
|
|
948
|
+
|
|
949
|
+
def vault_directory_remember_lockbox(handle, id, path)
|
|
950
|
+
require_value(Native.vault_directory_remember_lockbox(handle, Fiddle::Pointer[id], id.bytesize, Fiddle::Pointer[path], path.bytesize))
|
|
951
|
+
end
|
|
952
|
+
|
|
953
|
+
def vault_directory_set_lockbox_alias(handle, name, id)
|
|
954
|
+
require_value(Native.vault_directory_set_lockbox_alias(handle, Fiddle::Pointer[name], name.bytesize, Fiddle::Pointer[id], id.bytesize))
|
|
955
|
+
end
|
|
956
|
+
|
|
957
|
+
def vault_directory_list_lockbox_aliases(handle)
|
|
958
|
+
Revault::Internal::DomainCodec.decode('LockboxAliasList', take(buffer_call(:vault_directory_list_lockbox_aliases, handle)))
|
|
959
|
+
end
|
|
960
|
+
|
|
961
|
+
def vault_directory_remove_lockbox_alias(handle, name)
|
|
962
|
+
require_value(Native.vault_directory_remove_lockbox_alias(handle, Fiddle::Pointer[name], name.bytesize))
|
|
963
|
+
end
|
|
964
|
+
|
|
965
|
+
def vault_directory_resolve_lockbox_alias(handle, name)
|
|
966
|
+
Revault::Internal::DomainCodec.decode('KnownLockbox', take(buffer_call(:vault_directory_resolve_lockbox_alias, handle, Fiddle::Pointer[name], name.bytesize)))
|
|
967
|
+
end
|
|
968
|
+
|
|
969
|
+
def vault_read_only_list_lockbox_aliases(handle)
|
|
970
|
+
Revault::Internal::DomainCodec.decode('LockboxAliasList', take(buffer_call(:vault_read_only_list_lockbox_aliases, handle)))
|
|
971
|
+
end
|
|
972
|
+
|
|
973
|
+
def vault_read_only_resolve_lockbox_alias(handle, name)
|
|
974
|
+
Revault::Internal::DomainCodec.decode('KnownLockbox', take(buffer_call(:vault_read_only_resolve_lockbox_alias, handle, Fiddle::Pointer[name], name.bytesize)))
|
|
975
|
+
end
|
|
976
|
+
|
|
977
|
+
def vault_directory_list_known_lockboxes(handle)
|
|
978
|
+
Revault::Internal::DomainCodec.decode('KnownLockboxList', take(buffer_call(:vault_directory_list_known_lockboxes, handle)))
|
|
979
|
+
end
|
|
980
|
+
|
|
981
|
+
def vault_directory_forget_lockbox(handle, path)
|
|
982
|
+
require_value(Native.vault_directory_forget_lockbox(handle, Fiddle::Pointer[path], path.bytesize))
|
|
983
|
+
end
|
|
984
|
+
|
|
985
|
+
def vault_directory_remember_access_slot_label(handle, id, slot_id, name)
|
|
986
|
+
require_value(Native.vault_directory_remember_access_slot_label(handle, Fiddle::Pointer[id], id.bytesize, slot_id, Fiddle::Pointer[name], name.bytesize))
|
|
987
|
+
end
|
|
988
|
+
|
|
989
|
+
def vault_directory_list_access_slot_labels(handle, id)
|
|
990
|
+
Revault::Internal::DomainCodec.decode('AccessSlotLabelList', take(buffer_call(:vault_directory_list_access_slot_labels, handle, Fiddle::Pointer[id], id.bytesize)))
|
|
991
|
+
end
|
|
992
|
+
|
|
993
|
+
def vault_directory_find_access_slot_labels(handle, id, name)
|
|
994
|
+
Revault::Internal::DomainCodec.decode('AccessSlotLabelList', take(buffer_call(:vault_directory_find_access_slot_labels, handle, Fiddle::Pointer[id], id.bytesize, Fiddle::Pointer[name], name.bytesize)))
|
|
995
|
+
end
|
|
996
|
+
|
|
997
|
+
def vault_directory_forget_access_slot_label(handle, id, slot_id)
|
|
998
|
+
require_value(Native.vault_directory_forget_access_slot_label(handle, Fiddle::Pointer[id], id.bytesize, slot_id))
|
|
999
|
+
end
|
|
1000
|
+
|
|
1001
|
+
def vault_directory_define_form(handle, alias_name, name, description, fields_flatbuffer)
|
|
1002
|
+
Revault::Internal::DomainCodec.decode('FormDefinition', take(buffer_call(:vault_directory_define_form, handle, Fiddle::Pointer[alias_name], alias_name.bytesize, Fiddle::Pointer[name], name.bytesize, Fiddle::Pointer[description], description.bytesize, Fiddle::Pointer[fields_flatbuffer], fields_flatbuffer.bytesize)))
|
|
1003
|
+
end
|
|
1004
|
+
|
|
1005
|
+
def vault_directory_resolve_form(handle, reference)
|
|
1006
|
+
Revault::Internal::DomainCodec.decode('FormDefinition', take(buffer_call(:vault_directory_resolve_form, handle, Fiddle::Pointer[reference], reference.bytesize)))
|
|
1007
|
+
end
|
|
1008
|
+
|
|
1009
|
+
def vault_directory_list_forms(handle)
|
|
1010
|
+
Revault::Internal::DomainCodec.decode('FormDefinitionList', take(buffer_call(:vault_directory_list_forms, handle)))
|
|
1011
|
+
end
|
|
1012
|
+
|
|
1013
|
+
def vault_directory_list_form_revisions(handle, type_id)
|
|
1014
|
+
Revault::Internal::DomainCodec.decode('FormDefinitionList', take(buffer_call(:vault_directory_list_form_revisions, handle, Fiddle::Pointer[type_id], type_id.bytesize)))
|
|
1015
|
+
end
|
|
1016
|
+
|
|
1017
|
+
def vault_directory_seed_forms(handle)
|
|
1018
|
+
Native.vault_directory_seed_forms(handle)
|
|
1019
|
+
end
|
|
1020
|
+
|
|
1021
|
+
def vault_directory_remember_password(handle, id, password)
|
|
1022
|
+
require_value(Native.vault_directory_remember_password(handle, Fiddle::Pointer[id], id.bytesize, Fiddle::Pointer[password], password.bytesize))
|
|
1023
|
+
end
|
|
1024
|
+
|
|
1025
|
+
def vault_directory_remembered_password(handle, id)
|
|
1026
|
+
take(buffer_call(:vault_directory_remembered_password, handle, Fiddle::Pointer[id], id.bytesize))
|
|
1027
|
+
end
|
|
1028
|
+
|
|
1029
|
+
def vault_backup_default(path, overwrite)
|
|
1030
|
+
Revault::Internal::DomainCodec.decode('VaultBackupManifest', take(buffer_call(:vault_backup_default, Fiddle::Pointer[path], path.bytesize, overwrite)))
|
|
1031
|
+
end
|
|
1032
|
+
|
|
1033
|
+
def vault_restore_default(path, overwrite)
|
|
1034
|
+
Revault::Internal::DomainCodec.decode('VaultBackupManifest', take(buffer_call(:vault_restore_default, Fiddle::Pointer[path], path.bytesize, overwrite)))
|
|
1035
|
+
end
|
|
1036
|
+
|
|
1037
|
+
def vault_directory_free(handle)
|
|
1038
|
+
Native.vault_directory_free(handle)
|
|
1039
|
+
end
|
|
1040
|
+
def contact_exchange_free(handle)
|
|
1041
|
+
Native.contact_exchange_free(handle)
|
|
1042
|
+
end
|
|
1043
|
+
|
|
1044
|
+
def vault_read_only_open(root, password)
|
|
1045
|
+
require_handle(Native.vault_read_only_open(Fiddle::Pointer[root], root.bytesize, Fiddle::Pointer[password], password.bytesize))
|
|
1046
|
+
end
|
|
1047
|
+
|
|
1048
|
+
def vault_read_only_open_default(password)
|
|
1049
|
+
require_handle(Native.vault_read_only_open_default(Fiddle::Pointer[password], password.bytesize))
|
|
1050
|
+
end
|
|
1051
|
+
|
|
1052
|
+
def vault_read_only_load_private_key(handle, name)
|
|
1053
|
+
require_handle(Native.vault_read_only_load_private_key(handle, Fiddle::Pointer[name], name.bytesize))
|
|
1054
|
+
end
|
|
1055
|
+
|
|
1056
|
+
def vault_read_only_load_private_key_generation(handle, name, index)
|
|
1057
|
+
require_handle(Native.vault_read_only_load_private_key_generation(handle, Fiddle::Pointer[name], name.bytesize, index))
|
|
1058
|
+
end
|
|
1059
|
+
|
|
1060
|
+
def vault_read_only_load_owner_signing_key(handle, name)
|
|
1061
|
+
require_handle(Native.vault_read_only_load_owner_signing_key(handle, Fiddle::Pointer[name], name.bytesize))
|
|
1062
|
+
end
|
|
1063
|
+
|
|
1064
|
+
def vault_read_only_load_owner_signing_key_generation(handle, name, index)
|
|
1065
|
+
require_handle(Native.vault_read_only_load_owner_signing_key_generation(handle, Fiddle::Pointer[name], name.bytesize, index))
|
|
1066
|
+
end
|
|
1067
|
+
|
|
1068
|
+
def vault_read_only_load_profile_password(handle, name, &callback)
|
|
1069
|
+
secret = require_handle(Native.vault_read_only_load_profile_password(handle, Fiddle::Pointer[name], name.bytesize))
|
|
1070
|
+
with_secret(->(output) { output[0, Fiddle::SIZEOF_VOIDP] = [secret.to_i].pack('J'); true }, &callback)
|
|
1071
|
+
end
|
|
1072
|
+
|
|
1073
|
+
def vault_read_only_remembered_password(handle, id, &callback)
|
|
1074
|
+
with_secret(->(output) { Native.vault_read_only_remembered_password(handle, Fiddle::Pointer[id], id.bytesize, output) }, &callback)
|
|
1075
|
+
end
|
|
1076
|
+
|
|
1077
|
+
def vault_read_only_list_profile_names(handle)
|
|
1078
|
+
Revault::Internal::DomainCodec.decode('StringList', take(buffer_call(:vault_read_only_list_profile_names, handle)))
|
|
1079
|
+
end
|
|
1080
|
+
|
|
1081
|
+
def vault_read_only_list_contact_names(handle)
|
|
1082
|
+
Revault::Internal::DomainCodec.decode('StringList', take(buffer_call(:vault_read_only_list_contact_names, handle)))
|
|
1083
|
+
end
|
|
1084
|
+
|
|
1085
|
+
def vault_read_only_list_form_aliases(handle)
|
|
1086
|
+
Revault::Internal::DomainCodec.decode('StringList', take(buffer_call(:vault_read_only_list_form_aliases, handle)))
|
|
1087
|
+
end
|
|
1088
|
+
|
|
1089
|
+
def vault_read_only_list_known_lockboxes(handle)
|
|
1090
|
+
Revault::Internal::DomainCodec.decode('KnownLockboxList', take(buffer_call(:vault_read_only_list_known_lockboxes, handle)))
|
|
1091
|
+
end
|
|
1092
|
+
|
|
1093
|
+
def vault_read_only_free(handle)
|
|
1094
|
+
Native.vault_read_only_free(handle)
|
|
1095
|
+
end
|
|
1096
|
+
|
|
1097
|
+
def vault_agent_serve()
|
|
1098
|
+
require_value(Native.vault_agent_serve())
|
|
1099
|
+
end
|
|
1100
|
+
|
|
1101
|
+
def vault_agent_verify_transport()
|
|
1102
|
+
require_value(Native.vault_agent_verify_transport())
|
|
1103
|
+
end
|
|
1104
|
+
|
|
1105
|
+
def vault_agent_get(id)
|
|
1106
|
+
take(buffer_call(:vault_agent_get, Fiddle::Pointer[id], id.bytesize))
|
|
1107
|
+
end
|
|
1108
|
+
|
|
1109
|
+
def vault_agent_put(id, key)
|
|
1110
|
+
require_value(Native.vault_agent_put(Fiddle::Pointer[id], id.bytesize, Fiddle::Pointer[key], key.bytesize))
|
|
1111
|
+
end
|
|
1112
|
+
|
|
1113
|
+
def vault_agent_forget(id)
|
|
1114
|
+
require_value(Native.vault_agent_forget(Fiddle::Pointer[id], id.bytesize))
|
|
1115
|
+
end
|
|
1116
|
+
|
|
1117
|
+
def vault_agent_stop()
|
|
1118
|
+
require_value(Native.vault_agent_stop())
|
|
1119
|
+
end
|
|
1120
|
+
|
|
1121
|
+
def vault_agent_start()
|
|
1122
|
+
require_value(Native.vault_agent_start())
|
|
1123
|
+
end
|
|
1124
|
+
|
|
1125
|
+
def vault_agent_list()
|
|
1126
|
+
Revault::Internal::DomainCodec.decode('AgentEntryList', take(buffer_call(:vault_agent_list)))
|
|
1127
|
+
end
|
|
1128
|
+
|
|
1129
|
+
def vault_agent_sleep_support()
|
|
1130
|
+
Revault::Internal::DomainCodec.decode('SleepSupport', take(buffer_call(:vault_agent_sleep_support)))
|
|
1131
|
+
end
|
|
1132
|
+
|
|
1133
|
+
def vault_platform_status()
|
|
1134
|
+
Revault::Internal::DomainCodec.decode('PlatformStatus', take(buffer_call(:vault_platform_status)))
|
|
1135
|
+
end
|
|
1136
|
+
|
|
1137
|
+
def vault_platform_set_scope(scope)
|
|
1138
|
+
require_value(Native.vault_platform_set_scope(Fiddle::Pointer[scope], scope.bytesize))
|
|
1139
|
+
end
|
|
1140
|
+
|
|
1141
|
+
def vault_platform_forget_password()
|
|
1142
|
+
require_value(Native.vault_platform_forget_password())
|
|
1143
|
+
end
|
|
1144
|
+
|
|
1145
|
+
def vault_platform_put_password(password)
|
|
1146
|
+
require_value(Native.vault_platform_put_password(Fiddle::Pointer[password], password.bytesize))
|
|
1147
|
+
end
|
|
1148
|
+
|
|
1149
|
+
def vault_platform_enable()
|
|
1150
|
+
require_value(Native.vault_platform_enable())
|
|
1151
|
+
end
|
|
1152
|
+
|
|
1153
|
+
def vault_platform_disable()
|
|
1154
|
+
require_value(Native.vault_platform_disable())
|
|
1155
|
+
end
|
|
1156
|
+
|
|
1157
|
+
def vault_platform_disabled()
|
|
1158
|
+
Native.vault_platform_disabled()
|
|
1159
|
+
end
|
|
1160
|
+
|
|
1161
|
+
def vault_platform_get_password()
|
|
1162
|
+
take(buffer_call(:vault_platform_get_password))
|
|
1163
|
+
end
|
|
1164
|
+
|
|
1165
|
+
def vault_default_directory()
|
|
1166
|
+
take(buffer_call(:vault_default_directory))
|
|
1167
|
+
end
|
|
1168
|
+
|
|
1169
|
+
def vault_default_path()
|
|
1170
|
+
take(buffer_call(:vault_default_path))
|
|
1171
|
+
end
|
|
1172
|
+
|
|
1173
|
+
def vault_agent_log_path()
|
|
1174
|
+
take(buffer_call(:vault_agent_log_path))
|
|
1175
|
+
end
|
|
1176
|
+
|
|
1177
|
+
def vault_agent_log_destination()
|
|
1178
|
+
take(buffer_call(:vault_agent_log_destination))
|
|
1179
|
+
end
|
|
1180
|
+
|
|
1181
|
+
def vault_agent_get_vault_unlock_key(vault_id)
|
|
1182
|
+
take(buffer_call(:vault_agent_get_vault_unlock_key, Fiddle::Pointer[vault_id], vault_id.bytesize))
|
|
1183
|
+
end
|
|
1184
|
+
|
|
1185
|
+
def vault_agent_put_vault_unlock_key(vault_id, key, ttl_seconds)
|
|
1186
|
+
require_value(Native.vault_agent_put_vault_unlock_key(Fiddle::Pointer[vault_id], vault_id.bytesize, Fiddle::Pointer[key], key.bytesize, ttl_seconds))
|
|
1187
|
+
end
|
|
1188
|
+
|
|
1189
|
+
def vault_agent_forget_vault_unlock_key(vault_id)
|
|
1190
|
+
require_value(Native.vault_agent_forget_vault_unlock_key(Fiddle::Pointer[vault_id], vault_id.bytesize))
|
|
1191
|
+
end
|
|
1192
|
+
|
|
1193
|
+
def vault_agent_get_owner_signing_key(vault_id, profile)
|
|
1194
|
+
require_handle(Native.vault_agent_get_owner_signing_key(Fiddle::Pointer[vault_id], vault_id.bytesize, Fiddle::Pointer[profile], profile.bytesize))
|
|
1195
|
+
end
|
|
1196
|
+
|
|
1197
|
+
def vault_agent_put_owner_signing_key(vault_id, profile, key, ttl_seconds)
|
|
1198
|
+
require_value(Native.vault_agent_put_owner_signing_key(Fiddle::Pointer[vault_id], vault_id.bytesize, Fiddle::Pointer[profile], profile.bytesize, key, ttl_seconds))
|
|
1199
|
+
end
|
|
1200
|
+
|
|
1201
|
+
def vault_agent_forget_owner_signing_key(vault_id, profile)
|
|
1202
|
+
require_value(Native.vault_agent_forget_owner_signing_key(Fiddle::Pointer[vault_id], vault_id.bytesize, Fiddle::Pointer[profile], profile.bytesize))
|
|
1203
|
+
end
|
|
1204
|
+
|
|
1205
|
+
def vault_agent_begin_activity(kind)
|
|
1206
|
+
require_handle(Native.vault_agent_begin_activity(Fiddle::Pointer[kind], kind.bytesize))
|
|
1207
|
+
end
|
|
1208
|
+
|
|
1209
|
+
def vault_agent_end_activity(handle)
|
|
1210
|
+
Native.vault_agent_end_activity(handle)
|
|
1211
|
+
end
|
|
1212
|
+
|
|
1213
|
+
def vault_local()
|
|
1214
|
+
require_handle(Native.vault_local())
|
|
1215
|
+
end
|
|
1216
|
+
|
|
1217
|
+
def vault_create_lockbox_password(vault, path, password)
|
|
1218
|
+
require_handle(Native.vault_create_lockbox_password(vault, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[password], password.bytesize))
|
|
1219
|
+
end
|
|
1220
|
+
|
|
1221
|
+
def vault_open_lockbox_password(vault, path, password)
|
|
1222
|
+
require_handle(Native.vault_open_lockbox_password(vault, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[password], password.bytesize))
|
|
1223
|
+
end
|
|
1224
|
+
|
|
1225
|
+
def vault_create_lockbox_content_key(vault, path, content_key, signing_key)
|
|
1226
|
+
require_handle(Native.vault_create_lockbox_content_key(vault, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[content_key], content_key.bytesize, signing_key))
|
|
1227
|
+
end
|
|
1228
|
+
|
|
1229
|
+
def vault_create_lockbox_contact(vault, path, contact, name, signing_key)
|
|
1230
|
+
require_handle(Native.vault_create_lockbox_contact(vault, Fiddle::Pointer[path], path.bytesize, contact, Fiddle::Pointer[name], name.bytesize, signing_key))
|
|
1231
|
+
end
|
|
1232
|
+
|
|
1233
|
+
def vault_open_lockbox_content_key(vault, path, content_key, signing_key)
|
|
1234
|
+
require_handle(Native.vault_open_lockbox_content_key(vault, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[content_key], content_key.bytesize, signing_key))
|
|
1235
|
+
end
|
|
1236
|
+
|
|
1237
|
+
def vault_cache_lockbox_password(vault, path, password, ttl_seconds)
|
|
1238
|
+
require_value(Native.vault_cache_lockbox_password(vault, Fiddle::Pointer[path], path.bytesize, Fiddle::Pointer[password], password.bytesize, ttl_seconds))
|
|
1239
|
+
end
|
|
1240
|
+
|
|
1241
|
+
def vault_close_lockbox(vault, path)
|
|
1242
|
+
require_value(Native.vault_close_lockbox(vault, Fiddle::Pointer[path], path.bytesize))
|
|
1243
|
+
end
|
|
1244
|
+
|
|
1245
|
+
def vault_close_all(vault)
|
|
1246
|
+
require_value(Native.vault_close_all(vault))
|
|
1247
|
+
end
|
|
1248
|
+
|
|
1249
|
+
def vault_free(vault)
|
|
1250
|
+
Native.vault_free(vault)
|
|
1251
|
+
end
|
|
1252
|
+
|
|
1253
|
+
def free_buffer(value) = Shim.ruby_buffer_free(value)
|
|
1254
|
+
end
|
|
1255
|
+
end
|