Import of code from heimdal
[openafs.git] / src / external / heimdal / hcrypto / rand-w32.c
1 /*
2  * Copyright (c) 2006 Kungliga Tekniska Högskolan
3  * (Royal Institute of Technology, Stockholm, Sweden).
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * 3. Neither the name of the Institute nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33
34 #include <config.h>
35 #include <roken.h>
36
37 #include <wincrypt.h>
38
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <rand.h>
42 #include <heim_threads.h>
43
44 #include "randi.h"
45
46 volatile static HCRYPTPROV g_cryptprovider = 0;
47
48 static HCRYPTPROV
49 _hc_CryptProvider(void)
50 {
51     BOOL rv;
52     HCRYPTPROV cryptprovider = 0;
53
54     if (g_cryptprovider != 0)
55         return g_cryptprovider;
56
57     rv = CryptAcquireContext(&cryptprovider, NULL,
58                               MS_ENHANCED_PROV, PROV_RSA_FULL,
59                               CRYPT_VERIFYCONTEXT);
60
61     if (GetLastError() == NTE_BAD_KEYSET) {
62         rv = CryptAcquireContext(&cryptprovider, NULL,
63                                  MS_ENHANCED_PROV, PROV_RSA_FULL,
64                                  CRYPT_NEWKEYSET);
65     }
66
67     if (rv) {
68         /* try the default provider */
69         rv = CryptAcquireContext(&cryptprovider, NULL, 0, PROV_RSA_FULL,
70                                  CRYPT_VERIFYCONTEXT);
71
72         if (GetLastError() == NTE_BAD_KEYSET) {
73             rv = CryptAcquireContext(&cryptprovider, NULL,
74                                      MS_ENHANCED_PROV, PROV_RSA_FULL,
75                                      CRYPT_NEWKEYSET);
76         }
77     }
78
79     if (rv) {
80         /* try just a default random number generator */
81         rv = CryptAcquireContext(&cryptprovider, NULL, 0, PROV_RNG,
82                                  CRYPT_VERIFYCONTEXT);
83     }
84
85     if (rv &&
86         InterlockedCompareExchangePointer((PVOID *) &g_cryptprovider,
87                                           (PVOID) cryptprovider, 0) != 0) {
88
89         CryptReleaseContext(cryptprovider, 0);
90         cryptprovider = g_cryptprovider;
91     }
92
93     return cryptprovider;
94 }
95
96 /*
97  *
98  */
99
100
101 static void
102 w32crypto_seed(const void *indata, int size)
103 {
104 }
105
106
107 static int
108 w32crypto_bytes(unsigned char *outdata, int size)
109 {
110     if (CryptGenRandom(_hc_CryptProvider(), size, outdata))
111         return 1;
112     return 0;
113 }
114
115 static void
116 w32crypto_cleanup(void)
117 {
118     HCRYPTPROV cryptprovider;
119
120     if (InterlockedCompareExchangePointer((PVOID *) &cryptprovider,
121                                           0, (PVOID) g_cryptprovider) == 0) {
122         CryptReleaseContext(cryptprovider, 0);
123     }
124 }
125
126 static void
127 w32crypto_add(const void *indata, int size, double entropi)
128 {
129 }
130
131 static int
132 w32crypto_status(void)
133 {
134     if (_hc_CryptProvider() == 0)
135         return 0;
136     return 1;
137 }
138
139 const RAND_METHOD hc_rand_w32crypto_method = {
140     w32crypto_seed,
141     w32crypto_bytes,
142     w32crypto_cleanup,
143     w32crypto_add,
144     w32crypto_bytes,
145     w32crypto_status
146 };
147
148 const RAND_METHOD *
149 RAND_w32crypto_method(void)
150 {
151     return &hc_rand_w32crypto_method;
152 }