← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/ruby1.9/intrepid-updates

« back to all changes in this revision

Viewing changes to ext/digest/sha2/sha2hl.c

  • Committer: Bazaar Package Importer
  • Author(s): akira yamada
  • Date: 2007-05-21 14:00:19 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070521140019-ui4zd0v80duktssk
Tags: 1.9.0+20070521-1
http://bugs.debian.org/414856
http://bugs.debian.org/388344
new upstream snapshot. (2006-07-21)  (Closes: #414856, #388344)

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/digest/sha2/sha2hl.c
1
 
/* $NetBSD: sha2hl.c,v 1.1 2001/03/12 09:08:40 agc Exp $         */
2
 
/* $RoughId: sha2hl.c,v 1.2 2001/07/13 19:49:10 knu Exp $ */
3
 
/* $Id: sha2hl.c,v 1.1 2001/07/13 20:06:14 knu Exp $ */
4
 
 
5
 
/*
6
 
 * sha2hl.c
7
 
 * This code includes some functions taken from sha2.c, hence the
8
 
 * following licence reproduction.
9
 
 *
10
 
 * This code is not a verbatim copy, since some routines have been added,
11
 
 * and some bugs have been fixed.
12
 
 *
13
 
 * Version 1.0.0beta1
14
 
 *
15
 
 * Written by Aaron D. Gifford <me@aarongifford.com>
16
 
 *
17
 
 * Copyright 2000 Aaron D. Gifford.  All rights reserved.
18
 
 *
19
 
 * Redistribution and use in source and binary forms, with or without
20
 
 * modification, are permitted provided that the following conditions
21
 
 * are met:
22
 
 * 1. Redistributions of source code must retain the above copyright
23
 
 *    notice, this list of conditions and the following disclaimer.
24
 
 * 2. Redistributions in binary form must reproduce the above copyright
25
 
 *    notice, this list of conditions and the following disclaimer in the
26
 
 *    documentation and/or other materials provided with the distribution.
27
 
 * 3. Neither the name of the copyright holder nor the names of contributors
28
 
 *    may be used to endorse or promote products derived from this software
29
 
 *    without specific prior written permission.
30
 
 * 
31
 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) AND CONTRIBUTOR(S) ``AS IS'' AND
32
 
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
33
 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
34
 
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR(S) OR CONTRIBUTOR(S) BE LIABLE
35
 
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36
 
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37
 
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38
 
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
39
 
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
40
 
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
41
 
 * SUCH DAMAGE.
42
 
 *
43
 
 */
44
 
 
45
 
#include "sha2.h"
46
 
 
47
 
#ifndef lint
48
 
/* __RCSID("$NetBSD: sha2hl.c,v 1.1 2001/03/12 09:08:40 agc Exp $"); */
49
 
#endif                          /* not lint */
50
 
 
51
 
/* #include "namespace.h" */
52
 
 
53
 
#include <assert.h>
54
 
#include <errno.h>
55
 
#include <fcntl.h>
56
 
#include <stdio.h>
57
 
#include <string.h>
58
 
#include <stdlib.h>
59
 
#if defined(HAVE_UNISTD_H)
60
 
# include <unistd.h>
61
 
#endif
62
 
 
63
 
#ifndef _DIAGASSERT
64
 
#define _DIAGASSERT(cond)       assert(cond)
65
 
#endif
66
 
 
67
 
/*
68
 
 * Constant used by SHA256/384/512_End() functions for converting the
69
 
 * digest to a readable hexadecimal character string:
70
 
 */
71
 
static const char sha2_hex_digits[] = "0123456789abcdef";
72
 
 
73
 
char           *
74
 
SHA256_File(char *filename, char *buf)
75
 
{
76
 
        uint8_t         buffer[BUFSIZ * 20];
77
 
        SHA256_CTX      ctx;
78
 
        int             fd, num, oerrno;
79
 
 
80
 
        _DIAGASSERT(filename != NULL);
81
 
        /* XXX: buf may be NULL ? */
82
 
 
83
 
        SHA256_Init(&ctx);
84
 
 
85
 
        if ((fd = open(filename, O_RDONLY)) < 0)
86
 
                return (0);
87
 
 
88
 
        while ((num = read(fd, buffer, sizeof(buffer))) > 0)
89
 
                SHA256_Update(&ctx, buffer, (size_t) num);
90
 
 
91
 
        oerrno = errno;
92
 
        close(fd);
93
 
        errno = oerrno;
94
 
        return (num < 0 ? 0 : SHA256_End(&ctx, buf));
95
 
}
96
 
 
97
 
 
98
 
char           *
99
 
SHA256_End(SHA256_CTX *ctx, char buffer[])
100
 
{
101
 
        uint8_t         digest[SHA256_DIGEST_LENGTH], *d = digest;
102
 
        uint8_t        *ret;
103
 
        int             i;
104
 
 
105
 
        /* Sanity check: */
106
 
        assert(ctx != NULL);
107
 
 
108
 
        if ((ret = buffer) != NULL) {
109
 
                SHA256_Final(digest, ctx);
110
 
 
111
 
                for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
112
 
                        *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
113
 
                        *buffer++ = sha2_hex_digits[*d & 0x0f];
114
 
                        d++;
115
 
                }
116
 
                *buffer = (char) 0;
117
 
        } else {
118
 
                (void) memset(ctx, 0, sizeof(SHA256_CTX));
119
 
        }
120
 
        (void) memset(digest, 0, SHA256_DIGEST_LENGTH);
121
 
        return ret;
122
 
}
123
 
 
124
 
