krypt-core 0.0.1

data/ext/krypt/core/krypt_io_in_pem.c

@@ -0,0 +1,397 @@
+/*
+ * krypt-core API - C implementation
+ *
+ * Copyright (c) 2011-2013
+ * Hiroshi Nakamura <nahi@ruby-lang.org>
+ * Martin Bosslet <martin.bosslet@gmail.com>
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "krypt-core.h"
+
+enum krypt_pem_state {
+    HEADER = 0,
+    CONTENT,
+    FOOTER,
+    DONE
+};
+
+#define KRYPT_LINE_BUF_SIZE 256
+
+typedef struct krypt_pem_parse_ctx_st {
+    char *line;
+    size_t len;
+    size_t off;
+    char *name;
+} krypt_pem_parse_ctx;
+
+typedef struct krypt_b64_buffer_st {
+    binyo_instream *inner;
+    uint8_t *buffer;
+    size_t len;
+    size_t off;
+    enum krypt_pem_state state;
+    char *name;
+    int eof;
+} krypt_b64_buffer;
+
+typedef struct krypt_instream_pem_st {
+    binyo_instream_interface *methods;
+    krypt_b64_buffer *buffer;
+} krypt_instream_pem;
+
+#define int_safe_cast(out, in)		binyo_safe_cast_instream((out), (in), KRYPT_INSTREAM_TYPE_PEM, krypt_instream_pem)
+
+static krypt_instream_pem* int_pem_alloc(void);
+static ssize_t int_pem_read(binyo_instream *in, uint8_t *buf, size_t len);
+static int int_pem_seek(binyo_instream *in, off_t offset, int whence);
+static void int_pem_mark(binyo_instream *in);
+static void int_pem_free(binyo_instream *in);
+
+static binyo_instream_interface interface_pem = {
+    KRYPT_INSTREAM_TYPE_PEM,
+    int_pem_read,
+    NULL,
+    NULL,
+    int_pem_seek,
+    int_pem_mark,
+    int_pem_free
+};
+
+static krypt_b64_buffer*
+int_krypt_b64_buffer_new(binyo_instream *original)
+{
+    krypt_b64_buffer *ret;
+    ret = ALLOC(krypt_b64_buffer);
+    memset(ret, 0, sizeof(krypt_b64_buffer));
+    ret->inner = original;
+    ret->state = HEADER;
+    return ret;
+}
+
+binyo_instream *
+krypt_instream_new_pem(binyo_instream *original)
+{
+    krypt_instream_pem *in;
+
+    in = int_pem_alloc();
+    in->buffer = int_krypt_b64_buffer_new(original);
+    return (binyo_instream *) in;
+}
+
+static krypt_instream_pem*
+int_pem_alloc(void)
+{
+    krypt_instream_pem *ret;
+    ret = ALLOC(krypt_instream_pem);
+    memset(ret, 0, sizeof(krypt_instream_pem));
+    ret->methods = &interface_pem;
+    return ret;
+}
+
+static int
+int_pem_seek(binyo_instream *instream, off_t offset, int whence)
+{
+    /* TODO */
+    return BINYO_OK;
+}
+
+static void
+int_pem_mark(binyo_instream *instream)
+{
+    krypt_instream_pem *in;
+
+    if (!instream) return;
+    int_safe_cast(in, instream);
+    binyo_instream_mark(in->buffer->inner);
+}
+
+static void
+int_pem_free_inner(krypt_instream_pem *in)
+{
+    krypt_b64_buffer *b64;
+
+    b64 = in->buffer;
+    if (b64->buffer)
+	xfree(b64->buffer);
+    if (b64->name)
+	xfree(b64->name);
+    xfree(b64);
+}
+
+static void
+int_pem_free(binyo_instream *instream)
+{
+    krypt_instream_pem *in;
+    krypt_b64_buffer *b64;
+
+    if (!instream) return;
+    int_safe_cast(in, instream);
+    b64 = in->buffer;
+
+    binyo_instream_free(b64->inner);
+    int_pem_free_inner(in);
+}
+
+void
+krypt_instream_pem_free_wrapper(binyo_instream *instream)
+{
+    krypt_instream_pem *in;
+
+    if (!instream) return;
+    int_safe_cast(in, instream);
+
+    int_pem_free_inner(in);
+    xfree(in);
+}
+
+int
+krypt_pem_get_last_name(binyo_instream *instream, uint8_t **out, size_t *outlen)
+{
+    krypt_instream_pem *in;
+    krypt_b64_buffer *b64;
+    size_t retlen;
+
+    if (!instream) {
+	*out = NULL;
+	return BINYO_ERR;
+    }
+
+    int_safe_cast(in, instream);
+    b64 = in->buffer;
+
+    if (!b64->name) {
+	*out = NULL;
+	return BINYO_ERR;
+    }
+
+    retlen = strlen(b64->name);
+    *out = ALLOC_N(uint8_t, retlen);
+    memcpy(*out, b64->name, retlen);
+    *outlen = retlen;
+    return BINYO_OK;
+}
+
+
+void
+krypt_pem_continue_stream(binyo_instream *instream)
+{
+    krypt_instream_pem *in;
+    krypt_b64_buffer *b64;
+
+    if (!instream) return;
+    int_safe_cast(in, instream);
+    b64 = in->buffer;
+    b64->state = HEADER;
+    b64->eof = 0;
+    b64->off = 0;
+    b64->len = 0;
+    if (b64->name)
+	xfree(b64->name);
+    b64->name = NULL;
+    if (b64->buffer)
+	xfree(b64->buffer);
+    b64->buffer = NULL;
+}
+
+
+static int
+int_match_header(krypt_pem_parse_ctx *ctx)
+{
+    if (ctx->len == KRYPT_LINE_BUF_SIZE)
+	return BINYO_ERR;
+    if (strncmp(ctx->line, "-----BEGIN ", 11) == 0) {
+	size_t len;
+	len = ctx->len;
+	if (strncmp(ctx->line + len - 5, "-----", 5) != 0)
+	    return BINYO_ERR;
+	ctx->name = ALLOC_N(char, len - 11 - 4);
+	memcpy(ctx->name, ctx->line + 11, len - 11 - 5);
+	ctx->name[len - 11 - 5] = '\0';
+	return BINYO_OK;
+    }
+    return BINYO_ERR;
+}
+
+static int
+int_match_footer(krypt_pem_parse_ctx *ctx)
+{
+    char *name = ctx->name;
+
+    if (ctx->len == KRYPT_LINE_BUF_SIZE)
+	return BINYO_ERR;
+    if (strncmp(ctx->line, "-----END ", 9) == 0) {
+	size_t len;
+	len = ctx->len;
+	if (strncmp(ctx->line + len - 5, "-----", 5) != 0)
+	    return BINYO_ERR;
+	if (strncmp(ctx->line + 9, name, len - 9 - 5) == 0)
+	    return BINYO_OK;
+    }
+    return BINYO_ERR;
+}
+
+static int
+int_b64_fill(krypt_b64_buffer *in)
+{
+    binyo_outstream *out;
+    size_t total = 0;
+    ssize_t linelen;
+    char linebuf[KRYPT_LINE_BUF_SIZE]; 
+
+    if (in->buffer) {
+	xfree(in->buffer);
+        in->buffer = NULL;
+    }
+
+    out = binyo_outstream_new_bytes_size(BINYO_IO_BUF_SIZE + KRYPT_LINE_BUF_SIZE);
+    linelen = binyo_instream_gets(in->inner, linebuf, KRYPT_LINE_BUF_SIZE);
+
+    while (in->state != DONE && total < BINYO_IO_BUF_SIZE && linelen != BINYO_IO_EOF) {
+	if (linelen == BINYO_ERR) return BINYO_ERR;
+
+	if (linelen == 0) {
+	    linelen = binyo_instream_gets(in->inner, linebuf, KRYPT_LINE_BUF_SIZE);
+	    continue;
+	}
+
+	switch (in->state) {
+	    case HEADER:
+		if (linebuf[0] == '-') {
+		    krypt_pem_parse_ctx linectx;
+		    linectx.line = linebuf;
+		    linectx.len = linelen;
+		    linectx.off = 0;
+		    if (int_match_header(&linectx) == BINYO_OK) {
+			in->name = linectx.name;
+			in->state = CONTENT;
+		    }
+		}
+		linelen = binyo_instream_gets(in->inner, linebuf, KRYPT_LINE_BUF_SIZE);
+		break;
+	    case CONTENT:
+		if (linebuf[0] == '-') {
+		    in->state = FOOTER;
+		}
+		else {
+		    if (krypt_base64_buffer_decode_to(out, (uint8_t *) linebuf, 0, linelen) == KRYPT_ERR) {
+			krypt_error_add("Could not decode Base64 data");
+			return BINYO_ERR;
+		    }
+		    total += linelen;
+		    if (total < BINYO_IO_BUF_SIZE)
+			linelen = binyo_instream_gets(in->inner, linebuf, KRYPT_LINE_BUF_SIZE);
+		}
+		break;
+	    case FOOTER:
+		if (linebuf[0] == '-') {
+		    krypt_pem_parse_ctx linectx;
+		    linectx.line = linebuf;
+		    linectx.len = linelen;
+		    linectx.off = 0;
+		    linectx.name = in->name;
+		    if (int_match_footer(&linectx) == BINYO_OK)
+			in->state = DONE;
+		    else
+			linelen = binyo_instream_gets(in->inner, linebuf, KRYPT_LINE_BUF_SIZE);
+		}
+		else {
+		    linelen = binyo_instream_gets(in->inner, linebuf, KRYPT_LINE_BUF_SIZE);
+		}
+		break;
+	    default:
+		break;
+	}
+    }
+
+    if (linelen == BINYO_ERR) return BINYO_ERR;
+
+    if (in->state == DONE || linelen == BINYO_IO_EOF)
+	in->eof = 1;
+
+    if (linelen == BINYO_IO_EOF && in->state != DONE) {
+	binyo_outstream_free(out);
+	switch (in->state) {
+	    case HEADER:
+		in->len = in->off = 0;
+		in->eof = 1;
+		return BINYO_OK;
+	    case CONTENT:
+		krypt_error_add("PEM data ended prematurely");
+		return BINYO_ERR;
+	    default:
+		krypt_error_add("Could not find matching PEM footer");
+		return BINYO_ERR;
+	}
+    }
+
+    in->off = 0;
+    in->len = binyo_outstream_bytes_get_bytes_free(out, &in->buffer);
+    return BINYO_OK;
+}
+
+static size_t
+int_consume_bytes(krypt_b64_buffer *in, uint8_t *buf, size_t len)
+{
+    size_t available, toread;
+
+    if (in->off == in->len)
+	return 0;
+
+    available = in->len - in->off;
+    toread = len < available ? len : available;
+    memcpy(buf, in->buffer + in->off, toread);
+    in->off += toread;
+    return toread;
+}
+
+static ssize_t
+int_b64_read(krypt_b64_buffer *in, uint8_t *buf, size_t len)
+{
+    size_t total = 0;
+
+    while (total != len && !(in->off == in->len && in->eof)) {
+	if (in->off == in->len) {
+	    if (int_b64_fill(in) == BINYO_ERR) return BINYO_ERR;
+	}
+	total += int_consume_bytes(in, buf + total, len - total);
+    }
+
+    if (total == 0 && in->eof)
+	return BINYO_IO_EOF;
+
+    if (total > SSIZE_MAX) {
+	krypt_error_add("Return size too large: %ld", total);
+	return BINYO_ERR;
+    }
+    return (ssize_t) total;
+}
+
+static ssize_t
+int_pem_read(binyo_instream *instream, uint8_t *buf, size_t len)
+{
+    krypt_instream_pem *in;
+    if (!buf) return BINYO_ERR;
+    int_safe_cast(in, instream);
+    return int_b64_read(in->buffer, buf, len);
+}
+

