krypt-core 0.0.1

data/ext/krypt/core/krypt_digest.c

@@ -0,0 +1,391 @@
+/*
+ * 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"
+
+VALUE mKryptDigest;
+VALUE eKryptDigestError;
+
+VALUE cKryptNativeDigest;
+
+/** public internal digest API **/
+
+#define int_check_provider_has(p, m) 		if (!(p) || !(p)->m) return NULL;
+#define int_check_digest_has(d, m) 		if (!(d) || !(d)->methods || !(d)->methods->m) return KRYPT_ERR;
+
+krypt_md *
+krypt_md_oid_new(krypt_provider *provider, const char *oid)
+{
+    int_check_provider_has(provider, md_new_oid);
+    return provider->md_new_oid(provider, oid);
+}
+
+krypt_md *
+krypt_md_name_new(krypt_provider *provider, const char *name)
+{
+    int_check_provider_has(provider, md_new_name);
+    return provider->md_new_name(provider, name);
+}
+
+krypt_md *
+krypt_md_new(krypt_provider *provider, const char *name_or_oid)
+{
+    krypt_md *ret = NULL;
+    if ((ret = krypt_md_name_new(provider, name_or_oid)))
+	return ret;
+    return krypt_md_oid_new(provider, name_or_oid);
+}
+
+int
+krypt_md_reset(krypt_md *md)
+{
+    int_check_digest_has(md, md_reset);
+    return md->methods->md_reset(md);
+}
+
+int
+krypt_md_update(krypt_md *md, const void *data, size_t len)
+{
+    int_check_digest_has(md, md_update);
+    return md->methods->md_update(md, data, len);
+}
+
+int
+krypt_md_final(krypt_md *md, uint8_t **digest, size_t *len)
+{
+    int_check_digest_has(md, md_final);
+    if (md->methods->md_final(md, digest, len) == KRYPT_ERR) return KRYPT_ERR;
+    return krypt_md_reset(md);
+}
+
+int
+krypt_md_digest(krypt_md *md, const uint8_t *data, size_t len, uint8_t **digest, size_t *digest_len)
+{
+    int_check_digest_has(md, md_digest);
+    if(md->methods->md_digest(md, data, len, digest, digest_len) == KRYPT_ERR) return KRYPT_ERR;
+    return krypt_md_reset(md);
+}
+
+int
+krypt_md_digest_length(krypt_md *md, size_t *len)
+{
+    int_check_digest_has(md, md_digest_length);
+    return md->methods->md_digest_length(md, len);
+}
+
+int
+krypt_md_block_length(krypt_md *md, size_t *len)
+{
+    int_check_digest_has(md, md_block_length);
+    return md->methods->md_block_length(md, len);
+}
+
+int
+krypt_md_name(krypt_md *md, const char **name)
+{
+    int_check_digest_has(md, md_name);
+    return md->methods->md_name(md, name);
+}
+
+void
+krypt_md_mark(krypt_md *md)
+{
+    if (!md) return; 
+    if (md->methods->mark)
+	md->methods->mark(md);
+}
+
+void
+krypt_md_free(krypt_md *md)
+{
+    if (!md) return; 
+    md->methods->free(md);
+}
+
+/** Digest class implementation **/
+
+VALUE
+krypt_digest_new(krypt_md *md)
+{
+    VALUE obj;
+
+    obj = Data_Wrap_Struct(cKryptNativeDigest, krypt_md_mark, krypt_md_free, md);
+    return obj;
+}
+
+#define int_md_get(obj, md)					\
+do { 								\
+    Data_Get_Struct((obj), krypt_md, (md));			\
+    if (!(md)) { 						\
+	rb_raise(eKryptError, "Uninitialized krypt_md");	\
+    } 								\
+} while (0)
+
+/*
+ *  call-seq:
+ *     digest.reset -> self
+ *
+ * Resets the Digest in the sense that any Digest#update that has been
+ * performed is abandoned and the Digest is set to its initial state again.
+ *
+ */
+static VALUE
+krypt_digest_reset(VALUE self)
+{
+    krypt_md *md;
+
+    int_md_get(self, md);
+    if (krypt_md_reset(md) == KRYPT_ERR) {
+	rb_raise(eKryptDigestError, "Error while resetting digest");
+    }
+    return self;
+}
+
+/*
+ *  call-seq:
+ *     digest.update(string) -> aString
+ *
+ * Not every message digest can be computed in one single pass. If a message
+ * digest is to be computed from several subsequent sources, then each may
+ * be passed individually to the Digest instance.
+ *
+ * === Example
+ *   digest = Krypt::Digest::SHA256.new
+ *   digest.update('First input')
+ *   digest << 'Second input' # equivalent to digest.update('Second input')
+ *   result = digest.digest
+ *
+ */
+static VALUE
+krypt_digest_update(VALUE self, VALUE data)
+{
+    krypt_md *md;
+    uint8_t *bytes;
+    size_t len;
+
+    int_md_get(self, md);
+    StringValue(data);
+    bytes = (uint8_t *) RSTRING_PTR(data);
+    len = (size_t) RSTRING_LEN(data);
+    if (krypt_md_update(md, bytes, len) == KRYPT_ERR) {
+	rb_raise(eKryptDigestError, "Error while updating digest");
+    }
+    return self;
+}
+
+static VALUE
+int_digest_data(krypt_md *md, VALUE data)
+{
+    uint8_t *bytes;
+    size_t len;
+    uint8_t *digest;
+    size_t digest_len;
+    VALUE ret;
+
+    StringValue(data);
+    bytes = (uint8_t *) RSTRING_PTR(data);
+    len = (size_t) RSTRING_LEN(data);
+    if (krypt_md_digest(md, bytes, len, &digest, &digest_len) == KRYPT_ERR) {
+	rb_raise(eKryptDigestError, "Error while computing digest");
+    }
+    ret = rb_str_new((const char *) digest, digest_len);
+    xfree(digest);
+    return ret;
+}
+
+static VALUE
+int_digest_final(krypt_md *md)
+{
+    uint8_t *digest;
+    size_t len;
+    VALUE ret;
+    if (krypt_md_final(md, &digest, &len) == KRYPT_ERR) {
+	rb_raise(eKryptDigestError, "Error while finalizing digest");
+    }
+    ret = rb_str_new((const char *) digest, len);
+    xfree(digest);
+    return ret;
+}
+
+/*
+ *  call-seq:
+ *     digest.digest([string]) -> String
+ *
+ * When called with no arguments, the result will be the hash of the data that
+ * has been fed to this Digest instance so far. If called with a String
+ * argument, the hash of that argument will be computed.
+ *
+ * === Example
+ *   digest = Krypt::Digest::SHA256.new
+ *   result = digest.digest('First input')
+ *
+ * is equivalent to
+ *   
+ *   digest = Krypt::Digest::SHA256.new
+ *   digest << 'First input' # equivalent to digest.update('Second input')
+ *   result = digest.digest
+ *
+ */
+static VALUE
+krypt_digest_digest(int argc, VALUE *args, VALUE self)
+{
+    krypt_md *md;
+    VALUE data;
+
+    rb_scan_args(argc, args, "01", &data);
+    int_md_get(self, md);
+    if (!(NIL_P(data)))
+	return int_digest_data(md, data);
+    else
+	return int_digest_final(md);
+}
+
+/*
+ *  call-seq:
+ *     digest.hexdigest([string]) -> String
+ *
+ * Works the with the same semantics as Digest#digest with the difference that
+ * instead of the raw bytes the hex-encoded form of the raw representation is
+ * returned.
+ */
+static VALUE
+krypt_digest_hexdigest(int argc, VALUE *args, VALUE self)
+{
+    VALUE digest, ret;
+    uint8_t *bytes;
+    size_t len;
+
+    digest = krypt_digest_digest(argc, args, self);
+    if (krypt_hex_encode((uint8_t *) RSTRING_PTR(digest), RSTRING_LEN(digest), &bytes, &len) == KRYPT_ERR)
+	rb_raise(eKryptDigestError, "Error while hex-encoding digest");
+    ret = rb_str_new((const char *) bytes, len);
+    xfree(bytes);
+    return ret;
+}
+
+/*
+ *  call-seq:
+ *      digest.digest_length -> integer
+ *
+ * Returns the output size of the digest, i.e. the length in bytes of the
+ * final message digest result.
+ *
+ * === Example
+ *   digest = Krypt::Digest::SHA1.new
+ *   puts digest.digest_length # => 20
+ *
+ */
+static VALUE
+krypt_digest_digest_length(VALUE self)
+{
+    krypt_md *md;
+    size_t len;
+
+    int_md_get(self, md);
+    if (krypt_md_digest_length(md, &len) == KRYPT_ERR) {
+	rb_raise(eKryptDigestError, "Error while getting digest length");
+    }
+    return INT2NUM(len);
+}
+
+/*
+ *  call-seq:
+ *      digest.block_length -> integer
+ *
+ * Returns the block length of the digest algorithm, i.e. the length in bytes
+ * of an individual block. Most modern algorithms partition a message to be
+ * digested into a sequence of fix-sized blocks that are processed
+ * consecutively.
+ *
+ * === Example
+ *   digest = Krypt::Digest::SHA1.new
+ *   puts digest.block_length # => 64
+ */
+static VALUE
+krypt_digest_block_length(VALUE self)
+{
+    krypt_md *md;
+    size_t len;
+
+    int_md_get(self, md);
+    if (krypt_md_block_length(md, &len) == KRYPT_ERR) {
+	rb_raise(eKryptDigestError, "Error while getting digest block length");
+    }
+    return INT2NUM(len);
+}
+
+/*
+ *  call-seq:
+ *      digest.name -> string
+ *
+ * Returns the sn of this Digest instance.
+ *
+ * === Example
+ *   digest = Krypt::Digest::SHA512.new
+ *   puts digest.name # => SHA512
+ *
+ */
+static VALUE
+krypt_digest_name(VALUE self)
+{
+    krypt_md *md;
+    const char *name;
+
+    int_md_get(self, md);
+    if (krypt_md_name(md, &name) == KRYPT_ERR) {
+	rb_raise(eKryptDigestError, "Error while getting digest name");
+    }
+    return rb_str_new2(name);
+}
+
+void
+Init_krypt_digest(void)
+{
+#if 0
+    mKrypt = rb_define_module("Krypt"); /* Let RDoc know */
+#endif
+
+    mKryptDigest = rb_path2class("Krypt::Digest");
+    eKryptDigestError = rb_path2class("Krypt::Digest::DigestError");
+
+    /* Document-class: Krypt::Digest::NativeDigest
+     * Native C implementation of the Krypt::Digest interface. 
+     */
+    cKryptNativeDigest = rb_define_class_under(mKryptDigest, "NativeDigest", rb_cObject);
+
+    rb_define_method(cKryptNativeDigest, "reset", krypt_digest_reset, 0);
+    rb_define_method(cKryptNativeDigest, "update", krypt_digest_update, 1);
+    rb_define_alias(cKryptNativeDigest, "<<", "update");
+    rb_define_method(cKryptNativeDigest, "digest", krypt_digest_digest, -1);
+    rb_define_method(cKryptNativeDigest, "hexdigest", krypt_digest_hexdigest, -1);
+    rb_define_method(cKryptNativeDigest, "digest_length", krypt_digest_digest_length, 0);
+    rb_define_method(cKryptNativeDigest, "block_length", krypt_digest_block_length, 0);
+    rb_define_method(cKryptNativeDigest, "name", krypt_digest_name, 0);
+    rb_undef_method(CLASS_OF(cKryptNativeDigest), "new"); /* private constructor */	
+}
+