char           *
125
 
SHA256_Data(const uint8_t * data, size_t len, char *digest)
126
 
{
127
 
        SHA256_CTX      ctx;
128
 
 
129
 
        SHA256_Init(&ctx);
130
 
        SHA256_Update(&ctx, data, len);
131
 
        return SHA256_End(&ctx, digest);
132
 
}
133
 
 
134
 
char           *
135
 
SHA384_File(char *filename, char *buf)
136
 
{
137
 
        SHA384_CTX      ctx;
138
 
        uint8_t         buffer[BUFSIZ * 20];
139
 
        int             fd, num, oerrno;
140
 
 
141
 
        _DIAGASSERT(filename != NULL);
142
 
        /* XXX: buf may be NULL ? */
143
 
 
144
 
        SHA384_Init(&ctx);
145
 
 
146
 
        if ((fd = open(filename, O_RDONLY)) < 0)
147
 
                return (0);
148
 
 
149
 
        while ((num = read(fd, buffer, sizeof(buffer))) > 0)
150
 
                SHA384_Update(&ctx, buffer, (size_t) num);
151
 
 
152
 
        oerrno = errno;
153
 
        close(fd);
154
 
        errno = oerrno;
155
 
        return (num < 0 ? 0 : SHA384_End(&ctx, buf));
156
 
}
157
 
 
158
 
char           *
159
 
SHA384_End(SHA384_CTX * ctx, char buffer[])
160
 
{
161
 
        uint8_t         digest[SHA384_DIGEST_LENGTH], *d = digest;
162
 
        uint8_t        *ret;
163
 
        int             i;
164
 
 
165
 
        /* Sanity check: */
166
 
        assert(ctx != NULL);
167
 
 
168
 
        if ((ret = buffer) != NULL) {
169
 
                SHA384_Final(digest, ctx);
170
 
 
171
 
                for (i = 0; i < SHA384_DIGEST_LENGTH; i++) {
172
 
                        *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
173
 
                        *buffer++ = sha2_hex_digits[*d & 0x0f];
174
 
                        d++;
175
 
                }
176
 
                *buffer = (char) 0;
177
 
        } else {
178
 
                (void) memset(ctx, 0, sizeof(SHA384_CTX));
179
 
        }
180
 
        (void) memset(digest, 0, SHA384_DIGEST_LENGTH);
181
 
        return ret;
182
 
}
183
 
 
184
 
char           *
185
 
SHA384_Data(const uint8_t * data, size_t len, char *digest)
186
 
{
187
 
        SHA384_CTX      ctx;
188
 
 
189
 
        SHA384_Init(&ctx);
190
 
        SHA384_Update(&ctx, data, len);
191
 
        return SHA384_End(&ctx, digest);
192
 
}
193
 
 
194
 
char           *
195
 
SHA512_File(char *filename, char *buf)
196
 
{
197
 
        SHA512_CTX      ctx;
198
 
        uint8_t         buffer[BUFSIZ * 20];
199
 
        int             fd, num, oerrno;
200
 
 
201
 
        _DIAGASSERT(filename != NULL);
202
 
        /* XXX: buf may be NULL ? */
203
 
 
204
 
        SHA512_Init(&ctx);
205
 
 
206
 
        if ((fd = open(filename, O_RDONLY)) < 0)
207
 
                return (0);
208
 
 
209
 
        while ((num = read(fd, buffer, sizeof(buffer))) > 0)
210
 
                SHA512_Update(&ctx, buffer, (size_t) num);
211
 
 
212
 
        oerrno = errno;
213
 
        close(fd);
214
 
        errno = oerrno;
215
 
        return (num < 0 ? 0 : SHA512_End(&ctx, buf));
216
 
}
217
 
 
218
 
char           *
219
 
SHA512_End(SHA512_CTX * ctx, char buffer[])
220
 
{
221
 
        uint8_t         digest[SHA512_DIGEST_LENGTH], *d = digest;
222
 
        uint8_t        *ret;
223
 
        int             i;
224
 
 
225
 
        /* Sanity check: */
226
 
        assert(ctx != NULL);
227
 
 
228
 
        if ((ret = buffer) != NULL) {
229
 
                SHA512_Final(digest, ctx);
230
 
 
231
 
                for (i = 0; i < SHA512_DIGEST_LENGTH; i++) {
232
 
                        *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
233
 
                        *buffer++ = sha2_hex_digits[*d & 0x0f];
234
 
                        d++;
235
 
                }
236
 
                *buffer = (char) 0;
237
 
        } else {
238
 
                (void) memset(ctx, 0, sizeof(SHA512_CTX));
239
 
        }
240
 
        (void) memset(digest, 0, SHA512_DIGEST_LENGTH);
241
 
        return ret;
242
 
}
243
 
 
244
 
char           *
245
 
SHA512_Data(const uint8_t * data, size_t len, char *digest)
246
 
{
247
 
        SHA512_CTX      ctx;
248
 
 
249
 
        SHA512_Init(&ctx);
250
 
        SHA512_Update(&ctx, data, len);
251
 
        return SHA512_End(&ctx, digest);
252
 
}