aboutsummaryrefslogtreecommitdiffstats
path: root/wrappers/boost-python/src/hash.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'wrappers/boost-python/src/hash.cpp')
-rw-r--r--wrappers/boost-python/src/hash.cpp108
1 files changed, 108 insertions, 0 deletions
diff --git a/wrappers/boost-python/src/hash.cpp b/wrappers/boost-python/src/hash.cpp
new file mode 100644
index 000000000..69c107c32
--- /dev/null
+++ b/wrappers/boost-python/src/hash.cpp
@@ -0,0 +1,108 @@
+/*************************************************
+* Boost.Python module definition *
+* (C) 1999-2007 Jack Lloyd *
+*************************************************/
+
+#include <botan/botan.h>
+using namespace Botan;
+
+#include "common.h"
+
+class Py_HashFunction : public HashFunction
+ {
+ public:
+ virtual void hash_str(const std::string&) = 0;
+ virtual std::string final_str() = 0;
+
+ void clear() throw() {}
+
+ void add_data(const byte input[], u32bit length)
+ {
+ hash_str(make_string(input, length));
+ }
+
+ void final_result(byte output[])
+ {
+ string2binary(final_str(), output, OUTPUT_LENGTH);
+ }
+
+ Py_HashFunction(u32bit digest_size, u32bit block_size) :
+ HashFunction(digest_size, block_size) {}
+ };
+
+class Wrapped_HashFunction : public HashFunction
+ {
+ public:
+ void add_data(const byte in[], u32bit len) { hash->update(in, len); }
+ void final_result(byte out[]) { hash->final(out); }
+
+ void clear() throw() {}
+
+ std::string name() const { return hash->name(); }
+ HashFunction* clone() const { return hash->clone(); }
+
+ Wrapped_HashFunction(python::object py_obj, HashFunction* h) :
+ HashFunction(h->OUTPUT_LENGTH, h->HASH_BLOCK_SIZE),
+ obj(py_obj), hash(h) {}
+ private:
+ python::object obj;
+ HashFunction* hash;
+ };
+
+class Py_HashFunction_Wrapper : public Py_HashFunction,
+ public python::wrapper<Py_HashFunction>
+ {
+ public:
+ HashFunction* clone() const
+ {
+ python::object self = get_owner(this);
+ python::object py_clone = self.attr("__class__")();
+ HashFunction* hf = python::extract<HashFunction*>(py_clone);
+ return new Wrapped_HashFunction(py_clone, hf);
+ }
+
+ std::string name() const
+ {
+ return this->get_override("name")();
+ }
+
+ void hash_str(const std::string& in)
+ {
+ this->get_override("update")(in);
+ }
+
+ std::string final_str()
+ {
+ return this->get_override("final")();
+ }
+
+ Py_HashFunction_Wrapper(u32bit digest_size, u32bit block_size) :
+ Py_HashFunction(digest_size, block_size) {}
+ };
+
+std::string final_str(HashFunction* hash)
+ {
+ SecureVector<byte> digest = hash->final();
+ return std::string((const char*)digest.begin(), digest.size());
+ }
+
+void export_hash_functions()
+ {
+ void (HashFunction::*update_str)(const std::string&) =
+ &HashFunction::update;
+
+ python::class_<HashFunction, boost::noncopyable>
+ ("HashFunction", python::no_init)
+ .def("__init__", python::make_constructor(get_hash))
+ .def_readonly("digest_size", &HashFunction::OUTPUT_LENGTH)
+ .def("name", &HashFunction::name)
+ .def("update", update_str)
+ .def("final", final_str);
+
+ python::class_<Py_HashFunction_Wrapper, python::bases<HashFunction>,
+ boost::noncopyable>
+ ("HashFunctionImpl", python::init<u32bit, u32bit>())
+ .def("name", python::pure_virtual(&Py_HashFunction::name))
+ .def("update", python::pure_virtual(&Py_HashFunction::hash_str))
+ .def("final", python::pure_virtual(&Py_HashFunction::final_str));
+ }