data/ext/krypt/core/krypt_digest.h

@@ -0,0 +1,51 @@
+/*
+ * 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_DIGEST_H_
+#define _KRYPT_DIGEST_H_
+
+extern VALUE mKryptDigest;
+extern VALUE eKryptDigestError;
+
+extern VALUE cKryptNativeDigest;
+
+krypt_md *krypt_md_new(krypt_provider *provider, const char *name_or_oid);
+krypt_md *krypt_md_oid_new(krypt_provider *provider, const char *oid);
+krypt_md *krypt_md_name_new(krypt_provider *provider, const char *name);
+
+int krypt_md_update(krypt_md *md, const void *data, size_t len);
+int krypt_md_final(krypt_md *md, uint8_t **digest, size_t *len);
+int krypt_md_digest(krypt_md *md, const uint8_t *data, size_t len, uint8_t **digest, size_t *digest_len);
+void krypt_md_mark(krypt_md *md);
+void krypt_md_free(krypt_md *md);
+
+VALUE krypt_digest_new(krypt_md *md);
+
+void Init_krypt_digest(void);
+
+#endif /* _KRYPT_DIGEST_H_ */

data/ext/krypt/core/krypt_error.c

@@ -0,0 +1,221 @@
+/*
+ * 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"
+#include <stdarg.h>
+
+typedef struct krypt_err_stack_elem_st krypt_err_stack_elem;
+
+typedef struct krypt_err_stack_st {
+    int count;
+    krypt_err_stack_elem *head;
+} krypt_err_stack;
+
+struct krypt_err_stack_elem_st {
+    char *message;
+    size_t len;
+    krypt_err_stack_elem *prev;
+};
+
+static krypt_err_stack err_stack = { 0 };
+
+#define int_err_stack_empty()	(err_stack.count == 0)
+
+static void
+int_err_stack_push(char *message, size_t len)
+{
+    krypt_err_stack_elem *elem;
+
+    elem = ALLOC(krypt_err_stack_elem);
+    elem->message = message;
+    elem->len = len;
+    elem->prev = err_stack.head;
+    err_stack.head = elem;
+    err_stack.count++;
+}
+
+static char *
+int_err_stack_pop()
+{
+    char *message;
+    krypt_err_stack_elem *head = err_stack.head;
+
+    if (!head) return NULL;
+
+    err_stack.head = head->prev;
+    message = head->message;
+    xfree(head);
+    err_stack.count--;
+    return message;
+}
+
+int
+krypt_has_errors(void)
+{
+    return !int_err_stack_empty();
+}
+
+int
+krypt_error_message(char *buf, int buf_len)
+{
+    krypt_err_stack_elem *head = err_stack.head;
+    int len = 0;
+
+    while (head) {
+	int cur_len;
+	char *message = head->message;
+	cur_len = snprintf(buf + len, buf_len, "%s%s", (len ? ": " : ""), message);
+	if (cur_len > 0)
+	    len += cur_len;
+	head = head->prev;
+    }
+
+    return len;
+}
+
+void
+krypt_error_add(const char *format, ...)
+{
+    char *buf;
+    int len = 0;
+    va_list args;
+
+    va_start(args, format);
+    buf = ALLOC_N(char, BUFSIZ);
+    if ((len = vsnprintf(buf, BUFSIZ, format, args)) < 0) return;
+    int_err_stack_push(buf, len);
+    va_end(args);
+}
+
+static int
+int_add_binyo_errors(char *buf, int len)
+{
+    int l = 0;
+
+    if (binyo_has_errors()) {
+	int cur_len;
+	if ((cur_len = snprintf(buf + l, len, "%s", ": ")) > 0)
+	    l += cur_len;
+       	if ((cur_len = binyo_error_message(buf + l, len)) > 0)
+	    l += cur_len;
+    }
+
+    return l;
+}
+
+static int
+int_error_msg_create(char *buf, int len, const char *format, va_list args)
+{
+    int l;
+
+    if ((l = vsnprintf(buf, len, format, args)) < 0) {
+	return -1;
+    }
+
+    while (!int_err_stack_empty()) {
+	int cur_len;
+	char *message = int_err_stack_pop();
+	cur_len = snprintf(buf + l, len, "%s%s", (l ? ": " : ""), message);
+	xfree(message);
+	if (cur_len > 0)
+	    l += cur_len;
+    }
+
+    l += int_add_binyo_errors(buf + l, len);
+    binyo_error_clear();
+
+    return l;
+}
+
+static VALUE
+int_error_create(VALUE exception_class, const char *format, va_list args)
+{
+    char buf[BUFSIZ];
+    int len = 0;
+
+    if ((len = int_error_msg_create(buf, BUFSIZ, format, args)) < 0) {
+	return rb_funcall(exception_class, rb_intern("new"), 0);
+    }
+
+    return rb_exc_new(exception_class, buf, len);
+}
+
+static VALUE
+int_error_enhance(VALUE exception_class, VALUE active_exc, const char *format, va_list args)
+{
+    char buf[BUFSIZ];
+    int len;
+    VALUE orig_msg;
+    long orig_len;
+    const char *active_name = rb_class2name(CLASS_OF(active_exc));
+    size_t active_name_len = strlen(active_name);
+
+    if ((len = int_error_msg_create(buf, BUFSIZ, format, args)) < 0) {
+	return active_exc;
+    }
+
+    orig_msg = rb_funcall(active_exc, rb_intern("message"), 0);
+    StringValueCStr(orig_msg);
+    orig_len = RSTRING_LEN(orig_msg);
+    if (len <= BUFSIZ - ( (int) active_name_len ) - orig_len - 4) {
+	strcat(buf, ": ");
+	strcat(buf, active_name);
+	strcat(buf, ": ");
+	strcat(buf, RSTRING_PTR(orig_msg));
+	len += active_name_len + orig_len + 4;
+    }
+
+    return rb_exc_new(exception_class, buf, len);
+}
+
+void
+krypt_error_raise(VALUE exception_class, const char *format, ...)
+{
+    VALUE exc;
+    VALUE active_exc;
+    va_list args;
+
+    va_start(args, format);
+    active_exc = rb_errinfo();
+    if (NIL_P(active_exc)) {
+	exc = int_error_create(exception_class, format, args);
+    } else {
+	exc = int_error_enhance(exception_class, active_exc, format, args);
+    }
+    va_end(args);
+    rb_exc_raise(exc);
+}
+
+void
+krypt_error_clear(void)
+{
+    while (!int_err_stack_empty()) {
+	xfree(int_err_stack_pop());
+    }
+}
+

data/ext/krypt/core/krypt_error.h

@@ -0,0 +1,46 @@
+/*
+ * 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_ERROR_H_
+#define _KRYPT_ERROR_H_
+
+#define KRYPT_OK 1
+#define KRYPT_ERR -1
+
+#define KRYPT_ASN1_EOF -2
+
+void krypt_error_add(const char *format, ...);
+
+int krypt_has_errors(void);
+int krypt_error_message(char *buf, int buf_len);
+VALUE krypt_error_create(VALUE exception_class, const char *format, ...);
+void krypt_error_raise(VALUE exception_class, const char *format, ...);
+void krypt_error_clear(void);
+
+#endif /* KRYPT_ERROR_H */
+