asherah 1.3.26 → 1.3.28

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.
Files changed (11) hide show
  1. package/.asherah-version +1 -1
  2. package/package.json +2 -1
  3. package/scripts/download-libraries.sh +13 -10
  4. package/src/asherah.cc +144 -114
  5. package/src/asherah.d.ts +4 -0
  6. package/src/cobhan.h +23 -25
  7. package/src/cobhan_napi_interop.h +54 -59
  8. package/src/logging.cc +218 -2
  9. package/src/logging.h +43 -70
  10. package/SHA256SUMS +0 -4
  11. package/SHA256SUMS-darwin +0 -4
package/src/asherah.cc CHANGED
@@ -20,29 +20,51 @@ public:
20
20
  InstanceMethod("set_max_stack_alloc_item_size",
21
21
  &Asherah::SetMaxStackAllocItemSize),
22
22
  InstanceMethod("set_safety_padding_overhead",
23
- &Asherah::SetSafetyPaddingOverhead)});
23
+ &Asherah::SetSafetyPaddingOverhead),
24
+ InstanceMethod("set_log_hook", &Asherah::SetLogHook)});
24
25
  }
25
26
 
26
27
  private:
27
28
  size_t est_intermediate_key_overhead;
28
29
  size_t maximum_stack_alloc_size = 2048;
29
30
 
31
+ int32_t verbose_flag = 0;
30
32
  int32_t setup_state = 0;
31
33
  std::mutex asherah_lock;
34
+ Napi::FunctionReference log_hook;
35
+ Logger logger;
36
+
37
+ void SetLogHook(const Napi::CallbackInfo &info) {
38
+ std::lock_guard<std::mutex> lock(asherah_lock);
39
+
40
+ if (unlikely(verbose_flag)) {
41
+ logger.debug_log(__func__, "called");
42
+ }
43
+
44
+ if (unlikely(info.Length() < 1)) {
45
+ logger.log_error_and_throw(__func__, "Wrong number of arguments");
46
+ }
47
+
48
+ if (unlikely(!info[0].IsFunction())) {
49
+ logger.log_error_and_throw(__func__, "Wrong argument type");
50
+ }
51
+
52
+ logger.set_log_hook(info[0].As<Napi::Function>());
53
+ }
32
54
 
33
55
  void SetupAsherah(const Napi::CallbackInfo &info) {
34
56
  std::lock_guard<std::mutex> lock(asherah_lock);
35
57
 
36
58
  if (unlikely(verbose_flag)) {
37
- debug_log(__func__, "called");
59
+ logger.debug_log(__func__, "called");
38
60
  }
39
61
 
40
62
  if (unlikely(setup_state == 1)) {
41
- log_error_and_throw(__func__, "setup called twice");
63
+ logger.log_error_and_throw(__func__, "setup called twice");
42
64
  }
43
65
 
44
66
  if (unlikely(info.Length() < 1)) {
45
- log_error_and_throw(__func__, "Wrong number of arguments");
67
+ logger.log_error_and_throw(__func__, "Wrong number of arguments");
46
68
  }
47
69
 
48
70
  Napi::String config;
@@ -58,7 +80,7 @@ private:
58
80
  Napi::Function parse = json.Get("parse").As<Napi::Function>();
59
81
  config_json = parse.Call(json, {config}).As<Napi::Object>();
60
82
  } else {
61
- log_error_and_throw(__func__, "Wrong argument type");
83
+ logger.log_error_and_throw(__func__, "Wrong argument type");
62
84
  }
63
85
 
64
86
  Napi::String product_id = config_json.Get("ProductID").As<Napi::String>();
@@ -71,21 +93,24 @@ private:
71
93
  Napi::Value verbose = config_json.Get("Verbose");
