20 #include <gnutls/gnutls.h> 21 #include <gnutls/crypto.h> 22 #ifdef HAVE_GNUTLS_ABSTRACT_H 23 # include <gnutls/abstract.h> 26 #if !defined(HAVE_NETTLE) || !defined(HAVE_GMP) || !defined(HAVE_GNUTLS_RND) 31 # include <libtasn1.h> 35 # include <nettle/asn1.h> 36 # include <nettle/rsa.h> 37 # include <nettle/bignum.h> 52 #error HAVE_GNUTLS not defines, this file should not be included 63 #define mpz_powm(w,n,e,m) \ 64 gcry_mpi_powm((w)->num, (n)->num, (e)->num, (m)->num); 65 #define mpz_init(n) do { (n)->num = NULL; } while(0) 66 #define mpz_clear(n) gcry_mpi_release((n)->num) 75 typedef void nettle_random_func(
void *ctx,
size_t len, uint8_t *out);
78 nettle_mpz_set_str_256_u(
mpz_t x,
unsigned length,
const uint8_t *s)
80 gcry_mpi_scan(&x->num, GCRYMPI_FMT_USG, s, length, NULL);
84 nettle_mpz_get_str_256(
unsigned length, uint8_t *s,
const mpz_t x)
86 gcry_mpi_print(GCRYMPI_FMT_USG, s, length, NULL, x->num);
90 const unsigned char *data, *data_end;
95 enum asn1_iterator_result {
97 ASN1_ITERATOR_PRIMITIVE,
98 ASN1_ITERATOR_CONSTRUCTED,
103 ASN1_SEQUENCE = ASN1_TAG_SEQUENCE,
106 static enum asn1_iterator_result
114 if (asn1_get_tag_der(der->data, der->data_end - der->data, &cls, &len, &tag) != ASN1_SUCCESS)
115 return ASN1_ITERATOR_ERROR;
118 l = asn1_get_length_der(der->data, der->data_end - der->data, &len);
120 return ASN1_ITERATOR_ERROR;
123 if (cls == ASN1_CLASS_STRUCTURED)
124 return ASN1_ITERATOR_CONSTRUCTED;
125 return ASN1_ITERATOR_PRIMITIVE;
128 static enum asn1_iterator_result
129 asn1_der_iterator_first(
struct asn1_der_iterator *der,
int size,
const void *der_buf)
131 der->data = (
const unsigned char *) der_buf;
132 der->data_end = der->data + size;
134 return asn1_der_iterator_next(der);
160 enum asn1_iterator_result ret;
162 ret = asn1_der_iterator_next(der);
163 if (ret != ASN1_ITERATOR_PRIMITIVE || der->type != ASN1_TAG_INTEGER)
165 gcry_mpi_scan(&key->n->num, GCRYMPI_FMT_USG, der->data, der->length, NULL);
166 key->size = (gcry_mpi_get_nbits(key->n->num)+7)/8;
167 der->data += der->length;
169 ret = asn1_der_iterator_next(der);
170 if (ret != ASN1_ITERATOR_PRIMITIVE || der->type != ASN1_TAG_INTEGER)
172 gcry_mpi_scan(&key->e->num, GCRYMPI_FMT_USG, der->data, der->length, NULL);
178 sha1(uint8_t *hash,
const void *data,
size_t len)
180 gcry_md_hash_buffer(GCRY_MD_SHA1, hash, data, len);
184 sha1(uint8_t *hash,
const void *data,
size_t len)
188 sha1_update(&ctx, len, (
const uint8_t *) data);
189 sha1_digest(&ctx, 20, hash);
195 rnd_func(
void *ctx,
size_t len, uint8_t * out)
197 tds_random_buffer(out, len);
200 #define dumpl(b,l) tdsdump_dump_buf(TDS_DBG_INFO1, #b, b, l) 202 #define dumpl(b,l) do {} while(0) 204 #define dump(b) dumpl(b, sizeof(b)) 207 #define hash_func sha1 208 enum { hash_len = 20 };
209 enum { key_size_max = 1024 };
210 static const char label[] =
"";
213 memxor(uint8_t *dest,
const uint8_t *src,
size_t len)
216 for (n = 0; n < len; ++n)
217 dest[n] = dest[n] ^ src[n];
221 mgf_mask(uint8_t *dest,
size_t dest_len,
const uint8_t *mask,
size_t mask_len)
224 uint8_t hash[hash_len];
225 uint8_t seed[mask_len + 4];
227 memcpy(seed, mask, mask_len);
230 TDS_PUT_UA4BE(seed+mask_len, n);
232 hash_func(hash, seed,
sizeof(seed));
233 if (dest_len <= hash_len) {
234 memxor(dest, hash, dest_len);
238 memxor(dest, hash, hash_len);
240 dest_len -= hash_len;
246 oaep_encrypt(
size_t key_size,
void *random_ctx, nettle_random_func *random,
247 size_t length,
const uint8_t *message,
mpz_t m)
252 uint8_t ros[hash_len];
253 uint8_t db[key_size_max - hash_len - 1];
255 const unsigned db_len = key_size - hash_len - 1;
257 if (length + hash_len * 2 + 2 > key_size)
262 memset(&em, 0,
sizeof(em));
263 hash_func(em.db, label, strlen(label));
264 em.all[key_size - length - 1] = 0x1;
265 memcpy(em.all+(key_size - length), message, length);
266 dumpl(em.db, db_len);
269 random(random_ctx, hash_len, em.ros);
273 mgf_mask(em.db, db_len, em.ros, hash_len);
274 dumpl(em.db, db_len);
277 mgf_mask(em.ros, hash_len, em.db, db_len);
280 nettle_mpz_set_str_256_u(m, key_size, em.all);
286 rsa_encrypt_oaep(
const struct rsa_public_key *key,
void *random_ctx, nettle_random_func *random,
287 size_t length,
const uint8_t *message,
mpz_t gibberish)
289 if (!oaep_encrypt(key->size, random_ctx, random, length, message, gibberish))
292 mpz_powm(gibberish, gibberish, key->e, key->n);
297 tds5_rsa_encrypt(
const void *key,
size_t key_len,
const void *nonce,
size_t nonce_len,
const char *pwd,
size_t *em_size)
301 gnutls_datum_t pubkey_datum = { (
unsigned char *) key, key_len };
305 size_t message_len, pwd_len;
307 unsigned char der_buf[2048];
308 size_t size =
sizeof(der_buf);
311 rsa_public_key_init(&pubkey);
313 pwd_len = strlen(pwd);
314 message_len = nonce_len + pwd_len;
315 message = tds_new(uint8_t, message_len);
318 memcpy(message, nonce, nonce_len);
319 memcpy(message + nonce_len, pwd, pwd_len);
323 ret = gnutls_pem_base64_decode(
"RSA PUBLIC KEY", &pubkey_datum, der_buf, &size);
325 tdsdump_log(TDS_DBG_ERROR,
"Error %d decoding public key: %s\n", ret, gnutls_strerror(ret));
330 ret = asn1_der_iterator_first(&der, size, der_buf);
331 if (ret != ASN1_ITERATOR_CONSTRUCTED || der.type != ASN1_SEQUENCE) {
332 tdsdump_log(TDS_DBG_ERROR,
"Invalid DER content\n");
336 ret = rsa_public_key_from_der_iterator(&pubkey, key_size_max * 8, &der);
338 tdsdump_log(TDS_DBG_ERROR,
"Invalid DER content\n");
343 ret = rsa_encrypt_oaep(&pubkey, NULL, rnd_func, message_len, message, p);
345 tdsdump_log(TDS_DBG_ERROR,
"Error encrypting message\n");
349 em = tds_new(uint8_t, pubkey.size);
350 *em_size = pubkey.size;
354 nettle_mpz_get_str_256(pubkey.size, em, p);
360 rsa_public_key_clear(&pubkey);
Definition: sec_negotiate_gnutls.h:89
Definition: sec_negotiate_gnutls.h:59
void tdsdump_log(const char *file, unsigned int level_line, const char *fmt,...)
Write a message to the debug log.
Definition: log.c:353
Definition: sec_negotiate_gnutls.h:137
void tdsdump_dump_buf(const char *file, unsigned int level_line, const char *msg, const void *buf, size_t length)
Dump the contents of data into the log file in a human readable format.
Definition: log.c:255