← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ext/openssl/ossl_ns_spki.c

  • Committer: Bazaar Package Importer
  • Author(s): akira yamada
  • Date: 2007-03-13 22:11:58 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20070313221158-h3oql37brlaf2go2
Tags: 1.8.6-1
http://bugs.debian.org/410018
* new upstream version, 1.8.6.
* libruby1.8 conflicts with libopenssl-ruby1.8 (< 1.8.6) (closes: #410018)
* changed packaging style to cdbs from dbs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/openssl/ossl_ns_spki.c
 
1
/*
 
2
 * $Id: ossl_ns_spki.c 11708 2007-02-12 23:01:19Z shyouhei $
 
3
 * 'OpenSSL for Ruby' project
 
4
 * Copyright (C) 2001-2002  Michal Rokos <m.rokos@sh.cvut.cz>
 
5
 * All rights reserved.
 
6
 */
 
7
/*
 
8
 * This program is licenced under the same licence as Ruby.
 
9
 * (See the file 'LICENCE'.)
 
10
 */
 
11
#include "ossl.h"
 
12
 
 
13
#define WrapSPKI(klass, obj, spki) do { \
 
14
    if (!spki) { \
 
15
        ossl_raise(rb_eRuntimeError, "SPKI wasn't initialized!"); \
 
16
    } \
 
17
    obj = Data_Wrap_Struct(klass, 0, NETSCAPE_SPKI_free, spki); \
 
18
} while (0)
 
19
#define GetSPKI(obj, spki) do { \
 
20
    Data_Get_Struct(obj, NETSCAPE_SPKI, spki); \
 
21
    if (!spki) { \
 
22
        ossl_raise(rb_eRuntimeError, "SPKI wasn't initialized!"); \
 
23
    } \
 
24
} while (0)
 
25
 
 
26
/*
 
27
 * Classes
 
28
 */
 
29
VALUE mNetscape;
 
30
VALUE cSPKI;
 
31
VALUE eSPKIError;
 
32
 
 
33
/*
 
34
 * Public functions
 
35
 */
 
36
 
 
37
/*
 
38
 * Private functions
 
39
 */
 
40
static VALUE
 
41
ossl_spki_alloc(VALUE klass)
 
42
{
 
43
    NETSCAPE_SPKI *spki;
 
44
    VALUE obj;
 
45
        
 
46
    if (!(spki = NETSCAPE_SPKI_new())) {
 
47
        ossl_raise(eSPKIError, NULL);
 
48
    }   
 
49
    WrapSPKI(klass, obj, spki);
 
50
        
 
51
    return obj;
 
52
}
 
53
 
 
54
static VALUE
 
55
ossl_spki_initialize(int argc, VALUE *argv, VALUE self)
 
56
{
 
57
    NETSCAPE_SPKI *spki;
 
58
    VALUE buffer;
 
59
    unsigned char *p;
 
60
        
 
61
    if (rb_scan_args(argc, argv, "01", &buffer) == 0) {
 
62
        return self;
 
63
    }
 
64
    StringValue(buffer);
 
65
    if (!(spki = NETSCAPE_SPKI_b64_decode(RSTRING(buffer)->ptr, -1))) {
 
66
        p = RSTRING(buffer)->ptr;
 
67
        if (!(spki = d2i_NETSCAPE_SPKI(NULL, &p, RSTRING(buffer)->len))) {
 
68
            ossl_raise(eSPKIError, NULL);
 
69
        }
 
70
    }
 
71
    NETSCAPE_SPKI_free(DATA_PTR(self));
 
72
    DATA_PTR(self) = spki;
 
73
    ERR_clear_error();
 
74
 
 
75
    return self;
 
76
}
 
77
 
 
78
static VALUE
 
79
ossl_spki_to_der(VALUE self)
 
80
{
 
81
    NETSCAPE_SPKI *spki;
 
82
    VALUE str;
 
83
    long len;
 
84
    unsigned char *p;
 
85
 
 
86
    GetSPKI(self, spki);
 
87
    if ((len = i2d_NETSCAPE_SPKI(spki, NULL)) <= 0)
 
88
        ossl_raise(eX509CertError, NULL);
 
89
    str = rb_str_new(0, len);
 
90
    p = RSTRING(str)->ptr;
 
91
    if (i2d_NETSCAPE_SPKI(spki, &p) <= 0)
 
92
        ossl_raise(eX509CertError, NULL);
 
93
    ossl_str_adjust(str, p);
 
94
    
 
95
    return str;
 
96
}
 
97
 
 
98
static VALUE
 
99
ossl_spki_to_pem(VALUE self)
 
100
{
 
101
    NETSCAPE_SPKI *spki;
 
102
    char *data;
 
103
    VALUE str;
 
104
        
 
105
    GetSPKI(self, spki);
 
106
    if (!(data = NETSCAPE_SPKI_b64_encode(spki))) {
 
107
        ossl_raise(eSPKIError, NULL);
 
108
    }
 
109
    str = ossl_buf2str(data, strlen(data));
 
110
 
 
111
    return str;
 
112
}
 
113
 
 
114
static VALUE
 
115
ossl_spki_print(VALUE self)
 
116
{
 
117
    NETSCAPE_SPKI *spki;
 
118
    BIO *out;
 
119
    BUF_MEM *buf;
 
120
    VALUE str;
 
121
        
 
122
    GetSPKI(self, spki);
 
123
    if (!(out = BIO_new(BIO_s_mem()))) {
 
124
        ossl_raise(eSPKIError, NULL);
 
125
    }
 
126
    if (!NETSCAPE_SPKI_print(out, spki)) {
 
127
        BIO_free(out);
 
128
        ossl_raise(eSPKIError, NULL);
 
129
    }
 
130
    BIO_get_mem_ptr(out, &buf);
 
131
    str = rb_str_new(buf->data, buf->length);
 
132
    BIO_free(out);
 
133
        
 
134
    return str;
 
135
}
 
