← Back to branch summary

~ubuntu-branches/ubuntu/natty/postgresql-8.4/natty-security

« back to all changes in this revision

Viewing changes to contrib/pgcrypto/internal-sha2.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2009-07-11 16:59:35 UTC
  • mfrom: (5.1.1 karmic)
  • Revision ID: james.westby@ubuntu.com-20090711165935-jfwin6gfrxf0gfsi
Tags: 8.4.0-2
http://bugs.debian.org/536139
* debian/libpq-dev.install: Ship catalog/genbki.h. (Closes: #536139)
* debian/rules: Drop --enable-cassert for final release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/pgcrypto/internal-sha2.c
26
26
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27
27
 * SUCH DAMAGE.
28
28
 *
29
 
 * $PostgreSQL: pgsql/contrib/pgcrypto/internal-sha2.c,v 1.2 2006/10/04 00:29:46 momjian Exp $
 
29
 * $PostgreSQL: pgsql/contrib/pgcrypto/internal-sha2.c,v 1.3 2009/06/11 14:48:52 momjian Exp $
30
30
 */
31
31
 
32
32
#include "postgres.h"
36
36
#include "px.h"
37
37
#include "sha2.h"
38
38
 
39
 
void            init_sha224(PX_MD * h);
40
 
void            init_sha256(PX_MD * h);
41
 
void            init_sha384(PX_MD * h);
42
 
void            init_sha512(PX_MD * h);
 
39
void            init_sha224(PX_MD *h);
 
40
void            init_sha256(PX_MD *h);
 
41
void            init_sha384(PX_MD *h);
 
42
void            init_sha512(PX_MD *h);
43
43
 
44
44
/* SHA224 */
45
45
 
46
46
static unsigned
47
 
int_sha224_len(PX_MD * h)
 
47
int_sha224_len(PX_MD *h)
48
48
{
49
49
        return SHA224_DIGEST_LENGTH;
50
50
}
51
51
 
52
52
static unsigned
53
 
int_sha224_block_len(PX_MD * h)
 
53
int_sha224_block_len(PX_MD *h)
54
54
{
55
55
        return SHA224_BLOCK_LENGTH;
56
56
}
57
57
 
58
58
static void
59
 
int_sha224_update(PX_MD * h, const uint8 *data, unsigned dlen)
 
59
int_sha224_update(PX_MD *h, const uint8 *data, unsigned dlen)
60
60
{
61
61
        SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
62
62
 
64
64
}
65
65
 
66
66
static void
67
 
int_sha224_reset(PX_MD * h)
 
67
int_sha224_reset(PX_MD *h)
68
68
{
69
69
        SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
70
70
 
72
72
}
73
73
 
74
74
static void
75
 
int_sha224_finish(PX_MD * h, uint8 *dst)
 
75
int_sha224_finish(PX_MD *h, uint8 *dst)
76
76
{
77
77
        SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
78
78
 
80
80
}
81
81
 
82
82
static void
83
 
int_sha224_free(PX_MD * h)
 
83
int_sha224_free(PX_MD *h)
84
84
{
85
85
        SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
86
86
 
92
92
/* SHA256 */
93
93
 
94
94
static unsigned
95
 
int_sha256_len(PX_MD * h)
 
95
int_sha256_len(PX_MD *h)
96
96
{
97
97
        return SHA256_DIGEST_LENGTH;
98
98
}
99
99
 
100
100
static unsigned
101
 
int_sha256_block_len(PX_MD * h)
 
101
int_sha256_block_len(PX_MD *h)
102
102
{
103
103
        return SHA256_BLOCK_LENGTH;
104
104
}
105
105
 
106
106
static void
107
 
int_sha256_update(PX_MD * h, const uint8 *data, unsigned dlen)
 
107
int_sha256_update(PX_MD *h, const uint8 *data, unsigned dlen)
108
108
{
109
109
        SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
110
110
 
112
112
}
113
113
 
114
114
static void
115
 
int_sha256_reset(PX_MD * h)
 
115
int_sha256_reset(PX_MD *h)
116
116
{
117
117
        SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
118
118
 
120
120
}
121
121
 
122
122
static void
123
 
int_sha256_finish(PX_MD * h, uint8 *dst)
 
123
int_sha256_finish(PX_MD *h, uint8 *dst)
124
124
{
125
125
        SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
126
126
 
128
128
}
129
129
 
130
130
static void
131
 
int_sha256_free(PX_MD * h)
 
131
int_sha256_free(PX_MD *h)
132
132
{
133
133
        SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
134
134
 
140
140
/* SHA384 */
141
141
 
142
142
static unsigned
143
 
int_sha384_len(PX_MD * h)
 
143
int_sha384_len(PX_MD *h)
144
144
{
145
145
        return SHA384_DIGEST_LENGTH;
146
146
}
147
147
 
148
148
static unsigned
149
 
int_sha384_block_len(PX_MD * h)
 
149
int_sha384_block_len(PX_MD *h)
150
150
{
151
151
        return SHA384_BLOCK_LENGTH;
152
152
}
153
153
 
154
154
static void
155
 
int_sha384_update(PX_MD * h, const uint8 *data, unsigned dlen)
 
155
int_sha384_update(PX_MD *h, const uint8 *data, unsigned dlen)
156
156
{
157
157
        SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
158
158
 
160
160
}
161
161
 
162
162
static void
163
 
int_sha384_reset(PX_MD * h)
 
163
int_sha384_reset(PX_MD *h)
164
164
{
165
165
        SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
166
166
 
168
168
}
169
169
 
170
170
static void
171
 
int_sha384_finish(PX_MD * h, uint8 *dst)
 
171
int_sha384_finish(PX_MD *h, uint8 *dst)
172
172
{
173
173
        SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
174
174
 
176
176
}
177
177
 
178
178
static void
179
 
int_sha384_free(PX_MD * h)
 
179
int_sha384_free(PX_MD *h)
180
180
{
181
181
        SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
182
182
 
188
188
/* SHA512 */
189
189
 
190
190
static unsigned
191
 
int_sha512_len(PX_MD * h)
 
191
int_sha512_len(PX_MD *h)
192
192
{
193
193
        return SHA512_DIGEST_LENGTH;
194
194
}
195
195
 
196
196
static unsigned
197
 
int_sha512_block_len(PX_MD * h)
 
197
int_sha512_block_len(PX_MD *h)
198
198
{
199
199
        return SHA512_BLOCK_LENGTH;
200
200
}
201
201
 
202
202
static void
203
 
int_sha512_update(PX_MD * h, const uint8 *data, unsigned dlen)
 
203
int_sha512_update(PX_MD *h, const uint8 *data, unsigned dlen)
204
204
{
205
205
        SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
206
206
 
208
208
}
209
209
 
210
210
static void
211
 
int_sha512_reset(PX_MD * h)
 
211
int_sha512_reset(PX_MD *h)
212
212
{
213
213
        SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
214
214
 
216
216
}
217
217
 
218
218
static void
219
 
int_sha512_finish(PX_MD * h, uint8 *dst)
 
219
int_sha512_finish(PX_MD *h, uint8 *dst)
220
220
{
221
221
        SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
222
222
 
224
224
}
225
225
 
226
226
static void
227
 
int_sha512_free(PX_MD * h)
 
227
int_sha512_free(PX_MD *h)
228
228
{
229
229
        SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
230
230
 
236
236
/* init functions */
237
237
 
238
238
void
239
 
init_sha224(PX_MD * md)
 
239
init_sha224(PX_MD *md)
240
240
{
241
241
        SHA224_CTX *ctx;
242
242
 
256
256
}
257
257
 
258
258
void
259
 
init_sha256(PX_MD * md)
 
259
init_sha256(PX_MD *md)
260
260
{
261
261
        SHA256_CTX *ctx;
262
262
 
276
276
}
277
277
 
278
278
void
279
 
init_sha384(PX_MD * md)
 
279
init_sha384(PX_MD *md)
280
280
{
281
281
        SHA384_CTX *ctx;
282
282
 
296
296
}
297
297
 
298
298
void
299
 
init_sha512(PX_MD * md)
 
299
init_sha512(PX_MD *md)
300
300
{
301
301
        SHA512_CTX *ctx;
302
302