← Back to branch summary

~ubuntu-branches/debian/sid/botan/sid

« back to all changes in this revision

Viewing changes to src/lib/ffi/ffi_pk_op.cpp

  • Committer: Package Import Robot
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2018-03-01 22:23:25 UTC
  • mfrom: (1.2.2)
  • Revision ID: package-import@ubuntu.com-20180301222325-7p7vc45gu3hta34d
Tags: 2.4.0-2
* Don't remove .doctrees from the manual if it doesn't exist.
* Don't specify parallel to debhelper.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lib/ffi/ffi_pk_op.cpp
 
1
/*
 
2
* (C) 2015,2017 Jack Lloyd
 
3
*
 
4
* Botan is released under the Simplified BSD License (see license.txt)
 
5
*/
 
6
 
 
7
#include <botan/ffi.h>
 
8
#include <botan/internal/ffi_util.h>
 
9
#include <botan/internal/ffi_pkey.h>
 
10
#include <botan/internal/ffi_rng.h>
 
11
#include <botan/pubkey.h>
 
12
 
 
13
extern "C" {
 
14
 
 
15
using namespace Botan_FFI;
 
16
 
 
17
BOTAN_FFI_DECLARE_STRUCT(botan_pk_op_encrypt_struct, Botan::PK_Encryptor, 0x891F3FC3);
 
18
BOTAN_FFI_DECLARE_STRUCT(botan_pk_op_decrypt_struct, Botan::PK_Decryptor, 0x912F3C37);
 
19
BOTAN_FFI_DECLARE_STRUCT(botan_pk_op_sign_struct, Botan::PK_Signer, 0x1AF0C39F);
 
20
BOTAN_FFI_DECLARE_STRUCT(botan_pk_op_verify_struct, Botan::PK_Verifier, 0x2B91F936);
 
21
BOTAN_FFI_DECLARE_STRUCT(botan_pk_op_ka_struct, Botan::PK_Key_Agreement, 0x2939CAB1);
 
22
 
 
23
int botan_pk_op_encrypt_create(botan_pk_op_encrypt_t* op,
 
24
                               botan_pubkey_t key_obj,
 
25
                               const char* padding,
 
26
                               uint32_t flags)
 
27
   {
 
28
   return ffi_guard_thunk(BOTAN_CURRENT_FUNCTION, [=]() -> int {
 
29
      BOTAN_ASSERT_NONNULL(op);
 
30
 
 
31
      *op = nullptr;
 
32
 
 
33
      if(flags != 0)
 
34
         return BOTAN_FFI_ERROR_BAD_FLAG;
 
35
 
 
36
      std::unique_ptr<Botan::PK_Encryptor> pk(new Botan::PK_Encryptor_EME(safe_get(key_obj), Botan::system_rng(), padding));
 
37
      *op = new botan_pk_op_encrypt_struct(pk.release());
 
38
      return BOTAN_FFI_SUCCESS;
 
39
      });
 
40
   }
 
41
 
 
42
int botan_pk_op_encrypt_destroy(botan_pk_op_encrypt_t op)
 
43
   {
 
44
   return BOTAN_FFI_CHECKED_DELETE(op);
 
45
   }
 
46
 
 
47
int botan_pk_op_encrypt(botan_pk_op_encrypt_t op,
 
48
                        botan_rng_t rng_obj,
 
49
                        uint8_t out[], size_t* out_len,
 
50
                        const uint8_t plaintext[], size_t plaintext_len)
 
51
   {
 
52
   return BOTAN_FFI_DO(Botan::PK_Encryptor, op, o, {
 
53
      return write_vec_output(out, out_len, o.encrypt(plaintext, plaintext_len, safe_get(rng_obj)));
 
54
      });
 
55
   }
 
56
 
 
57
/*
 
58
* Public Key Decryption
 
59
*/
 
60
int botan_pk_op_decrypt_create(botan_pk_op_decrypt_t* op,
 
61
                               botan_privkey_t key_obj,
 
62
                               const char* padding,
 
63
                               uint32_t flags)
 
64
   {
 
65
   return ffi_guard_thunk(BOTAN_CURRENT_FUNCTION, [=]() -> int {
 
66
      BOTAN_ASSERT_NONNULL(op);
 
67
 
 
68
      *op = nullptr;
 
69
 
 
70
      if(flags != 0)
 
71
         return BOTAN_FFI_ERROR_BAD_FLAG;
 
72
 
 
73
      std::unique_ptr<Botan::PK_Decryptor> pk(new Botan::PK_Decryptor_EME(safe_get(key_obj), Botan::system_rng(), padding));
 
74
      *op = new botan_pk_op_decrypt_struct(pk.release());
 
75
      return BOTAN_FFI_SUCCESS;
 
76
      });
 
77
   }
 
78
 
 
79
int botan_pk_op_decrypt_destroy(botan_pk_op_decrypt_t op)
 
80
   {
 
81
   return BOTAN_FFI_CHECKED_DELETE(op);
 
82
   }
 
83
 
 
84
int botan_pk_op_decrypt(botan_pk_op_decrypt_t op,
 
85
                        uint8_t out[], size_t* out_len,
 
86
                        const uint8_t ciphertext[], size_t ciphertext_len)
 
87
   {
 
88
   return BOTAN_FFI_DO(Botan::PK_Decryptor, op, o, {
 
89
      return write_vec_output(out, out_len, o.decrypt(ciphertext, ciphertext_len));
 
90
      });
 
91
   }
 
92
 
 
93
/*
 
94
* Signature Generation
 
95
*/
 
96
int botan_pk_op_sign_create(botan_pk_op_sign_t* op,
 
97
                            botan_privkey_t key_obj,
 
98
                            const char* hash,
 
99
                            uint32_t flags)
 
100
   {
 
101
   return ffi_guard_thunk(BOTAN_CURRENT_FUNCTION, [=]() -> int {
 
102
      BOTAN_ASSERT_NONNULL(op);
 
103
 
 
104
      *op = nullptr;
 
105
 
 
106
      if(flags != 0)
 
107
         return BOTAN_FFI_ERROR_BAD_FLAG;
 
108
 
 
109
      std::unique_ptr<Botan::PK_Signer> pk(new Botan::PK_Signer(safe_get(key_obj),Botan::system_rng(),  hash));
 
110
      *op = new botan_pk_op_sign_struct(pk.release());
 
111
      return BOTAN_FFI_SUCCESS;
 
112
      });
 
113
   }
 
114
 
 
115
int botan_pk_op_sign_destroy(botan_pk_op_sign_t op)
 
116
   {
 
117
   return BOTAN_FFI_CHECKED_DELETE(op);
 
118
   }
 
119
 
 
120
int botan_pk_op_sign_update(botan_pk_op_sign_t op, const uint8_t in[], size_t in_len)
 
121
   {
 
122
   return BOTAN_FFI_DO(Botan::PK_Signer, op, o, { o.update(in, in_len); });
 
123
   }
 
124
 
 
125
int botan_pk_op_sign_finish(botan_pk_op_sign_t op, botan_rng_t rng_obj, uint8_t out[], size_t* out_len)
 
126
   {
 
127
   return BOTAN_FFI_DO(Botan::PK_Signer, op, o, {
 
128
      return write_vec_output(out, out_len, o.signature(safe_get(rng_obj)));
 
129
      });
 
130
   }
 
131
 
 
132
int botan_pk_op_verify_create(botan_pk_op_verify_t* op,
 
133
                              botan_pubkey_t key_obj,
 
134
                              const char* hash,
 
135
                              uint32_t flags)
 
136
   {
 
137
   return ffi_guard_thunk(BOTAN_CURRENT_FUNCTION, [=]() -> int {
 
138
      BOTAN_ASSERT_NONNULL(op);
 
139
 
 
140
      if(flags != 0)
 
141
         return BOTAN_FFI_ERROR_BAD_FLAG;
 
142
 
 
143
      std::unique_ptr<Botan::PK_Verifier> pk(new Botan::PK_Verifier(safe_get(key_obj), hash));
 
144
      *op = new botan_pk_op_verify_struct(pk.release());
 
145
      return BOTAN_FFI_SUCCESS;
 
146
      });
 
147
   }
 
148
 
 
149
int botan_pk_op_verify_destroy(botan_pk_op_verify_t op)
 
150
   {
 
151
   return BOTAN_FFI_CHECKED_DELETE(op);
 
152
   }
 
153
 
 
154
int botan_pk_op_verify_update(botan_pk_op_verify_t op, const uint8_t in[], size_t in_len)
 
155
   {
 
156
   return BOTAN_FFI_DO(Botan::PK_Verifier, op, o, { o.update(in, in_len); });
 
157
   }
 
158
 
 
159
int botan_pk_op_verify_finish(botan_pk_op_verify_t op, const uint8_t sig[], size_t sig_len)
 
160
   {
 
161
   return BOTAN_FFI_DO(Botan::PK_Verifier, op, o, {
 
162
      const bool legit = o.check_signature(sig, sig_len);
 
163
 
 
164
      if(legit)
 
165
         return BOTAN_FFI_SUCCESS;
 
166
      else
 
167
         return BOTAN_FFI_INVALID_VERIFIER;
 
168
      });
 
169
   }
 
170
 
 
171
int botan_pk_op_key_agreement_create(botan_pk_op_ka_t* op,
 
172
                                     botan_privkey_t key_obj,
 
173
                                     const char* kdf,
 
174
                                     uint32_t flags)
 
175
   {
 
176
   return ffi_guard_thunk(BOTAN_CURRENT_FUNCTION, [=]() -> int {
 
177
      BOTAN_ASSERT_NONNULL(op);
 
178
 
 
179
      *op = nullptr;
 
180
 
 
181
      if(flags != 0)
 
182
         return BOTAN_FFI_ERROR_BAD_FLAG;
 
183
 
 
184
      std::unique_ptr<Botan::PK_Key_Agreement> pk(new Botan::PK_Key_Agreement(safe_get(key_obj), Botan::system_rng(), kdf));
 
185
      *op = new botan_pk_op_ka_struct(pk.release());
 
186
      return BOTAN_FFI_SUCCESS;
 
187
      });
 
188
   }
 
189
 
 
190
int botan_pk_op_key_agreement_destroy(botan_pk_op_ka_t op)
 
191
   {
 
192
   return BOTAN_FFI_CHECKED_DELETE(op);
 
193
   }
 
194
 
 
195
int botan_pk_op_key_agreement_export_public(botan_privkey_t key,
 
196
                                            uint8_t out[], size_t* out_len)
 
197
   {
 
198
   return BOTAN_FFI_DO(Botan::Private_Key, key, k, {
 
199
      if(auto kak = dynamic_cast<const Botan::PK_Key_Agreement_Key*>(&k))
 
200
         return write_vec_output(out, out_len, kak->public_value());
 
201
      return BOTAN_FFI_ERROR_BAD_FLAG;
 
202
      });
 
203
   }
 
204
 
 
205
int botan_pk_op_key_agreement(botan_pk_op_ka_t op,
 
206
                              uint8_t out[], size_t* out_len,
 
207
                              const uint8_t other_key[], size_t other_key_len,
 
208
                              const uint8_t salt[], size_t salt_len)
 
209
   {
 
210
   return BOTAN_FFI_DO(Botan::PK_Key_Agreement, op, o, {
 
211
      auto k = o.derive_key(*out_len, other_key, other_key_len, salt, salt_len).bits_of();
 
212
      return write_vec_output(out, out_len, k);
 
213
      });
 
214
   }
 
215
 
 
216
}