Add patch that contain Mali fixes.
[deb_xorg-server.git] / os / xsha1.c
1 #ifdef HAVE_DIX_CONFIG_H
2 #include <dix-config.h>
3 #endif
4
5 #include "os.h"
6 #include "xsha1.h"
7
8 #if defined(HAVE_SHA1_IN_LIBMD) /* Use libmd for SHA1 */ \
9 || defined(HAVE_SHA1_IN_LIBC) /* Use libc for SHA1 */
10
11 #include <sha1.h>
12
13 void *
14 x_sha1_init(void)
15 {
16 SHA1_CTX *ctx = malloc(sizeof(*ctx));
17
18 if (!ctx)
19 return NULL;
20 SHA1Init(ctx);
21 return ctx;
22 }
23
24 int
25 x_sha1_update(void *ctx, void *data, int size)
26 {
27 SHA1_CTX *sha1_ctx = ctx;
28
29 SHA1Update(sha1_ctx, data, size);
30 return 1;
31 }
32
33 int
34 x_sha1_final(void *ctx, unsigned char result[20])
35 {
36 SHA1_CTX *sha1_ctx = ctx;
37
38 SHA1Final(result, sha1_ctx);
39 free(sha1_ctx);
40 return 1;
41 }
42
43 #elif defined(HAVE_SHA1_IN_COMMONCRYPTO) /* Use CommonCrypto for SHA1 */
44
45 #include <CommonCrypto/CommonDigest.h>
46
47 void *
48 x_sha1_init(void)
49 {
50 CC_SHA1_CTX *ctx = malloc(sizeof(*ctx));
51
52 if (!ctx)
53 return NULL;
54 CC_SHA1_Init(ctx);
55 return ctx;
56 }
57
58 int
59 x_sha1_update(void *ctx, void *data, int size)
60 {
61 CC_SHA1_CTX *sha1_ctx = ctx;
62
63 CC_SHA1_Update(sha1_ctx, data, size);
64 return 1;
65 }
66
67 int
68 x_sha1_final(void *ctx, unsigned char result[20])
69 {
70 CC_SHA1_CTX *sha1_ctx = ctx;
71
72 CC_SHA1_Final(result, sha1_ctx);
73 free(sha1_ctx);
74 return 1;
75 }
76
77 #elif defined(HAVE_SHA1_IN_CRYPTOAPI) /* Use CryptoAPI for SHA1 */
78
79 #define WIN32_LEAN_AND_MEAN
80 #include <X11/Xwindows.h>
81 #include <wincrypt.h>
82
83 static HCRYPTPROV hProv;
84
85 void *
86 x_sha1_init(void)
87 {
88 HCRYPTHASH *ctx = malloc(sizeof(*ctx));
89
90 if (!ctx)
91 return NULL;
92 CryptAcquireContext(&hProv, NULL, MS_DEF_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
93 CryptCreateHash(hProv, CALG_SHA1, 0, 0, ctx);
94 return ctx;
95 }
96
97 int
98 x_sha1_update(void *ctx, void *data, int size)
99 {
100 HCRYPTHASH *hHash = ctx;
101
102 CryptHashData(*hHash, data, size, 0);
103 return 1;
104 }
105
106 int
107 x_sha1_final(void *ctx, unsigned char result[20])
108 {
109 HCRYPTHASH *hHash = ctx;
110 DWORD len = 20;
111
112 CryptGetHashParam(*hHash, HP_HASHVAL, result, &len, 0);
113 CryptDestroyHash(*hHash);
114 CryptReleaseContext(hProv, 0);
115 free(ctx);
116 return 1;
117 }
118
119 #elif defined(HAVE_SHA1_IN_LIBNETTLE) /* Use libnettle for SHA1 */
120
121 #include <nettle/sha.h>
122
123 void *
124 x_sha1_init(void)
125 {
126 struct sha1_ctx *ctx = malloc(sizeof(*ctx));
127
128 if (!ctx)
129 return NULL;
130 sha1_init(ctx);
131 return ctx;
132 }
133
134 int
135 x_sha1_update(void *ctx, void *data, int size)
136 {
137 sha1_update(ctx, size, data);
138 return 1;
139 }
140
141 int
142 x_sha1_final(void *ctx, unsigned char result[20])
143 {
144 sha1_digest(ctx, 20, result);
145 free(ctx);
146 return 1;
147 }
148
149 #elif defined(HAVE_SHA1_IN_LIBGCRYPT) /* Use libgcrypt for SHA1 */
150
151 #include <gcrypt.h>
152
153 void *
154 x_sha1_init(void)
155 {
156 static int init;
157 gcry_md_hd_t h;
158 gcry_error_t err;
159
160 if (!init) {
161 if (!gcry_check_version(NULL))
162 return NULL;
163 gcry_control(GCRYCTL_DISABLE_SECMEM, 0);
164 gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);
165 init = 1;
166 }
167
168 err = gcry_md_open(&h, GCRY_MD_SHA1, 0);
169 if (err)
170 return NULL;
171 return h;
172 }
173
174 int
175 x_sha1_update(void *ctx, void *data, int size)
176 {
177 gcry_md_hd_t h = ctx;
178
179 gcry_md_write(h, data, size);
180 return 1;
181 }
182
183 int
184 x_sha1_final(void *ctx, unsigned char result[20])
185 {
186 gcry_md_hd_t h = ctx;
187
188 memcpy(result, gcry_md_read(h, GCRY_MD_SHA1), 20);
189 gcry_md_close(h);
190 return 1;
191 }
192
193 #elif defined(HAVE_SHA1_IN_LIBSHA1) /* Use libsha1 */
194
195 #include <libsha1.h>
196
197 void *
198 x_sha1_init(void)
199 {
200 sha1_ctx *ctx = malloc(sizeof(*ctx));
201
202 if (!ctx)
203 return NULL;
204 sha1_begin(ctx);
205 return ctx;
206 }
207
208 int
209 x_sha1_update(void *ctx, void *data, int size)
210 {
211 sha1_hash(data, size, ctx);
212 return 1;
213 }
214
215 int
216 x_sha1_final(void *ctx, unsigned char result[20])
217 {
218 sha1_end(result, ctx);
219 free(ctx);
220 return 1;
221 }
222
223 #else /* Use OpenSSL's libcrypto */
224
225 #include <stddef.h> /* buggy openssl/sha.h wants size_t */
226 #include <openssl/sha.h>
227
228 void *
229 x_sha1_init(void)
230 {
231 int ret;
232 SHA_CTX *ctx = malloc(sizeof(*ctx));
233
234 if (!ctx)
235 return NULL;
236 ret = SHA1_Init(ctx);
237 if (!ret) {
238 free(ctx);
239 return NULL;
240 }
241 return ctx;
242 }
243
244 int
245 x_sha1_update(void *ctx, void *data, int size)
246 {
247 int ret;
248 SHA_CTX *sha_ctx = ctx;
249
250 ret = SHA1_Update(sha_ctx, data, size);
251 if (!ret)
252 free(sha_ctx);
253 return ret;
254 }
255
256 int
257 x_sha1_final(void *ctx, unsigned char result[20])
258 {
259 int ret;
260 SHA_CTX *sha_ctx = ctx;
261
262 ret = SHA1_Final(result, sha_ctx);
263 free(sha_ctx);
264 return ret;
265 }
266
267 #endif