Exported gnutls_cpuid() and gnutls_have_cpuid().
[gnutls:gnutls.git] / extra / gnutls_openssl.c
1 /*
2  * Copyright (C) 2004, 2005, 2006, 2008, 2010 Free Software Foundation,
3  * Inc.
4  * Copyright (c) 2002 Andrew McDonald <andrew@mcdonald.org.uk>
5  *
6  * This file is part of GnuTLS-EXTRA.
7  *
8  * GnuTLS-extra is free software: you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation, either version 3 of the License, or
11  * (at your option) any later version.
12  *               
13  * GnuTLS-extra is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *                               
18  * You should have received a copy of the GNU General Public License
19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23
24 #include <gnutls/gnutls.h>
25 #include <openssl_compat.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include "../lib/gnutls_int.h"
30 #include "../lib/random.h"
31 #include "../lib/gnutls_hash_int.h"
32
33 /* In win32 X509_NAME is defined in wincrypt.h.
34  * undefine it to avoid the conflict with openssl.h.
35  */
36 #ifdef X509_NAME
37 # undef X509_NAME
38 #endif
39 #include <gnutls/openssl.h>
40
41 /* Gnulib re-defines shutdown on mingw.  We only use it as a variable
42    name, so restore the original name. */
43 #undef shutdown
44
45 /* XXX: See lib/gnutls_int.h. */
46 #define GNUTLS_POINTER_TO_INT(_) ((int) GNUTLS_POINTER_TO_INT_CAST (_))
47 #define GNUTLS_INT_TO_POINTER(_) ((void*) GNUTLS_POINTER_TO_INT_CAST (_))
48
49 /* WARNING: Error functions aren't currently thread-safe */
50
51 static int last_error = 0;
52
53 /* Library initialisation functions */
54
55 int
56 SSL_library_init (void)
57 {
58   gnutls_global_init ();
59   /* NB: we haven't got anywhere to call gnutls_global_deinit() */
60   return 1;
61 }
62
63 void
64 OpenSSL_add_all_algorithms (void)
65 {
66 }
67
68
69 /* SSL_CTX structure handling */
70
71 SSL_CTX *
72 SSL_CTX_new (SSL_METHOD * method)
73 {
74   SSL_CTX *ctx;
75
76   ctx = (SSL_CTX *) calloc (1, sizeof (SSL_CTX));
77   ctx->method = method;
78
79   return ctx;
80 }
81
82 void
83 SSL_CTX_free (SSL_CTX * ctx)
84 {
85   free (ctx->method);
86   free (ctx);
87 }
88
89 int
90 SSL_CTX_set_default_verify_paths (SSL_CTX * ctx)
91 {
92   return 0;
93 }
94
95 int
96 SSL_CTX_use_certificate_file (SSL_CTX * ctx, const char *certfile, int type)
97 {
98   ctx->certfile = (char *) calloc (1, strlen (certfile) + 1);
99   if (!ctx->certfile)
100     return -1;
101   memcpy (ctx->certfile, certfile, strlen (certfile));
102
103   ctx->certfile_type = type;
104
105   return 1;
106 }
107
108 int
109 SSL_CTX_use_PrivateKey_file (SSL_CTX * ctx, const char *keyfile, int type)
110 {
111   ctx->keyfile = (char *) calloc (1, strlen (keyfile) + 1);
112   if (!ctx->keyfile)
113     return -1;
114   memcpy (ctx->keyfile, keyfile, strlen (keyfile));
115
116   ctx->keyfile_type = type;
117
118   return 1;
119
120 }
121
122 void
123 SSL_CTX_set_verify (SSL_CTX * ctx, int verify_mode,
124                     int (*verify_callback) (int, X509_STORE_CTX *))
125 {
126   ctx->verify_mode = verify_mode;
127   ctx->verify_callback = verify_callback;
128 }
129
130 unsigned long
131 SSL_CTX_set_options (SSL_CTX * ctx, unsigned long options)
132 {
133   return (ctx->options |= options);
134 }
135
136 long
137 SSL_CTX_set_mode (SSL_CTX * ctx, long mode)
138 {
139   return 0;
140 }
141
142 int
143 SSL_CTX_set_cipher_list (SSL_CTX * ctx, const char *list)
144 {
145   /* FIXME: ignore this for the moment */
146   /* We're going to have to parse the "list" string to do this */
147   /* It is a string, which in its simplest form is something like
148      "DES-CBC3-SHA:IDEA-CBC-MD5", but can be rather more complicated
149      (see OpenSSL's ciphers(1) manpage for details) */
150
151   return 1;
152 }
153
154
155 /* SSL_CTX statistics */
156
157 long
158 SSL_CTX_sess_number (SSL_CTX * ctx)
159 {
160   return 0;
161 }
162
163 long
164 SSL_CTX_sess_connect (SSL_CTX * ctx)
165 {
166   return 0;
167 }
168
169 long
170 SSL_CTX_sess_connect_good (SSL_CTX * ctx)
171 {
172   return 0;
173 }
174
175 long
176 SSL_CTX_sess_connect_renegotiate (SSL_CTX * ctx)
177 {
178   return 0;
179 }
180
181 long
182 SSL_CTX_sess_accept (SSL_CTX * ctx)
183 {
184   return 0;
185 }
186
187 long
188 SSL_CTX_sess_accept_good (SSL_CTX * ctx)
189 {
190   return 0;
191 }
192
193 long
194 SSL_CTX_sess_accept_renegotiate (SSL_CTX * ctx)
195 {
196   return 0;
197 }
198
199 long
200 SSL_CTX_sess_hits (SSL_CTX * ctx)
201 {
202   return 0;
203 }
204
205 long
206 SSL_CTX_sess_misses (SSL_CTX * ctx)
207 {
208   return 0;
209 }
210
211 long
212 SSL_CTX_sess_timeouts (SSL_CTX * ctx)
213 {
214   return 0;
215 }
216
217
218
219 /* SSL structure handling */
220
221 SSL *
222 SSL_new (SSL_CTX * ctx)
223 {
224   SSL *ssl;
225   int err;
226
227   ssl = (SSL *) calloc (1, sizeof (SSL));
228   if (!ssl)
229     return NULL;
230
231   err = gnutls_certificate_allocate_credentials (&ssl->gnutls_cred);
232   if (err < 0)
233     {
234       last_error = err;
235       free (ssl);
236       return NULL;
237     }
238
239   gnutls_init (&ssl->gnutls_state, ctx->method->connend);
240
241   gnutls_priority_set_direct (ssl->gnutls_state,
242                                 ctx->method->priority_string, NULL);
243
244   gnutls_credentials_set (ssl->gnutls_state, GNUTLS_CRD_CERTIFICATE,
245                           ssl->gnutls_cred);
246   if (ctx->certfile)
247     gnutls_certificate_set_x509_trust_file (ssl->gnutls_cred,
248                                             ctx->certfile,
249                                             ctx->certfile_type);
250   if (ctx->keyfile)
251     gnutls_certificate_set_x509_key_file (ssl->gnutls_cred,
252                                           ctx->certfile, ctx->keyfile,
253                                           ctx->keyfile_type);
254   ssl->ctx = ctx;
255   ssl->verify_mode = ctx->verify_mode;
256   ssl->verify_callback = ctx->verify_callback;
257
258   ssl->options = ctx->options;
259
260   ssl->rfd = (gnutls_transport_ptr_t) - 1;
261   ssl->wfd = (gnutls_transport_ptr_t) - 1;
262
263   return ssl;
264 }
265
266 void
267 SSL_free (SSL * ssl)
268 {
269   gnutls_certificate_free_credentials (ssl->gnutls_cred);
270   gnutls_deinit (ssl->gnutls_state);
271   free (ssl);
272 }
273
274 void
275 SSL_load_error_strings (void)
276 {
277 }
278
279 int
280 SSL_get_error (SSL * ssl, int ret)
281 {
282   if (ret > 0)
283     return SSL_ERROR_NONE;
284
285   return SSL_ERROR_ZERO_RETURN;
286 }
287
288 int
289 SSL_set_fd (SSL * ssl, int fd)
290 {
291   gnutls_transport_set_ptr (ssl->gnutls_state, GNUTLS_INT_TO_POINTER (fd));
292   return 1;
293 }
294
295 int
296 SSL_set_rfd (SSL * ssl, int fd)
297 {
298   ssl->rfd = GNUTLS_INT_TO_POINTER (fd);
299
300   if (ssl->wfd != (gnutls_transport_ptr_t) - 1)
301     gnutls_transport_set_ptr2 (ssl->gnutls_state, ssl->rfd, ssl->wfd);
302
303   return 1;
304 }
305
306 int
307 SSL_set_wfd (SSL * ssl, int fd)
308 {
309   ssl->wfd = GNUTLS_INT_TO_POINTER (fd);
310
311   if (ssl->rfd != (gnutls_transport_ptr_t) - 1)
312     gnutls_transport_set_ptr2 (ssl->gnutls_state, ssl->rfd, ssl->wfd);
313
314   return 1;
315 }
316
317 void
318 SSL_set_bio (SSL * ssl, BIO * rbio, BIO * wbio)
319 {
320   gnutls_transport_set_ptr2 (ssl->gnutls_state, rbio->fd, wbio->fd);
321   /*    free(BIO); ? */
322 }
323
324 void
325 SSL_set_connect_state (SSL * ssl)
326 {
327 }
328
329 int
330 SSL_pending (SSL * ssl)
331 {
332   return gnutls_record_check_pending (ssl->gnutls_state);
333 }
334
335 void
336 SSL_set_verify (SSL * ssl, int verify_mode,
337                 int (*verify_callback) (int, X509_STORE_CTX *))
338 {
339   ssl->verify_mode = verify_mode;
340   ssl->verify_callback = verify_callback;
341 }
342
343 const X509 *
344 SSL_get_peer_certificate (SSL * ssl)
345 {
346   const gnutls_datum_t *cert_list;
347   unsigned int cert_list_size = 0;
348
349   cert_list = gnutls_certificate_get_peers (ssl->gnutls_state,
350                                             &cert_list_size);
351
352   return cert_list;
353 }
354
355 /* SSL connection open/close/read/write functions */
356
357 int
358 SSL_connect (SSL * ssl)
359 {
360   X509_STORE_CTX *store;
361   unsigned int cert_list_size = 0;
362   int err;
363   char x_priority[256];
364   /* take options into account before connecting */
365
366   memset (x_priority, 0, sizeof (x_priority));
367   if (ssl->options & SSL_OP_NO_TLSv1)
368     {
369       snprintf(x_priority, sizeof(x_priority), "%s:-VERS-TLS1.0", ssl->ctx->method->priority_string);
370       err = gnutls_priority_set_direct(ssl->gnutls_state, x_priority, NULL);
371       if (err < 0)
372         {
373           last_error = err;
374           return 0;
375         }
376     }
377
378   err = gnutls_handshake (ssl->gnutls_state);
379   ssl->last_error = err;
380
381   if (err < 0)
382     {
383       last_error = err;
384       return 0;
385     }
386
387   store = (X509_STORE_CTX *) calloc (1, sizeof (X509_STORE_CTX));
388   store->ssl = ssl;
389   store->cert_list = gnutls_certificate_get_peers (ssl->gnutls_state,
390                                                    &cert_list_size);
391
392   if (ssl->verify_callback)
393     {
394       ssl->verify_callback (1 /*FIXME*/, store);
395     }
396   ssl->state = SSL_ST_OK;
397
398   err = store->error;
399   free (store);
400
401   /* FIXME: deal with error from callback */
402
403   return 1;
404 }
405
406 int
407 SSL_accept (SSL * ssl)
408 {
409   X509_STORE_CTX *store;
410   unsigned int cert_list_size = 0;
411   int err;
412   char x_priority[256];
413   /* take options into account before connecting */
414
415   memset (x_priority, 0, sizeof (x_priority));
416   if (ssl->options & SSL_OP_NO_TLSv1)
417     {
418       snprintf(x_priority, sizeof(x_priority), "%s:-VERS-TLS1.0", ssl->ctx->method->priority_string);
419       err = gnutls_priority_set_direct(ssl->gnutls_state, x_priority, NULL);
420       if (err < 0)
421         {
422           last_error = err;
423           return 0;
424         }
425     }
426
427   /* FIXME: dh params, do we want client cert? */
428
429   err = gnutls_handshake (ssl->gnutls_state);
430   ssl->last_error = err;
431
432   if (err < 0)
433     {
434       last_error = err;
435       return 0;
436     }
437
438   store = (X509_STORE_CTX *) calloc (1, sizeof (X509_STORE_CTX));
439   store->ssl = ssl;
440   store->cert_list = gnutls_certificate_get_peers (ssl->gnutls_state,
441                                                    &cert_list_size);
442
443   if (ssl->verify_callback)
444     {
445       ssl->verify_callback (1 /*FIXME*/, store);
446     }
447   ssl->state = SSL_ST_OK;
448
449   err = store->error;
450   free (store);
451
452   /* FIXME: deal with error from callback */
453
454   return 1;
455 }
456
457 int
458 SSL_shutdown (SSL * ssl)
459 {
460   if (!ssl->shutdown)
461     {
462       gnutls_bye (ssl->gnutls_state, GNUTLS_SHUT_WR);
463       ssl->shutdown++;
464     }
465   else
466     {
467       gnutls_bye (ssl->gnutls_state, GNUTLS_SHUT_RDWR);
468       ssl->shutdown++;
469     }
470
471   /* FIXME */
472   return 1;
473 }
474
475 int
476 SSL_read (SSL * ssl, void *buf, int len)
477 {
478   int ret;
479
480   ret = gnutls_record_recv (ssl->gnutls_state, buf, len);
481   ssl->last_error = ret;
482
483   if (ret < 0)
484     {
485       last_error = ret;
486       return 0;
487     }
488
489   return ret;
490 }
491
492 int
493 SSL_write (SSL * ssl, const void *buf, int len)
494 {
495   int ret;
496
497   ret = gnutls_record_send (ssl->gnutls_state, buf, len);
498   ssl->last_error = ret;
499
500   if (ret < 0)
501     {
502       last_error = ret;
503       return 0;
504     }
505
506   return ret;
507 }
508
509 int
510 SSL_want (SSL * ssl)
511 {
512   return SSL_NOTHING;
513 }
514
515
516 /* SSL_METHOD functions */
517
518 SSL_METHOD *
519 SSLv23_client_method (void)
520 {
521   SSL_METHOD *m;
522   m = (SSL_METHOD *) calloc (1, sizeof (SSL_METHOD));
523   if (!m)
524     return NULL;
525
526   strcpy(m->priority_string, "NONE:+VERS-TLS1.0:+VERS-SSL3.0:+CIPHER-ALL:+COMP-ALL:+RSA:+DHE-RSA:+DHE-DSS:+MAC-ALL");
527
528   m->connend = GNUTLS_CLIENT;
529
530   return m;
531 }
532
533 SSL_METHOD *
534 SSLv23_server_method (void)
535 {
536   SSL_METHOD *m;
537   m = (SSL_METHOD *) calloc (1, sizeof (SSL_METHOD));
538   if (!m)
539     return NULL;
540
541   strcpy(m->priority_string, "NONE:+VERS-TLS1.0:+VERS-SSL3.0:+CIPHER-ALL:+COMP-ALL:+RSA:+DHE-RSA:+DHE-DSS:+MAC-ALL");
542   m->connend = GNUTLS_SERVER;
543
544   return m;
545 }
546
547 SSL_METHOD *
548 SSLv3_client_method (void)
549 {
550   SSL_METHOD *m;
551   m = (SSL_METHOD *) calloc (1, sizeof (SSL_METHOD));
552   if (!m)
553     return NULL;
554
555   strcpy(m->priority_string, "NONE:+VERS-SSL3.0:+CIPHER-ALL:+COMP-ALL:+RSA:+DHE-RSA:+DHE-DSS:+MAC-ALL");
556   m->connend = GNUTLS_CLIENT;
557
558   return m;
559 }
560
561 SSL_METHOD *
562 SSLv3_server_method (void)
563 {
564   SSL_METHOD *m;
565   m = (SSL_METHOD *) calloc (1, sizeof (SSL_METHOD));
566   if (!m)
567     return NULL;
568
569   strcpy(m->priority_string, "NONE:+VERS-SSL3.0:+CIPHER-ALL:+COMP-ALL:+RSA:+DHE-RSA:+DHE-DSS:+MAC-ALL");
570   m->connend = GNUTLS_SERVER;
571
572   return m;
573 }
574
575 SSL_METHOD *
576 TLSv1_client_method (void)
577 {
578   SSL_METHOD *m;
579   m = (SSL_METHOD *) calloc (1, sizeof (SSL_METHOD));
580   if (!m)
581     return NULL;
582
583   strcpy(m->priority_string, "NONE:+VERS-TLS1.0:+CIPHER-ALL:+COMP-ALL:+RSA:+DHE-RSA:+DHE-DSS:+MAC-ALL");
584   m->connend = GNUTLS_CLIENT;
585
586   return m;
587 }
588
589 SSL_METHOD *
590 TLSv1_server_method (void)
591 {
592   SSL_METHOD *m;
593   m = (SSL_METHOD *) calloc (1, sizeof (SSL_METHOD));
594   if (!m)
595     return NULL;
596
597   strcpy(m->priority_string, "NONE:+VERS-TLS1.0:+CIPHER-ALL:+COMP-ALL:+RSA:+DHE-RSA:+DHE-DSS:+MAC-ALL");
598   m->connend = GNUTLS_SERVER;
599
600   return m;
601 }
602
603
604 /* SSL_CIPHER functions */
605
606 SSL_CIPHER *
607 SSL_get_current_cipher (SSL * ssl)
608 {
609   if (!ssl)
610     return NULL;
611
612   ssl->ciphersuite.version = gnutls_protocol_get_version (ssl->gnutls_state);
613   ssl->ciphersuite.cipher = gnutls_cipher_get (ssl->gnutls_state);
614   ssl->ciphersuite.kx = gnutls_kx_get (ssl->gnutls_state);
615   ssl->ciphersuite.mac = gnutls_mac_get (ssl->gnutls_state);
616   ssl->ciphersuite.compression = gnutls_compression_get (ssl->gnutls_state);
617   ssl->ciphersuite.cert = gnutls_certificate_type_get (ssl->gnutls_state);
618
619   return &(ssl->ciphersuite);
620 }
621
622 const char *
623 SSL_CIPHER_get_name (SSL_CIPHER * cipher)
624 {
625   if (!cipher)
626     return ("NONE");
627
628   return gnutls_cipher_suite_get_name (cipher->kx,
629                                        cipher->cipher, cipher->mac);
630 }
631
632 int
633 SSL_CIPHER_get_bits (SSL_CIPHER * cipher, int *bits)
634 {
635   int bit_result;
636
637   if (!cipher)
638     return 0;
639
640   bit_result = (8 * gnutls_cipher_get_key_size (cipher->cipher));
641
642   if (bits)
643     *bits = bit_result;
644
645   return bit_result;
646 }
647
648 const char *
649 SSL_CIPHER_get_version (SSL_CIPHER * cipher)
650 {
651   const char *ret;
652
653   if (!cipher)
654     return ("(NONE)");
655
656   ret = gnutls_protocol_get_name (cipher->version);
657   if (ret)
658     return ret;
659
660   return ("unknown");
661 }
662
663 char *
664 SSL_CIPHER_description (SSL_CIPHER * cipher, char *buf, int size)
665 {
666   char *tmpbuf;
667   int tmpsize;
668   int local_alloc;
669
670   if (buf)
671     {
672       tmpbuf = buf;
673       tmpsize = size;
674       local_alloc = 0;
675     }
676   else
677     {
678       tmpbuf = (char *) malloc (128);
679       tmpsize = 128;
680       local_alloc = 1;
681     }
682
683   if (snprintf (tmpbuf, tmpsize, "%s %s %s %s",
684                 gnutls_protocol_get_name (cipher->version),
685                 gnutls_kx_get_name (cipher->kx),
686                 gnutls_cipher_get_name (cipher->cipher),
687                 gnutls_mac_get_name (cipher->mac)) == -1)
688     {
689       if (local_alloc)
690         free (tmpbuf);
691       return (char *) "Buffer too small";
692     }
693
694   return tmpbuf;
695 }
696
697
698 /* X509 functions */
699
700 X509_NAME *
701 X509_get_subject_name (const X509 * cert)
702 {
703   gnutls_x509_dn *dn;
704   dn = (gnutls_x509_dn *) calloc (1, sizeof (gnutls_x509_dn));
705   if (gnutls_x509_extract_certificate_dn (cert, dn) < 0)
706     {
707       free (dn);
708       return NULL;
709     }
710   return dn;
711 }
712
713 X509_NAME *
714 X509_get_issuer_name (const X509 * cert)
715 {
716   gnutls_x509_dn *dn;
717   dn = (gnutls_x509_dn *) calloc (1, sizeof (gnutls_x509_dn));
718   if (gnutls_x509_extract_certificate_issuer_dn (cert, dn) < 0)
719     {
720       free (dn);
721       return NULL;
722     }
723   return dn;
724 }
725
726 char *
727 X509_NAME_oneline (gnutls_x509_dn * name, char *buf, int len)
728 {
729   /* XXX openssl allocates buffer if buf == NULL */
730   if (!buf)
731     return NULL;
732   memset (buf, 0, len);
733
734   snprintf (buf, len - 1,
735             "C=%s, ST=%s, L=%s, O=%s, OU=%s, CN=%s/Email=%s",
736             name->country, name->state_or_province_name,
737             name->locality_name, name->organization,
738             name->organizational_unit_name, name->common_name, name->email);
739   return buf;
740 }
741
742 void
743 X509_free (const X509 * cert)
744 {
745   /* only get certificates as const items */
746 }
747
748
749 /* BIO functions */
750
751 void
752 BIO_get_fd (gnutls_session_t gnutls_state, int *fd)
753 {
754   gnutls_transport_ptr_t tmp = gnutls_transport_get_ptr (gnutls_state);
755   *fd = GNUTLS_POINTER_TO_INT (tmp);
756 }
757
758 BIO *
759 BIO_new_socket (int sock, int close_flag)
760 {
761   BIO *bio;
762
763   bio = (BIO *) malloc (sizeof (BIO));
764   if (!bio)
765     return NULL;
766
767   bio->fd = GNUTLS_INT_TO_POINTER (sock);
768
769   return bio;
770 }
771
772
773 /* error handling */
774
775 unsigned long
776 ERR_get_error (void)
777 {
778   unsigned long ret;
779
780   ret = -1 * last_error;
781   last_error = 0;
782
783   return ret;
784 }
785
786 const char *
787 ERR_error_string (unsigned long e, char *buf)
788 {
789   return gnutls_strerror (-1 * e);
790 }
791
792
793 /* RAND functions */
794
795 int
796 RAND_status (void)
797 {
798   return 1;
799 }
800
801 void
802 RAND_seed (const void *buf, int num)
803 {
804 }
805
806 int
807 RAND_bytes (unsigned char *buf, int num)
808 {
809   gnutls_rnd (GNUTLS_RND_RANDOM, buf, num);
810   return 1;
811 }
812
813 int
814 RAND_pseudo_bytes (unsigned char *buf, int num)
815 {
816   gnutls_rnd (GNUTLS_RND_NONCE, buf, num);
817   return 1;
818 }
819
820 const char *
821 RAND_file_name (char *buf, size_t len)
822 {
823   return "";
824 }
825
826 int
827 RAND_load_file (const char *name, long maxbytes)
828 {
829   return maxbytes;
830 }
831
832 int
833 RAND_write_file (const char *name)
834 {
835   return 0;
836 }
837
838 int
839 RAND_egd_bytes (const char *path, int bytes)
840 {
841   /* fake it */
842   return bytes;
843 }
844
845
846 /* message digest functions */
847
848 void
849 MD5_Init (MD5_CTX * ctx)
850 {
851   ctx->handle = gnutls_malloc (sizeof (digest_hd_st));
852   if (!ctx->handle)
853     abort ();
854   _gnutls_hash_init (ctx->handle, GNUTLS_DIG_MD5);
855 }
856
857 void
858 MD5_Update (MD5_CTX * ctx, const void *buf, int len)
859 {
860   _gnutls_hash (ctx->handle, buf, len);
861 }
862
863 void
864 MD5_Final (unsigned char *md, MD5_CTX * ctx)
865 {
866   _gnutls_hash_deinit (ctx->handle, md);
867   gnutls_free (ctx->handle);
868 }
869
870 unsigned char *
871 MD5 (const unsigned char *buf, unsigned long len, unsigned char *md)
872 {
873   if (!md)
874     return NULL;
875
876   _gnutls_hash_fast (GNUTLS_DIG_MD5, buf, len, md);
877
878   return md;
879 }
880
881 void
882 RIPEMD160_Init (RIPEMD160_CTX * ctx)
883 {
884   ctx->handle = gnutls_malloc (sizeof (digest_hd_st));
885   if (!ctx->handle)
886     abort ();
887   _gnutls_hash_init (ctx->handle, GNUTLS_DIG_RMD160);
888 }
889
890 void
891 RIPEMD160_Update (RIPEMD160_CTX * ctx, const void *buf, int len)
892 {
893   _gnutls_hash (ctx->handle, buf, len);
894 }
895
896 void
897 RIPEMD160_Final (unsigned char *md, RIPEMD160_CTX * ctx)
898 {
899   _gnutls_hash_deinit (ctx->handle, md);
900   gnutls_free (ctx->handle);
901 }
902
903 unsigned char *
904 RIPEMD160 (const unsigned char *buf, unsigned long len, unsigned char *md)
905 {
906   if (!md)
907     return NULL;
908
909   _gnutls_hash_fast (GNUTLS_DIG_RMD160, buf, len, md);
910
911   return md;
912 }