data/ext/krypt/core/krypt_missing.c

@@ -0,0 +1,238 @@
+/*
+ * krypt-core API - C implementation
+ *
+ * Copyright (c) 2011-2013
+ * Hiroshi Nakamura <nahi@ruby-lang.org>
+ * Martin Bosslet <martin.bosslet@gmail.com>
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "krypt-core.h"
+
+#ifndef HAVE_RB_STR_ENCODE
+VALUE
+rb_str_encode(VALUE str, VALUE to, int ecflags, VALUE ecopts)
+{
+    rb_encoding *enc = rb_enc_get(to);
+    rb_enc_associate(str, enc);
+    return str;
+}
+#endif
+
+#ifndef HAVE_GMTIME_R
+struct tm *
+krypt_gmtime_r(const time_t *tp, struct tm *result)
+{
+    struct tm *t = gmtime(tp);
+    if (t) *result = *t;
+    return t;
+}
+#endif
+
+#ifdef HAVE_RB_BIG_PACK
+int
+krypt_asn1_encode_bignum(VALUE bignum, uint8_t **out, size_t *outlen)
+{
+    int len, i, j;
+    long num_longs, biglen, divisor;
+    unsigned long *longs;
+    uint8_t *bytes;
+    uint8_t *ptr;
+    uint8_t msb;
+    unsigned long l;
+
+    biglen = RBIGNUM_LEN(bignum);
+    divisor = SIZEOF_LONG / SIZEOF_BDIGITS;
+    num_longs = (biglen % divisor) == 0 ? biglen / divisor : biglen / divisor + 1;
+    longs = ALLOC_N(unsigned long, num_longs);
+    rb_big_pack(bignum, longs, num_longs);
+    msb = longs[num_longs - 1] >> (SIZEOF_LONG * CHAR_BIT - 1);
+
+    if (RBIGNUM_SIGN(bignum) == ((msb & 1) == 1)) {
+	/* We can't use int_encode_integer here because longs are unsigned */
+	len = num_longs * SIZEOF_LONG + 1;
+	bytes = ALLOC_N(uint8_t, len);
+	ptr = bytes;
+	*ptr++ = RBIGNUM_SIGN(bignum) ? 0x00 : 0xff;
+    }
+    else {
+	uint8_t *buf;
+	size_t encoded;
+
+	encoded = krypt_asn1_encode_integer(longs[num_longs - 1], &buf);
+	len = encoded + (num_longs - 1) * SIZEOF_LONG;
+	bytes = ALLOC_N(uint8_t, len);
+	ptr = bytes;
+	memcpy(ptr, buf, encoded);
+	ptr += encoded;
+	--num_longs;
+	xfree(buf);
+    }
+    for (i = num_longs - 1; i >= 0; --i) {
+	l = longs[i];
+	for (j = 0; j < SIZEOF_LONG; ++j) {
+	    ptr[SIZEOF_LONG - j - 1] = l & 0xff;
+	    l >>= CHAR_BIT;
+	}
+	ptr += SIZEOF_LONG;
+    }
+    xfree(longs);
+    *out = bytes;
+    *outlen = ptr - bytes;
+    return KRYPT_OK;
+}
+#else
+int
+krypt_asn1_encode_bignum(VALUE bignum, uint8_t **out, size_t *outlen)
+{
+    VALUE hexstr;
+    int sign;
+    char *hexstrbytes;
+    int free_hex = 0;
+    long hexstrlen;
+    uint8_t *numbytes;
+    size_t numlen;
+
+    sign = RBIGNUM_NEGATIVE_P(bignum);
+
+    hexstr = rb_funcall(bignum, rb_intern("to_s"), 1, INT2NUM(16));
+    hexstrbytes = (char *) RSTRING_PTR(hexstr);
+    hexstrlen = RSTRING_LEN(hexstr);
+
+    if (sign) {
+	hexstrbytes++;
+	hexstrlen--; /* discard '-' */
+    }
+
+    if (hexstrlen % 2) {
+	/* pad with leading 0 */
+	char *padded = ALLOC_N(char, hexstrlen + 1);
+	padded[0] = '0';
+	memcpy(padded +1, hexstrbytes, hexstrlen);
+	hexstrbytes = padded;
+	hexstrlen++;
+	free_hex = 1;
+    }
+
+    if (krypt_hex_decode(hexstrbytes, hexstrlen, &numbytes, &numlen) == KRYPT_ERR) {
+	if (free_hex) xfree(hexstrbytes);
+	return KRYPT_ERR;
+    }
+    if (sign) {
+	krypt_compute_twos_complement(numbytes, numbytes, numlen);
+    } else if (numbytes[0] & 0x80) {
+	uint8_t *normalized = ALLOC_N(uint8_t, numlen + 1);
+	normalized[0] = 0x0;
+	memcpy(normalized + 1, numbytes, numlen);
+	xfree(numbytes);
+	numlen++;
+	numbytes = normalized;
+    }
+
+    if (free_hex) xfree(hexstrbytes);
+    *out = numbytes;
+    *outlen = numlen;
+    return KRYPT_OK;
+}
+#endif
+
+#ifdef HAVE_RB_BIG_PACK
+int
+krypt_asn1_decode_bignum(uint8_t *bytes, size_t len, VALUE *out)
+{
+    long num_longs;
+    int i, j, pos, sign;
+    unsigned long *longs;
+    long l;
+    VALUE value;
+
+    sign = bytes[0] & 0x80;
+    num_longs = (len - 1) / SIZEOF_LONG + 1;
+    longs = ALLOC_N(unsigned long, num_longs);
+    for (i = 0; i < num_longs; ++i) {
+	l = 0;
+	for (j = 0; j < SIZEOF_LONG; ++j) {
+	    pos = len - i * SIZEOF_LONG - j - 1;
+	    if (pos >= 0) {
+		l += ((long)(bytes[pos] & 0xff) << (j * CHAR_BIT));
+	    }
+	    else if (sign) {
+		l |= ((long)0xff << (j * CHAR_BIT));
+	    }
+	}
+	longs[i] = l;
+    }
+    value = rb_big_unpack(longs, num_longs);
+    if (TYPE(value) == T_BIGNUM) {
+	RBIGNUM_SET_SIGN(value, !sign);
+    }
+    xfree(longs);
+    *out = value;
+    return KRYPT_OK;
+}
+#else
+int krypt_asn1_decode_bignum(uint8_t *bytes, size_t len, VALUE *out)
+{
+    int sign;
+    size_t hexlen;
+    uint8_t *absolute;
+    int free_abs = 0;
+    char *hexnum;
+    char *chexnum;
+
+    sign = bytes[0] & 0x80;
+    if (sign) {
+	absolute = ALLOC_N(uint8_t, len); 
+	krypt_compute_twos_complement(absolute, bytes, len);
+	free_abs = 1;
+    } else {
+	absolute = bytes;
+	if (absolute[0] == 0x0) {
+	    absolute++;
+	    len--;
+	}
+    }
+
+    if (krypt_hex_encode(absolute, len, &hexnum, &hexlen) == KRYPT_ERR) {
+	if (free_abs) xfree(absolute);
+	return KRYPT_ERR;
+    }
+    
+    if (sign) {
+	chexnum = ALLOC_N(char, hexlen + 2);
+	chexnum[0] = '-';
+	memcpy(chexnum + 1, hexnum, hexlen);
+	chexnum[hexlen + 1] = '\0';
+    } else {
+	chexnum = ALLOC_N(char, hexlen + 1);
+	memcpy(chexnum, hexnum, hexlen);
+	chexnum[hexlen] = '\0';
+    }
+
+    *out = rb_cstr2inum(chexnum, 16);
+    if (free_abs) xfree(absolute);
+    xfree(hexnum);
+    xfree(chexnum);
+    return KRYPT_OK;
+}
+#endif
+

