1  #include <assert.h>
  2  #include <string.h>
  3  #include <lscore/plugin.h>
  4  #include <lscore/param.h>
  5  #include <lsplugin/mkobject.h>
  6  #include <lsplugin/mkoperator.h>
  7  #include <lsplugin/register.h>
  8  #include <lsplugin/param.h>
  9  #include "vigenere.h"
 10  
 11  static LE_STATUS set_encryptor_v_key(LSC_encryptor_t *op, LSC_key_t *key)
 12  {
 13    assert(op != NULL && key != NULL);
 14    op->lsc_data = key;
 15    return LE_STS_SUCCESS;
 16  }
 17  
 18  static LE_STATUS get_encryptor_v_key(LSC_encryptor_t *op, LSC_key_t **key)
 19  {
 20    assert(op != NULL && key != NULL);
 21    *key = op->lsc_data;
 22    return LE_STS_SUCCESS;
 23  }
 24  
 25  static LE_STATUS get_v_encryption_unit_size(LSC_encryptor_t *enc, size_t *size)
 26  {
 27    *size = 1;
 28    return LE_STS_SUCCESS;
 29  }
 30  
 31  static LE_STATUS get_v_encryption_input_size(LSC_encryptor_t *enc, size_t *size)
 32  {
 33    *size = 0;
 34    return LE_STS_SUCCESS;
 35  }
 36  
 37  static LE_STATUS get_v_encryption_output_size(LSC_encryptor_t *enc, size_t *size)
 38  {
 39    *size = 0;
 40    return LE_STS_SUCCESS;
 41  }
 42  
 43  LE_STATUS start_v_encryption(LSC_encryptor_t *enc)
 44  {
 45    assert(enc != NULL && enc->lsc_data != NULL);
 46    LSC_key_t *key = enc->lsc_data;
 47  
 48    if (key->lsc_dispatch != LSplugin_key_dispatch)
 49      return LE_STS_ERROR;
 50  
 51    /* Not much to do here */
 52    return LE_STS_SUCCESS;
 53  }
 54  
 55  LE_STATUS perform_v_encryption(LSC_encryptor_t *enc,
 56                                 const unsigned char *in, size_t inlen,
 57                                 unsigned char *out, size_t outsize,
 58                                 size_t *outlen)
 59  {
 60    assert(enc != NULL && enc->lsc_data != NULL);
 61    LSC_key_t *key = enc->lsc_data;
 62  
 63    if (key->lsc_dispatch != LSplugin_key_dispatch)
 64      return LE_STS_ERROR;
 65  
 66    int res = vigenere_encrypt(in, inlen, out, outsize, key->lsc_data);
 67    *outlen = inlen;
 68    return res ? LE_STS_SUCCESS : LE_STS_ERROR;
 69  }
 70  
 71  LE_STATUS finalize_v_encryption(LSC_encryptor_t *enc, unsigned char *out,
 72                                  size_t outsize, size_t *outlen)
 73  {
 74    assert(enc != NULL && enc->lsc_data != NULL);
 75    LSC_key_t *key = enc->lsc_data;
 76  
 77    if (key->lsc_dispatch != LSplugin_key_dispatch)
 78      return LE_STS_ERROR;
 79  
 80    *outlen = 0;
 81    return LE_STS_SUCCESS;
 82  }
 83  
 84  LE_STATUS stop_v_encryption(LSC_encryptor_t *enc)
 85  {
 86    assert(enc != NULL && enc->lsc_data != NULL);
 87    LSC_key_t *key = enc->lsc_data;
 88  
 89    if (key->lsc_dispatch != LSplugin_key_dispatch)
 90      return LE_STS_ERROR;
 91  
 92    /* Not much to do here */
 93    return LE_STS_SUCCESS;
 94  }
 95  
 96  const LSplugin_encryptor_desc_t v_encryptor_desc = {
 97    NULL, "vigenere", NULL, "vigenere", /* lsp_docstring, lsp_id, lsp_priv_desc, lsp_key_id */
 98    NULL, NULL,                   /* No special data, yet */
 99    NULL,                         /* No setting the key encryptor */
100    set_encryptor_v_key,
101    get_encryptor_v_key,
102    (int[]){ LSC_ENCRYPTOR_TYPE_BASE_COMMANDS(),
103             LSC_ENCRYPTOR_SIZE_COMMANDS(),
104             LSC_NR_start_encryption,
105             LSC_NR_perform_encryption,
106             LSC_NR_finalize_encryption,
107             LSC_NR_stop_encryption, 0 },
108    NULL, NULL, NULL,
109    get_v_encryption_unit_size,
110    get_v_encryption_input_size,
111    get_v_encryption_output_size,
112    NULL,
113    start_v_encryption,
114    perform_v_encryption,
115    finalize_v_encryption,
116    stop_v_encryption
117  };
118  
119  const LSplugin_encryptor_desc_t v_key_encryptor_desc = {
120    NULL, NULL, NULL, NULL, /* lsp_docstring, lsp_id, lsp_priv_desc, lsp_key_id */
121    NULL, NULL,             /* No special data, yet */
122    NULL,                   /* No caching the key operation */
123    set_encryptor_v_key,
124    get_encryptor_v_key,
125    (int[]){ LSC_ENCRYPTOR_TYPE_BASE_COMMANDS(),
126             LSC_ENCRYPTOR_SIZE_COMMANDS(),
127             LSC_NR_start_encryption,
128             LSC_NR_perform_encryption,
129             LSC_NR_finalize_encryption,
130             LSC_NR_stop_encryption, 0 },
131    NULL, NULL, NULL,
132    get_v_encryption_unit_size,
133    get_v_encryption_input_size,
134    get_v_encryption_output_size,
135    NULL,
136    start_v_encryption,
137    perform_v_encryption,
138    finalize_v_encryption,
139    stop_v_encryption
140  };
141  
142  static LE_STATUS set_decryptor_v_key(LSC_decryptor_t *op, LSC_key_t *key)
143  {
144    assert(op != NULL && key != NULL);
145    op->lsc_data = key;
146    return LE_STS_SUCCESS;
147  }
148  
149  static LE_STATUS get_decryptor_v_key(LSC_decryptor_t *op, LSC_key_t **key)
150  {
151    assert(op != NULL && key != NULL);
152    *key = op->lsc_data;
153    return LE_STS_SUCCESS;
154  }
155  
156  static LE_STATUS get_v_decryption_unit_size(LSC_decryptor_t *enc, size_t *size)
157  {
158    *size = 1;
159    return LE_STS_SUCCESS;
160  }
161  
162  static LE_STATUS get_v_decryption_input_size(LSC_decryptor_t *enc, size_t *size)
163  {
164    *size = 0;
165    return LE_STS_SUCCESS;
166  }
167  
168  static LE_STATUS get_v_decryption_output_size(LSC_decryptor_t *enc, size_t *size)
169  {
170    *size = 0;
171    return LE_STS_SUCCESS;
172  }
173  
174  LE_STATUS start_v_decryption(LSC_decryptor_t *dec)
175  {
176    assert(dec != NULL && dec->lsc_data != NULL);
177    LSC_key_t *key = dec->lsc_data;
178  
179    if (key->lsc_dispatch != LSplugin_key_dispatch)
180      return LE_STS_ERROR;
181  
182    /* Not much to do here */
183    return LE_STS_SUCCESS;
184  }
185  
186  LE_STATUS perform_v_decryption(LSC_decryptor_t *dec,
187                                 const unsigned char *in, size_t inlen,
188                                 unsigned char *out, size_t outsize,
189                                 size_t *outlen)
190  {
191    assert(dec != NULL && dec->lsc_data != NULL);
192    LSC_key_t *key = dec->lsc_data;
193  
194    if (key->lsc_dispatch != LSplugin_key_dispatch)
195      return LE_STS_ERROR;
196  
197    int res = vigenere_decrypt(in, inlen, out, outsize, key->lsc_data);
198    *outlen = inlen;
199    return res ? LE_STS_SUCCESS : LE_STS_ERROR;
200  }
201  
202  LE_STATUS finalize_v_decryption(LSC_decryptor_t *dec, unsigned char *out,
203                                   size_t outsize, size_t *outlen)
204  {
205    assert(dec != NULL && dec->lsc_data != NULL);
206    LSC_key_t *key = dec->lsc_data;
207  
208    if (key->lsc_dispatch != LSplugin_key_dispatch)
209      return LE_STS_ERROR;
210  
211    *outlen = 0;
212    return LE_STS_SUCCESS;
213  }
214  
215  LE_STATUS stop_v_decryption(LSC_decryptor_t *dec)
216  {
217    assert(dec != NULL && dec->lsc_data != NULL);
218    LSC_key_t *key = dec->lsc_data;
219  
220    if (key->lsc_dispatch != LSplugin_key_dispatch)
221      return LE_STS_ERROR;
222  
223    /* Not much to do here */
224    return LE_STS_SUCCESS;
225  }
226  
227  const LSplugin_decryptor_desc_t v_decryptor_desc = {
228    NULL, "vigenere", NULL, "vigenere", /* lsp_docstring, lsp_id, lsp_priv_desc, lsp_key_id */
229    NULL, NULL,
230    NULL,                         /* No setting the key decryptor */
231    set_decryptor_v_key,
232    get_decryptor_v_key,
233    (int[]){ LSC_DECRYPTOR_TYPE_BASE_COMMANDS(),
234             LSC_DECRYPTOR_SIZE_COMMANDS(),
235             LSC_NR_start_decryption,
236             LSC_NR_perform_decryption,
237             LSC_NR_finalize_decryption,
238             LSC_NR_stop_decryption, 0 },
239    NULL, NULL, NULL,
240    get_v_decryption_unit_size,
241    get_v_decryption_input_size,
242    get_v_decryption_output_size,
243    NULL,
244    start_v_decryption,
245    perform_v_decryption,
246    finalize_v_decryption,
247    stop_v_decryption
248  };
249  
250  const LSplugin_decryptor_desc_t v_key_decryptor_desc = {
251    NULL, NULL, NULL, NULL, /* lsp_docstring, lsp_id, lsp_priv_desc, lsp_key_id */
252    NULL, NULL,             /* No special data, yet */
253    NULL,                   /* No caching the key operation */
254    set_decryptor_v_key,
255    get_decryptor_v_key,
256    (int[]){ LSC_DECRYPTOR_TYPE_BASE_COMMANDS(),
257             LSC_DECRYPTOR_SIZE_COMMANDS(),
258             LSC_NR_start_decryption,
259             LSC_NR_perform_decryption,
260             LSC_NR_finalize_decryption,
261             LSC_NR_stop_decryption, 0 },
262    NULL, NULL, NULL,
263    get_v_decryption_unit_size,
264    get_v_decryption_input_size,
265    get_v_decryption_output_size,
266    NULL,
267    start_v_decryption,
268    perform_v_decryption,
269    finalize_v_decryption,
270    stop_v_decryption
271  };
272  
273  /* ----------------------------------------------------------------------------- */
274  
275  static LE_STATUS set_constructor_v_key(LSC_key_constructor_t *op, LSC_key_t *key)
276  {
277    assert(op != NULL && key != NULL);
278    op->lsc_data = key;
279    return LE_STS_SUCCESS;
280  }
281  
282  static LE_STATUS get_constructor_v_key(LSC_key_constructor_t *op, LSC_key_t **key)
283  {
284    assert(op != NULL && key != NULL);
285    *key = op->lsc_data;
286    return LE_STS_SUCCESS;
287  }
288  
289  static LE_STATUS set_constructor_key_param(void *o, LSC_param_t *data, size_t index,
290                                             size_t data_offset, size_t datalen_offset)
291  {
292    LSC_key_t *key = o;
293    struct vigenere_key_st *k = key->lsc_data;
294  
295    assert(data_offset == 0);
296    vigenere_init(k, data->data, data->size / 8);
297    if (data->len != NULL)
298      *data->len = data->size;
299    return LE_STS_SUCCESS;
300  }
301  
302  static LSplugin_param_functions_t key_fns = {
303    0, 0, 0, false,
304    set_constructor_key_param, NULL
305  };
306  
307  static const LSC_param_desc_t constructor_param_descs[] = {
308    { "key", 1,
309      .p_data = { LSC_DT_bit_string, { { 8, 0, 8 } } },
310      .p_private = &key_fns,
311      .p_docstring = "The key bits used for encryption / decryption" },
312    { NULL, }
313  };
314  
315  static LE_STATUS
316  get_constructor_param_data(LSC_key_constructor_t *op, void **data)
317  {
318    *data = op->lsc_data;
319    return LE_STS_SUCCESS;
320  }
321  
322  static LE_STATUS
323  get_constructor_settable_param_desc(LSC_key_constructor_t *op,
324                                      const LSC_param_desc_t **param_desc)
325  {
326    *param_desc = constructor_param_descs;
327    return LE_STS_SUCCESS;
328  }
329  
330  static LE_STATUS construct_v_key(LSC_key_constructor_t *op)
331  {
332    /* Do nothing here, as we've done it all when setting the key param */
333    return LE_STS_SUCCESS;
334  }
335  
336  const LSplugin_key_constructor_desc_t v_key_constructor_desc = {
337    NULL, NULL, NULL, NULL, /* lsp_docstring, lsp_id, lsp_priv_desc, lsp_key_id */
338    NULL, NULL,
339    NULL,                         /* No caching the key constructor */
340    set_constructor_v_key,
341    get_constructor_v_key,
342    (int[]){ LSC_KEY_TYPE_BASE_COMMANDS(),
343             LSC_NR_construct_key, 0 },
344    get_constructor_param_data,
345    NULL,
346    get_constructor_settable_param_desc,
347    construct_v_key,
348  };
349  
350  /* ----------------------------------------------------------------------------- */
351  
352  LE_STATUS setup_v_key_data(LSC_key_t *key, const void *priv_desc)
353  {
354    if (key->lsc_data == NULL) {
355      key->lsc_data = malloc(sizeof(struct vigenere_key_st));
356      if (key->lsc_data == NULL)
357        return LE_STS_ERROR;
358      memset(key->lsc_data, 0, sizeof(struct vigenere_key_st));
359    }
360    return LE_STS_SUCCESS;
361  }
362  
363  LE_STATUS clean_v_key_data(LSC_key_t *key)
364  {
365    vigenere_done(key->lsc_data); /* For good measure */
366    free(key->lsc_data);
367    key->lsc_data = NULL;
368    return LE_STS_SUCCESS;
369  }
370  
371  static LE_STATUS get_v_key_size(LSC_key_t *key, size_t *keysize)
372  {
373    struct vigenere_key_st *k = key->lsc_data;
374    if (k == NULL || k->key == NULL)
375      return LE_STS_ERROR;
376  
377    *keysize = k->keysize;
378    return LE_STS_SUCCESS;
379  }
380  
381  const LSplugin_key_desc_t v_key_desc = {
382    NULL, "vigenere", NULL,
383    setup_v_key_data, clean_v_key_data,
384    (int[]){ LSC_KEY_TYPE_BASE_COMMANDS(),
385             LSC_NR_get_key_size,
386             LSC_NR_get_key_constructor,
387             LSC_NR_get_associated_encryptor,
388             LSC_NR_get_associated_decryptor, 0 },
389    get_v_key_size,
390    NULL,
391    &v_key_constructor_desc,
392    NULL,
393    &v_key_encryptor_desc,
394    &v_key_decryptor_desc,
395  };
396  
397  /* ----------------------------------------------------------------------------- */
398  
399  LSC_EXPORT const char LSC_plugin_docstring[] =
400    "The Vigenère plugin - 'vigenere' is a modern implementation of the \
401  a cipher first described by Giovan Battista Bellaso in 1553, and was \
402  later misattributed to Blaise de Vigenère.\n\
403  \n\
404  Read all about it in https://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher.";
405  
406  static const LSplugin_key_desc_t *key_impls[] = { &v_key_desc, NULL };
407  static const LSplugin_encryptor_desc_t *enc_impls[] = { &v_encryptor_desc, NULL };
408  static const LSplugin_decryptor_desc_t *dec_impls[] = { &v_decryptor_desc, NULL };
409  
410  LSC_EXPORT LE_STATUS LSC_plugin_start(LSC_plugin_t *plugin)
411  {
412    LSC_env_t *env;
413    LE_STATUS sts;
414  
415    if (!LE_status_is_OK(sts = LSC_get_plugin_parent_environment(plugin, &env)))
416      return sts;
417    sts = LSplugin_register_key_implementations(env, plugin, key_impls);
418    if (!LE_status_is_OK(sts))
419      return sts;
420    sts = LSplugin_register_encryptor_implementations(env, plugin, enc_impls);
421    if (!LE_status_is_OK(sts))
422      return sts;
423    sts = LSplugin_register_decryptor_implementations(env, plugin, dec_impls);
424    return sts;
425  }
426  
427  LSC_EXPORT LE_STATUS LSC_plugin_stop(LSC_plugin_t *plugin)
428  {
429    LSC_env_t *env;
430    LE_STATUS sts;
431  
432    if (!LE_status_is_OK(sts = LSC_get_plugin_parent_environment(plugin, &env)))
433      return sts;
434    sts = LSplugin_deregister_key_implementations(env, plugin, key_impls);
435    if (!LE_status_is_OK(sts))
436      return sts;
437    sts = LSplugin_deregister_encryptor_implementations(env, plugin, enc_impls);
438    if (!LE_status_is_OK(sts))
439      return sts;
440    sts = LSplugin_deregister_decryptor_implementations(env, plugin, dec_impls);
441    return sts;
442  }