examples/seal.c

   1 /*
   2  *  Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Contact: Krzysztof Jackiewicz <k.jackiewicz@samsung.com>
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License
  17  */
  18
  19 /**
  20  * @file seal.c
  21  * @brief
  22  */
  23
  24 #include <stdio.h>
  25
  26 #include <yaca/crypto.h>
  27 #include <yaca/seal.h>
  28 #include <yaca/key.h>
  29 #include "lorem.h"
  30 #include "misc.h"
  31
  32 void encrypt_seal(void)
  33 {
  34         int ret;
  35         yaca_ctx_h ctx = YACA_CTX_NULL;
  36         yaca_key_h key_pub = YACA_KEY_NULL;
  37         yaca_key_h key_priv = YACA_KEY_NULL;
  38         yaca_key_h aes_key = YACA_KEY_NULL;
  39         yaca_key_h iv = YACA_KEY_NULL;
  40
  41         char *enc = NULL;
  42         char *dec = NULL;
  43         size_t enc_size;
  44         size_t dec_size;
  45
  46         printf("Plain data (16 of %zu bytes): %.16s\n", (size_t)4096, lorem1024);
  47
  48         /// Generate key pair
  49         ret = yaca_key_gen_pair(&key_priv, &key_pub,
  50                                 YACA_KEY_TYPE_PAIR_RSA,
  51                                 YACA_KEY_2048BIT);
  52         if (ret) return;
  53
  54         /// Encrypt a.k.a. seal
  55         {
  56                 size_t out_size;
  57                 size_t rem;
  58
  59                 ret = yaca_seal_init(&ctx, key_pub,
  60                                      YACA_ENC_AES, YACA_BCM_CBC,
  61                                      &aes_key, &iv);
  62                 if (ret < 0)
  63                         goto ex_pk;
  64
  65                 ret = yaca_seal_update(ctx, lorem4096, 4096, NULL, &enc_size);
  66                 if (ret < 0)
  67                         goto ex_ak;
  68
  69                 ret = yaca_get_block_length(ctx);
  70                 if (ret < 0)
  71                         goto ex_ak;
  72
  73                 enc_size = enc_size + ret;
  74                 enc = yaca_malloc(enc_size);
  75                 if (enc == NULL)
  76                         goto ex_ak;
  77
  78                 // Seal and finalize
  79                 out_size = enc_size;
  80                 ret = yaca_seal_update(ctx, lorem4096, 4096, enc, &out_size);
  81                 if (ret < 0)
  82                         goto ex_of;
  83
  84                 rem = enc_size - out_size;
  85                 ret = yaca_seal_final(ctx, enc + out_size, &rem);
  86                 if (ret < 0)
  87                         goto ex_of;
  88
  89                 enc_size = rem + out_size;
  90
  91                 dump_hex(enc, 16, "Encrypted data (16 of %zu bytes): ", enc_size);
  92
  93                 yaca_ctx_free(ctx); // TODO: perhaps it should not return value
  94         }
  95
  96         /// Decrypt a.k.a. open
  97         {
  98                 size_t out_size;
  99                 size_t rem;
 100
 101                 ret = yaca_open_init(&ctx, key_priv,
 102                                      YACA_ENC_AES, YACA_BCM_CBC,
 103                                      aes_key, iv);
 104                 if (ret < 0) {
 105                         yaca_free(enc);
 106                         goto ex_ak;
 107                 }
 108
 109                 ret = yaca_open_update(ctx, enc, enc_size, NULL, &dec_size);
 110                 if (ret < 0)
 111                         goto ex_of;
 112
 113                 ret = yaca_get_block_length(ctx);
 114                 if (ret < 0)
 115                         goto ex_of;
 116
 117                 dec_size = dec_size + ret;
 118                 dec = yaca_malloc(dec_size);
 119                 if (dec == NULL)
 120                         goto ex_of;
 121
 122                 // Seal and finalize
 123                 out_size = enc_size;
 124                 ret = yaca_open_update(ctx, enc, enc_size, dec, &out_size);
 125                 if (ret < 0)
 126                         goto ex_in;
 127
 128                 rem = dec_size - out_size;
 129                 ret = yaca_open_final(ctx, dec + out_size, &rem);
 130                 if (ret < 0)
 131                         goto ex_in;
 132
 133                 dec_size = rem + out_size;
 134
 135                 printf("Decrypted data (16 of %zu bytes): %.16s\n", (size_t)dec_size, dec);
 136
 137                 yaca_ctx_free(ctx); // TODO: perhaps it should not return value
 138         }
 139
 140 ex_in:
 141         yaca_free(dec);
 142 ex_of:
 143         yaca_free(enc);
 144 ex_ak:
 145         yaca_key_free(aes_key);
 146         yaca_key_free(iv);
 147 ex_pk:
 148         yaca_key_free(key_pub);
 149         yaca_key_free(key_priv);
 150 }
 151
 152 int main()
 153 {
 154         int ret = yaca_init();
 155         if (ret < 0)
 156                 return ret;
 157
 158         encrypt_seal();
 159
 160         yaca_exit(); // TODO: what about handing of return value from exit??
 161         return ret;
 162 }