data/ext/krypt/core/krypt_missing.h

@@ -0,0 +1,62 @@
+/*
+ * krypt-core API - C implementation
+ *
+ * Copyright (c) 2011-2013
+ * Hiroshi Nakamura <nahi@ruby-lang.org>
+ * Martin Bosslet <martin.bosslet@gmail.com>
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _KRYPT_MISSING_H_
+#define _KRYPT_MISSING_H_
+
+#include RUBY_EXTCONF_H
+
+#ifndef HAVE_RB_ENUMERATORIZE
+#define KRYPT_RETURN_ENUMERATOR(enumerable, id)						\
+do {											\
+    if (!rb_block_given_p())								\
+    	return rb_funcall((enumerable), rb_intern("enum_for"), 1, ID2SYM((id)));	\
+} while (0) 
+#else
+#define KRYPT_RETURN_ENUMERATOR(enumerable, id)						\
+do {											\
+    if(!rb_block_given_p())								\
+    	RETURN_ENUMERATOR((enumerable), 0, 0);						\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_STR_ENCODE
+VALUE rb_str_encode(VALUE str, VALUE to, int ecflags, VALUE ecopts);
+#endif
+
+#ifndef HAVE_GMTIME_R
+#include <time.h>
+struct tm *krypt_gmtime_r(const time_t *tp, struct tm *result);
+#define gmtime_r(t, tm)				krypt_gmtime_r((t), (tm))
+#endif
+
+int krypt_asn1_encode_bignum(VALUE bignum, uint8_t **out, size_t *len);
+int krypt_asn1_decode_bignum(uint8_t *bytes, size_t len, VALUE *out);
+
+#endif /* KRYPT_MISSING_H */
+