1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
/*
* $Id$
* 'OpenSSL for Ruby' project
* Copyright (C) 2001-2002 Michal Rokos <m.rokos@sh.cvut.cz>
* All rights reserved.
*/
/*
* This program is licenced under the same licence as Ruby.
* (See the file 'LICENCE'.)
*/
#if !defined(OPENSSL_NO_HMAC)
#include "ossl.h"
#define WrapHMAC(obj, ctx) do { \
if (!ctx) { \
rb_raise(rb_eRuntimeError, "HMAC wasn't initialized"); \
} \
obj = Data_Wrap_Struct(cHMAC, 0, CRYPTO_free, ctx); \
} while (0)
#define GetHMAC(obj, ctx) do { \
Data_Get_Struct(obj, HMAC_CTX, ctx); \
if (!ctx) { \
rb_raise(rb_eRuntimeError, "HMAC wasn't initialized"); \
} \
} while (0)
/*
* Classes
*/
VALUE cHMAC;
VALUE eHMACError;
/*
* Public
*/
/*
* Private
*/
static VALUE
ossl_hmac_s_allocate(VALUE klass)
{
HMAC_CTX *ctx;
VALUE obj;
if (!(ctx = OPENSSL_malloc(sizeof(HMAC_CTX)))) {
OSSL_Raise(eHMACError, "");
}
WrapHMAC(obj, ctx);
return obj;
}
static VALUE
ossl_hmac_initialize(VALUE self, VALUE key, VALUE digest)
{
HMAC_CTX *ctx;
GetHMAC(self, ctx);
StringValue(key);
HMAC_Init(ctx, RSTRING(key)->ptr, RSTRING(key)->len, ossl_digest_get_EVP_MD(digest));
return self;
}
static VALUE
ossl_hmac_update(VALUE self, VALUE data)
{
HMAC_CTX *ctx;
GetHMAC(self, ctx);
StringValue(data);
HMAC_Update(ctx, RSTRING(data)->ptr, RSTRING(data)->len);
return self;
}
static void
hmac_final(HMAC_CTX *ctx, char **buf, int *buf_len)
{
HMAC_CTX final;
if (!HMAC_CTX_copy(&final, ctx)) {
OSSL_Raise(eHMACError, "");
}
if (!(*buf = OPENSSL_malloc(HMAC_size(&final)))) {
OSSL_Raise(eHMACError, "Cannot allocate memory for hmac");
}
HMAC_Final(&final, *buf, buf_len);
}
static VALUE
ossl_hmac_digest(VALUE self)
{
HMAC_CTX *ctx;
char *buf;
int buf_len;
VALUE digest;
GetHMAC(self, ctx);
hmac_final(ctx, &buf, &buf_len);
digest = rb_str_new(buf, buf_len);
OPENSSL_free(buf);
return digest;
}
static VALUE
ossl_hmac_hexdigest(VALUE self)
{
HMAC_CTX *ctx;
char *buf, *hexbuf;
int buf_len;
VALUE hexdigest;
GetHMAC(self, ctx);
hmac_final(ctx, &buf, &buf_len);
if (string2hex(buf, buf_len, &hexbuf, NULL) != 2 * buf_len) {
OPENSSL_free(buf);
OSSL_Raise(eHMACError, "Memory alloc error");
}
hexdigest = rb_str_new(hexbuf, 2 * buf_len);
OPENSSL_free(buf);
OPENSSL_free(hexbuf);
return hexdigest;
}
/*
* INIT
*/
void
Init_ossl_hmac()
{
eHMACError = rb_define_class_under(mOSSL, "HMACError", eOSSLError);
cHMAC = rb_define_class_under(mOSSL, "HMAC", rb_cObject);
rb_define_singleton_method(cHMAC, "allocate", ossl_hmac_s_allocate, 0);
rb_define_method(cHMAC, "initialize", ossl_hmac_initialize, 2);
rb_define_method(cHMAC, "update", ossl_hmac_update, 1);
rb_define_alias(cHMAC, "<<", "update");
rb_define_method(cHMAC, "digest", ossl_hmac_digest, 0);
rb_define_method(cHMAC, "hexdigest", ossl_hmac_hexdigest, 0);
rb_define_alias(cHMAC, "inspect", "hexdigest");
rb_define_alias(cHMAC, "to_s", "hexdigest");
}
#else /* NO_HMAC */
void
Init_ossl_hmac(VALUE module)
{
rb_warning("HMAC will NOT be avaible: OpenSSL is compiled without HMAC.");
}
#endif /* NO_HMAC */
|