72
94
  if (likely(verbose.IsBoolean())) {
73
95
  verbose_flag = verbose.As<Napi::Boolean>().Value();
74
- debug_log(__func__, "verbose_flag: " + std::to_string(verbose_flag));
96
+ logger.set_verbose_flag(verbose_flag);
97
+ logger.debug_log(__func__,
98
+ "verbose_flag: " + std::to_string(verbose_flag));
75
99
  } else {
76
100
  verbose_flag = 0;
77
- debug_log(__func__, "verbose_flag: defaulting to false");
101
+ logger.set_verbose_flag(verbose_flag);
102
+ logger.debug_log(__func__, "verbose_flag: defaulting to false");
78
103
  }
79
104
 
80
105
  char *config_cobhan_buffer;
81
106
  size_t config_copied_bytes;
82
- NAPI_STRING_TO_CBUFFER(env, config, config_cobhan_buffer,
107
+ NAPI_STRING_TO_CBUFFER(env, logger, config, config_cobhan_buffer,
83
108
  config_copied_bytes, maximum_stack_alloc_size,
84
109
  __func__);
85
110
 
86
111
  char *config_canary_ptr = get_canary_ptr(config_cobhan_buffer);
87
- if (unlikely(!check_canary_ptr(config_canary_ptr))) {
88
- log_error_and_throw(
112
+ if (unlikely(!check_canary_ptr(logger, config_canary_ptr))) {
113
+ logger.log_error_and_throw(
89
114
  __func__, "Failed initial canary check for config_cobhan_buffer");
90
115
  }
91
116
 
@@ -93,16 +118,16 @@ private:
93
118
  GoInt32 result = SetupJson(config_cobhan_buffer);
94
119
 
95
120
  if (unlikely(verbose_flag)) {
96
- debug_log(__func__, "Returned from asherah-cobhan SetupJson");
121
+ logger.debug_log(__func__, "Returned from asherah-cobhan SetupJson");
97
122
  }
98
123
 
99
- if (unlikely(!check_canary_ptr(config_canary_ptr))) {
100
- log_error_and_throw(
124
+ if (unlikely(!check_canary_ptr(logger, config_canary_ptr))) {
125
+ logger.log_error_and_throw(
101
126
  __func__, "Failed post-call canary check for config_cobhan_buffer");
102
127
  }
103
128
 
104
129
  if (unlikely(result < 0)) {
105
- log_error_and_throw(__func__, AsherahCobhanErrorToString(result));
130
+ logger.log_error_and_throw(__func__, AsherahCobhanErrorToString(result));
106
131
  }
107
132
  setup_state = 1;
108
133
  }
@@ -111,19 +136,19 @@ private:
111
136
  std::lock_guard<std::mutex> lock(asherah_lock);
112
137
 
113
138
  if (unlikely(verbose_flag)) {
114
- debug_log(__func__, "called");
139
+ logger.debug_log(__func__, "called");
115
140
  }
116
141
 
117
142
  if (unlikely(setup_state == 0)) {
118
- log_error_and_throw(__func__, "setup() not called");
143
+ logger.log_error_and_throw(__func__, "setup() not called");
119
144
  }
120
145
 
121
146
  if (unlikely(info.Length() < 2)) {
122
- log_error_and_throw(__func__, "Wrong number of arguments");
147
+ logger.log_error_and_throw(__func__, "Wrong number of arguments");
123
148
  }
124
149
 
125
150
  if (unlikely(!info[0].IsString() || !info[1].IsBuffer())) {
126
- log_error_and_throw(__func__, "Wrong argument types");
151
+ logger.log_error_and_throw(__func__, "Wrong argument types");
127
152
  }
128
153
 
129
154
  Napi::Env env = info.Env();
@@ -131,15 +156,15 @@ private:
131
156
  Napi::String partition_id = info[0].As<Napi::String>();
132
157
  char *partition_id_cobhan_buffer;
133
158
  size_t partition_id_copied_bytes;
134
- NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
135
- partition_id_copied_bytes, maximum_stack_alloc_size,
136
- __func__);
159
+ NAPI_STRING_TO_CBUFFER(
160
+ env, logger, partition_id, partition_id_cobhan_buffer,
161
+ partition_id_copied_bytes, maximum_stack_alloc_size, __func__);
137
162
 
138
163
  Napi::Buffer<unsigned char> input_napi_buffer =
139
164
  info[1].As<Napi::Buffer<unsigned char>>();
140
165
  char *input_cobhan_buffer;
141
166
  size_t input_copied_bytes;
142
- NAPI_BUFFER_TO_CBUFFER(env, input_napi_buffer, input_cobhan_buffer,
167
+ NAPI_BUFFER_TO_CBUFFER(env, logger, input_napi_buffer, input_cobhan_buffer,
143
168
  input_copied_bytes, maximum_stack_alloc_size,
144
169
  __func__);
145
170
 
@@ -148,7 +173,7 @@ private:
148
173
  partition_id_cobhan_buffer, input_cobhan_buffer);
149
174
 
150
175
  if (unlikely(verbose_flag)) {
151
- debug_log(__func__, "finished");
176
+ logger.debug_log(__func__, "finished");
152
177
  }
153
178
 
154
179
  return output;
@@ -158,19 +183,19 @@ private:
158
183
  std::lock_guard<std::mutex> lock(asherah_lock);
159
184
 
160
185
  if (unlikely(verbose_flag)) {
161
- debug_log(__func__, "called");
186
+ logger.debug_log(__func__, "called");
162
187
  }
163
188
 
164
189
  if (unlikely(setup_state == 0)) {
165
- log_error_and_throw(__func__, "setup() not called");
190
+ logger.log_error_and_throw(__func__, "setup() not called");
166
191
  }
167
192
 
168
193
  if (unlikely(info.Length() < 2)) {
169
- log_error_and_throw(__func__, "Wrong number of arguments");
194
+ logger.log_error_and_throw(__func__, "Wrong number of arguments");
170
195
  }
171
196
 
172
197
  if (unlikely(!info[0].IsString() || !info[1].IsString())) {
173
- log_error_and_throw(__func__, "Wrong argument types");
198
+ logger.log_error_and_throw(__func__, "Wrong argument types");
174
199
  }
175
200
 
176
201
  Napi::Env env = info.Env();
@@ -178,22 +203,23 @@ private:
178
203
  Napi::String partition_id = info[0].As<Napi::String>();
179
204
  char *partition_id_cobhan_buffer;
180
205
  size_t partition_id_copied_bytes;
181
- NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
182
- partition_id_copied_bytes, maximum_stack_alloc_size,
183
- __func__);
206
+ NAPI_STRING_TO_CBUFFER(
207
+ env, logger, partition_id, partition_id_cobhan_buffer,
208
+ partition_id_copied_bytes, maximum_stack_alloc_size, __func__);
184
209
 
185
210
  Napi::String input = info[1].As<Napi::String>();
186
211
  char *input_cobhan_buffer;
187
212
  size_t input_copied_bytes;
188
- NAPI_STRING_TO_CBUFFER(env, input, input_cobhan_buffer, input_copied_bytes,
189
- maximum_stack_alloc_size, __func__);
213
+ NAPI_STRING_TO_CBUFFER(env, logger, input, input_cobhan_buffer,
214
+ input_copied_bytes, maximum_stack_alloc_size,
215
+ __func__);
190
216
 
191
217
  Napi::String output = EncryptCobhanBufferToJson(
192
218
  env, partition_id_copied_bytes, input_copied_bytes,
193
219
  partition_id_cobhan_buffer, input_cobhan_buffer);
194
220
 
195
221
  if (unlikely(verbose_flag)) {
196
- debug_log(__func__, "finished");
222
+ logger.debug_log(__func__, "finished");
197
223
  }
198
224
 
199
225
  return output;
@@ -208,33 +234,33 @@ private:
208
234
  EstimateAsherahOutputSize(data_bytes, partition_bytes);
209
235
 
210
236
  if (unlikely(verbose_flag)) {
211
- debug_log(__func__, " asherah_output_size_bytes " +
212
- std::to_string(asherah_output_size_bytes));
237
+ logger.debug_log(__func__, " asherah_output_size_bytes " +
238
+ std::to_string(asherah_output_size_bytes));
213
239
  }
214
240
 
215
241
  char *output_cobhan_buffer;
216
- ALLOCATE_CBUFFER(output_cobhan_buffer, asherah_output_size_bytes,
242
+ ALLOCATE_CBUFFER(logger, output_cobhan_buffer, asherah_output_size_bytes,
217
243
  maximum_stack_alloc_size, __func__);
218
244
 
219
245
  char *partition_id_canary_ptr = get_canary_ptr(partition_id_cobhan_buffer);
220
- if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
221
- log_error_and_throw(
246
+ if (unlikely(!check_canary_ptr(logger, partition_id_canary_ptr))) {
247
+ logger.log_error_and_throw(
222
248
  __func__,
223
249
  "Failed initial canary check for partition_id_cobhan_buffer");
224
250
  }
225
251
  char *input_canary_ptr = get_canary_ptr(input_cobhan_buffer);
226
- if (unlikely(!check_canary_ptr(input_canary_ptr))) {
227
- log_error_and_throw(
252
+ if (unlikely(!check_canary_ptr(logger, input_canary_ptr))) {
253
+ logger.log_error_and_throw(
228
254
  __func__, "Failed initial canary check for input_cobhan_buffer");
229
255
  }
230
256
  char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
231
- if (unlikely(!check_canary_ptr(output_canary_ptr))) {
232
- log_error_and_throw(
257
+ if (unlikely(!check_canary_ptr(logger, output_canary_ptr))) {
258
+ logger.log_error_and_throw(
233
259
  __func__, "Failed initial canary check for output_cobhan_buffer");
234
260
  }
235
261
 
236
262
  if (unlikely(verbose_flag)) {
237
- debug_log(__func__, "Calling asherah-cobhan EncryptToJson");
263
+ logger.debug_log(__func__, "Calling asherah-cobhan EncryptToJson");
238
264
  }
239
265
 
240
266
  // extern GoInt32 EncryptToJson(void* partitionIdPtr, void* dataPtr, void*
@@ -243,28 +269,28 @@ private:
243
269
  input_cobhan_buffer, output_cobhan_buffer);
244
270
 
245
271
  if (unlikely(verbose_flag)) {
246
- debug_log(__func__, "Returning from asherah-cobhan EncryptToJson");
272
+ logger.debug_log(__func__, "Returning from asherah-cobhan EncryptToJson");
247
273
  }
248
274
 
249
- if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
250
- log_error_and_throw(
275
+ if (unlikely(!check_canary_ptr(logger, partition_id_canary_ptr))) {
276
+ logger.log_error_and_throw(
251
277
  __func__,
252
278
  "Failed post-call canary check for partition_id_cobhan_buffer");
253
279
  }
254
- if (unlikely(!check_canary_ptr(input_canary_ptr))) {
255
- log_error_and_throw(
280
+ if (unlikely(!check_canary_ptr(logger, input_canary_ptr))) {
281
+ logger.log_error_and_throw(
256
282
  __func__, "Failed post-call canary check for input_cobhan_buffer");
257
283
  }
258
- if (unlikely(!check_canary_ptr(output_canary_ptr))) {
259
- log_error_and_throw(
284
+ if (unlikely(!check_canary_ptr(logger, output_canary_ptr))) {
285
+ logger.log_error_and_throw(
260
286
  __func__, "Failed post-call canary check for output_cobhan_buffer");
261
287
  }
262
288
 
263
289
  if (unlikely(result < 0)) {
264
- log_error_and_throw(__func__, AsherahCobhanErrorToString(result));
290
+ logger.log_error_and_throw(__func__, AsherahCobhanErrorToString(result));
265
291
  }
266
292
 
267
- Napi::String output = cbuffer_to_nstring(env, output_cobhan_buffer);
293
+ Napi::String output = cbuffer_to_nstring(env, logger, output_cobhan_buffer);
268
294
  return output;
269
295
  }
270
296
 
@@ -272,19 +298,19 @@ private:
272
298
  std::lock_guard<std::mutex> lock(asherah_lock);
273
299
 
274
300
  if (unlikely(verbose_flag)) {
275
- debug_log(__func__, "called");
301
+ logger.debug_log(__func__, "called");
276
302
  }
277
303
 
278
304
  if (unlikely(setup_state == 0)) {
279
- log_error_and_throw(__func__, "setup() not called");
305
+ logger.log_error_and_throw(__func__, "setup() not called");
280
306
  }
281
307
 
282
308
  if (unlikely(info.Length() < 2)) {
283
- log_error_and_throw(__func__, "Wrong number of arguments");
309
+ logger.log_error_and_throw(__func__, "Wrong number of arguments");
284
310
  }
285
311
 
286
312
  if (unlikely(!info[0].IsString() || !info[1].IsString())) {
287
- log_error_and_throw(__func__, "Wrong argument types");
313
+ logger.log_error_and_throw(__func__, "Wrong argument types");
288
314
  }
289
315
 
290
316
  Napi::Env env = info.Env();
@@ -292,39 +318,40 @@ private:
292
318
  Napi::String partition_id = info[0].As<Napi::String>();
293
319
  char *partition_id_cobhan_buffer;
294
320
  size_t partition_id_copied_bytes;
295
- NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
296
- partition_id_copied_bytes, maximum_stack_alloc_size,
297
- __func__);
321
+ NAPI_STRING_TO_CBUFFER(
322
+ env, logger, partition_id, partition_id_cobhan_buffer,
323
+ partition_id_copied_bytes, maximum_stack_alloc_size, __func__);
298
324
 
299
325
  Napi::String input = info[1].As<Napi::String>();
300
326
  char *input_cobhan_buffer;
301
327
  size_t input_copied_bytes;
302
- NAPI_STRING_TO_CBUFFER(env, input, input_cobhan_buffer, input_copied_bytes,
303
- maximum_stack_alloc_size, __func__);
328
+ NAPI_STRING_TO_CBUFFER(env, logger, input, input_cobhan_buffer,
329
+ input_copied_bytes, maximum_stack_alloc_size,
330
+ __func__);
304
331
 
305
332
  char *output_cobhan_buffer;
306
- ALLOCATE_CBUFFER(output_cobhan_buffer, input_copied_bytes,
333
+ ALLOCATE_CBUFFER(logger, output_cobhan_buffer, input_copied_bytes,
307
334
  maximum_stack_alloc_size, __func__);
308
335
 
309
336
  char *partition_id_canary_ptr = get_canary_ptr(partition_id_cobhan_buffer);
310
- if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
311
- log_error_and_throw(
337
+ if (unlikely(!check_canary_ptr(logger, partition_id_canary_ptr))) {
338
+ logger.log_error_and_throw(
312
339
  __func__,
313
340
  "Failed initial canary check for partition_id_cobhan_buffer");
314
341
  }
315
342
  char *input_canary_ptr = get_canary_ptr(input_cobhan_buffer);
316
- if (unlikely(!check_canary_ptr(input_canary_ptr))) {
317
- log_error_and_throw(
343
+ if (unlikely(!check_canary_ptr(logger, input_canary_ptr))) {
344
+ logger.log_error_and_throw(
318
345
  __func__, "Failed initial canary check for input_cobhan_buffer");
319
346
  }
320
347
  char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
321
- if (unlikely(!check_canary_ptr(output_canary_ptr))) {
322
- log_error_and_throw(
348
+ if (unlikely(!check_canary_ptr(logger, output_canary_ptr))) {
349
+ logger.log_error_and_throw(
323
350
  __func__, "Failed initial canary check for output_cobhan_buffer");
324
351
  }
325
352
 
326
353
  if (unlikely(verbose_flag)) {
327
- debug_log(__func__, "Calling asherah-cobhan DecryptFromJson");
354
+ logger.debug_log(__func__, "Calling asherah-cobhan DecryptFromJson");
328
355
  }
329
356
 
330
357
  // extern GoInt32 DecryptFromJson(void* partitionIdPtr, void* jsonPtr, void*
@@ -333,32 +360,33 @@ private:
333
360
  input_cobhan_buffer, output_cobhan_buffer);
334
361
 
335
362
  if (unlikely(verbose_flag)) {
336
- debug_log(__func__, "Returned from asherah-cobhan DecryptFromJson");
363
+ logger.debug_log(__func__,
364
+ "Returned from asherah-cobhan DecryptFromJson");
337
365
  }
338
366
 
339
- if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
340
- log_error_and_throw(
367
+ if (unlikely(!check_canary_ptr(logger, partition_id_canary_ptr))) {
368
+ logger.log_error_and_throw(
341
369
  __func__,
342
370
  "Failed post-call canary check for partition_id_cobhan_buffer");
343
371
  }
344
- if (unlikely(!check_canary_ptr(input_canary_ptr))) {
345
- log_error_and_throw(
372
+ if (unlikely(!check_canary_ptr(logger, input_canary_ptr))) {
373
+ logger.log_error_and_throw(
346
374
  __func__, "Failed post-call canary check for input_cobhan_buffer");
347
375
  }
348
- if (unlikely(!check_canary_ptr(output_canary_ptr))) {
349
- log_error_and_throw(
376
+ if (unlikely(!check_canary_ptr(logger, output_canary_ptr))) {
377
+ logger.log_error_and_throw(
350
378
  __func__, "Failed post-call canary check for output_cobhan_buffer");
351
379
  }
352
380
 
353
381
  if (unlikely(result < 0)) {
354
- log_error_and_throw(__func__, AsherahCobhanErrorToString(result));
382
+ logger.log_error_and_throw(__func__, AsherahCobhanErrorToString(result));
355
383
  }
356
384
 
357
385
  Napi::Buffer<unsigned char> output =
358
- cbuffer_to_nbuffer(env, output_cobhan_buffer);
386
+ cbuffer_to_nbuffer(env, logger, output_cobhan_buffer);
359
387
 
360
388
  if (unlikely(verbose_flag)) {
361
- debug_log(__func__, "finished");
389
+ logger.debug_log(__func__, "finished");
362
390
  }
363
391
 
364
392
  return output;
@@ -368,19 +396,19 @@ private:
368
396
  std::lock_guard<std::mutex> lock(asherah_lock);
369
397
 
370
398
  if (unlikely(verbose_flag)) {
371
- debug_log(__func__, "called");
399
+ logger.debug_log(__func__, "called");
372
400
  }
373
401
 
374
402
  if (unlikely(setup_state == 0)) {
375
- log_error_and_throw(__func__, "setup() not called");
403
+ logger.log_error_and_throw(__func__, "setup() not called");
376
404
  }
377
405
 
378
406
  if (unlikely(info.Length() < 2)) {
379
- log_error_and_throw(__func__, "Wrong number of arguments");
407
+ logger.log_error_and_throw(__func__, "Wrong number of arguments");
380
408
  }
381
409
 
382
410
  if (unlikely(!info[0].IsString() || !info[1].IsString())) {
383
- log_error_and_throw(__func__, "Wrong argument types");
411
+ logger.log_error_and_throw(__func__, "Wrong argument types");
384
412
  }
385
413
 
386
414
  Napi::Env env = info.Env();
@@ -388,39 +416,40 @@ private:
388
416
  Napi::String partition_id = info[0].As<Napi::String>();
389
417
  char *partition_id_cobhan_buffer;
390
418
  size_t partition_id_copied_bytes;
391
- NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
392
- partition_id_copied_bytes, maximum_stack_alloc_size,
393
- __func__);
419
+ NAPI_STRING_TO_CBUFFER(
420
+ env, logger, partition_id, partition_id_cobhan_buffer,
421
+ partition_id_copied_bytes, maximum_stack_alloc_size, __func__);
394
422
 
395
423
  Napi::String input = info[1].As<Napi::String>();
396
424
  char *input_cobhan_buffer;
397
425
  size_t input_copied_bytes;
398
- NAPI_STRING_TO_CBUFFER(env, input, input_cobhan_buffer, input_copied_bytes,
399
- maximum_stack_alloc_size, __func__);
426
+ NAPI_STRING_TO_CBUFFER(env, logger, input, input_cobhan_buffer,
427
+ input_copied_bytes, maximum_stack_alloc_size,
428
+ __func__);
400
429
 
401
430
  char *output_cobhan_buffer;
402
- ALLOCATE_CBUFFER(output_cobhan_buffer, input_copied_bytes,
431
+ ALLOCATE_CBUFFER(logger, output_cobhan_buffer, input_copied_bytes,
403
432
  maximum_stack_alloc_size, __func__);
404
433
 
405
434
  char *partition_id_canary_ptr = get_canary_ptr(partition_id_cobhan_buffer);
406
- if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
407
- log_error_and_throw(
435
+ if (unlikely(!check_canary_ptr(logger, partition_id_canary_ptr))) {
436
+ logger.log_error_and_throw(
408
437
  __func__,
409
438
  "Failed initial canary check for partition_id_cobhan_buffer");
410
439
  }
411
440
  char *input_canary_ptr = get_canary_ptr(input_cobhan_buffer);
412
- if (unlikely(!check_canary_ptr(input_canary_ptr))) {
413
- log_error_and_throw(
441
+ if (unlikely(!check_canary_ptr(logger, input_canary_ptr))) {
442
+ logger.log_error_and_throw(
414
443
  __func__, "Failed initial canary check for input_cobhan_buffer");
415
444
  }
416
445
  char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
417
- if (unlikely(!check_canary_ptr(output_canary_ptr))) {
418
- log_error_and_throw(
446
+ if (unlikely(!check_canary_ptr(logger, output_canary_ptr))) {
447
+ logger.log_error_and_throw(
419
448
  __func__, "Failed initial canary check for output_cobhan_buffer");
420
449
  }
421
450
 
422
451
  if (unlikely(verbose_flag)) {
423
- debug_log(__func__, "Calling asherah-cobhan DecryptFromJson");
452
+ logger.debug_log(__func__, "Calling asherah-cobhan DecryptFromJson");
424
453
  }
425
454
 
426
455
  // extern GoInt32 DecryptFromJson(void* partitionIdPtr, void* jsonPtr, void*
@@ -429,31 +458,32 @@ private:
429
458
  input_cobhan_buffer, output_cobhan_buffer);
430
459
 
431
460
  if (unlikely(verbose_flag)) {
432
- debug_log(__func__, "Returned from asherah-cobhan DecryptFromJson");
461
+ logger.debug_log(__func__,
462
+ "Returned from asherah-cobhan DecryptFromJson");
433
463
  }
434
464
 
435
- if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
436
- log_error_and_throw(
465
+ if (unlikely(!check_canary_ptr(logger, partition_id_canary_ptr))) {
466
+ logger.log_error_and_throw(
437
467
  __func__,
438
468
  "Failed post-call canary check for partition_id_cobhan_buffer");
439
469
  }
440
- if (unlikely(!check_canary_ptr(input_canary_ptr))) {
441
- log_error_and_throw(
470
+ if (unlikely(!check_canary_ptr(logger, input_canary_ptr))) {
471
+ logger.log_error_and_throw(
442
472
  __func__, "Failed post-call canary check for input_cobhan_buffer");
443
473
  }
444
- if (unlikely(!check_canary_ptr(output_canary_ptr))) {
445
- log_error_and_throw(
474
+ if (unlikely(!check_canary_ptr(logger, output_canary_ptr))) {
475
+ logger.log_error_and_throw(
446
476
  __func__, "Failed post-call canary check for output_cobhan_buffer");
447
477
  }
448
478
 
449
479
  if (unlikely(result < 0)) {
450
- log_error_and_throw(__func__, AsherahCobhanErrorToString(result));
480
+ logger.log_error_and_throw(__func__, AsherahCobhanErrorToString(result));
451
481
  }
452
482
 
453
- Napi::String output = cbuffer_to_nstring(env, output_cobhan_buffer);
483
+ Napi::String output = cbuffer_to_nstring(env, logger, output_cobhan_buffer);
454
484
 
455
485
  if (unlikely(verbose_flag)) {
456
- debug_log(__func__, "finished");
486
+ logger.debug_log(__func__, "finished");
457
487
  }
458
488
 
459
489
  return output;
@@ -463,20 +493,20 @@ private:
463
493
  std::lock_guard<std::mutex> lock(asherah_lock);
464
494
 
465
495
  if (unlikely(verbose_flag)) {
466
- debug_log(__func__, "called");
496
+ logger.debug_log(__func__, "called");
467
497
  }
468
498
 
469
499
  setup_state = 0;
470
500
 
471
501
  if (unlikely(verbose_flag)) {
472
- debug_log(__func__, "Calling asherah-cobhan Shutdown");
502
+ logger.debug_log(__func__, "Calling asherah-cobhan Shutdown");
473
503
  }
474
504
 
475
505
  // extern void Shutdown();
476
506
  Shutdown();
477
507
 
478
508
  if (unlikely(verbose_flag)) {
479
- debug_log(__func__, "Returned from asherah-cobhan Shutdown");
509
+ logger.debug_log(__func__, "Returned from asherah-cobhan Shutdown");
480
510
  }
481
511
  }
482
512
 
@@ -484,11 +514,11 @@ private:
484
514
  std::lock_guard<std::mutex> lock(asherah_lock);
485
515
 
486
516
  if (unlikely(verbose_flag)) {
487
- debug_log(__func__, "called");
517
+ logger.debug_log(__func__, "called");
488
518
  }
489
519
 
490
520
  if (unlikely(info.Length() < 1)) {
491
- log_error_and_throw(__func__, "Wrong number of arguments");
521
+ logger.log_error_and_throw(__func__, "Wrong number of arguments");
492
522
  }
493
523
 
494
524
  Napi::Number item_size = info[0].ToNumber();
@@ -500,11 +530,11 @@ private:
500
530
  std::lock_guard<std::mutex> lock(asherah_lock);
501
531
 
502
532
  if (unlikely(verbose_flag)) {
503
- debug_log(__func__, "called");
533
+ logger.debug_log(__func__, "called");
504
534
  }
505
535
 
506
536
  if (unlikely(info.Length() < 1)) {
507
- log_error_and_throw(__func__, "Wrong number of arguments");
537
+ logger.log_error_and_throw(__func__, "Wrong number of arguments");
508
538
  }
509
539
 
510
540
  Napi::Number safety_padding_number = info[0].ToNumber();
@@ -532,7 +562,7 @@ private:
532
562
  ") est_data_byte_len: " + std::to_string(est_data_byte_len) +
533
563
  " asherah_output_size_bytes: " +
534
564
  std::to_string(asherah_output_size_bytes);
535
- debug_log(__func__, log_msg);
565
+ logger.debug_log(__func__, log_msg);
536
566
  }
537
567
  return asherah_output_size_bytes;
538
568
  }
package/src/asherah.d.ts CHANGED
@@ -39,6 +39,9 @@ export type AsherahConfig = {
39
39
  /** Enable verbose logging output */
40
40
  Verbose: boolean | null;
41
41
  };
42
+
43
+ type LogHookCallback = (level: number, message: string) => void;
44
+
42
45
  export declare function setup(config: AsherahConfig): void;
43
46
  export declare function shutdown(): void;
44
47
  export declare function decrypt(partitionId: string, dataRowRecord: string): Buffer;
@@ -47,3 +50,4 @@ export declare function decrypt_string(partitionId: string, dataRowRecord: strin
47
50
  export declare function encrypt_string(partitionId: string, data: string): string;
48
51
  export declare function set_max_stack_alloc_item_size(max_item_size: number): void;
49
52
  export declare function set_safety_padding_overhead(safety_padding_overhead: number): void;
53
+ export declare function set_log_hook(logHook: LogHookCallback): void;