136
 
 
137
static VALUE
 
138
ossl_spki_get_public_key(VALUE self)
 
139
{
 
140
    NETSCAPE_SPKI *spki;
 
141
    EVP_PKEY *pkey;
 
142
 
 
143
    GetSPKI(self, spki);
 
144
    if (!(pkey = NETSCAPE_SPKI_get_pubkey(spki))) { /* adds an reference */
 
145
        ossl_raise(eSPKIError, NULL);
 
146
    }
 
147
 
 
148
    return ossl_pkey_new(pkey); /* NO DUP - OK */
 
149
}
 
150
 
 
151
static VALUE
 
152
ossl_spki_set_public_key(VALUE self, VALUE key)
 
153
{
 
154
    NETSCAPE_SPKI *spki;
 
155
 
 
156
    GetSPKI(self, spki);
 
157
    if (!NETSCAPE_SPKI_set_pubkey(spki, GetPKeyPtr(key))) { /* NO NEED TO DUP */
 
158
        ossl_raise(eSPKIError, NULL);
 
159
    }
 
160
 
 
161
    return key;
 
162
}
 
163
 
 
164
static VALUE
 
165
ossl_spki_get_challenge(VALUE self)
 
166
{
 
167
    NETSCAPE_SPKI *spki;
 
168
 
 
169
    GetSPKI(self, spki);
 
170
    if (spki->spkac->challenge->length <= 0) {
 
171
        OSSL_Debug("Challenge.length <= 0?");
 
172
        return rb_str_new(0, 0);
 
173
    }
 
174
 
 
175
    return rb_str_new(spki->spkac->challenge->data,
 
176
                      spki->spkac->challenge->length);
 
177
}
 
178
 
 
179
static VALUE
 
180
ossl_spki_set_challenge(VALUE self, VALUE str)
 
181
{
 
182
    NETSCAPE_SPKI *spki;
 
183
 
 
184
    StringValue(str);
 
185
    GetSPKI(self, spki);
 
186
    if (!ASN1_STRING_set(spki->spkac->challenge, RSTRING(str)->ptr,
 
187
                         RSTRING(str)->len)) {
 
188
        ossl_raise(eSPKIError, NULL);
 
189
    }
 
190
    
 
191
    return str;
 
192
}
 
193
 
 
194
static VALUE
 
195
ossl_spki_sign(VALUE self, VALUE key, VALUE digest)
 
196
{
 
197
    NETSCAPE_SPKI *spki;
 
198
    EVP_PKEY *pkey;
 
199
    const EVP_MD *md;
 
200
 
 
201
    pkey = GetPrivPKeyPtr(key); /* NO NEED TO DUP */
 
202
    md = GetDigestPtr(digest);
 
203
    GetSPKI(self, spki);
 
204
    if (!NETSCAPE_SPKI_sign(spki, pkey, md)) {
 
205
        ossl_raise(eSPKIError, NULL);
 
206
    }
 
207
 
 
208
    return self;
 
209
}
 
210
 
 
211
/*
 
212
 * Checks that cert signature is made with PRIVversion of this PUBLIC 'key'
 
213
 */
 
214
static VALUE
 
215
ossl_spki_verify(VALUE self, VALUE key)
 
216
{
 
217
    NETSCAPE_SPKI *spki;
 
218
 
 
219
    GetSPKI(self, spki);
 
220
    switch (NETSCAPE_SPKI_verify(spki, GetPKeyPtr(key))) { /* NO NEED TO DUP */
 
221
    case 0:
 
222
        return Qfalse;
 
223
    case 1:
 
224
        return Qtrue;
 
225
    default:
 
226
        ossl_raise(eSPKIError, NULL);
 
227
    }
 
228
    return Qnil; /* dummy */
 
229
}
 
230
 
 
231
/*
 
232
 * NETSCAPE_SPKI init
 
233
 */
 
234
void
 
235
Init_ossl_ns_spki()
 
236
{
 
237
    mNetscape = rb_define_module_under(mOSSL, "Netscape");
 
238
        
 
239
    eSPKIError = rb_define_class_under(mNetscape, "SPKIError", eOSSLError);
 
240
        
 
241
    cSPKI = rb_define_class_under(mNetscape, "SPKI", rb_cObject);
 
242
        
 
243
    rb_define_alloc_func(cSPKI, ossl_spki_alloc);
 
244
    rb_define_method(cSPKI, "initialize", ossl_spki_initialize, -1);
 
245
        
 
246
    rb_define_method(cSPKI, "to_der", ossl_spki_to_der, 0);
 
247
    rb_define_method(cSPKI, "to_pem", ossl_spki_to_pem, 0);
 
248
    rb_define_alias(cSPKI, "to_s", "to_pem");
 
249
    rb_define_method(cSPKI, "to_text", ossl_spki_print, 0);
 
250
    rb_define_method(cSPKI, "public_key", ossl_spki_get_public_key, 0);
 
251
    rb_define_method(cSPKI, "public_key=", ossl_spki_set_public_key, 1);
 
252
    rb_define_method(cSPKI, "sign", ossl_spki_sign, 2);
 
253
    rb_define_method(cSPKI, "verify", ossl_spki_verify, 1);
 
254
    rb_define_method(cSPKI, "challenge", ossl_spki_get_challenge, 0);
 
255
    rb_define_method(cSPKI, "challenge=", ossl_spki_set_challenge, 1);
 
256
}
 
257