aboutsummaryrefslogtreecommitdiffstats
path: root/misc
diff options
context:
space:
mode:
authorlloyd <[email protected]>2006-09-02 00:18:00 +0000
committerlloyd <[email protected]>2006-09-02 00:18:00 +0000
commit66f811e3807811b915a1b4209b2fc0f6e8b0890c (patch)
tree35152ce8dc01d055571b0969a3e530d83f9b4625 /misc
parentbfdc18f249d1341579aad71e2764cff49de42daa (diff)
parent69ea090a366cbdf8a5c3ef30f95fd0d9923ac110 (diff)
merge of '2e51bbe4473463af7f2603deb7c12a332a7e1ae6'
and '94c8c963566255088b729b3c2cc7fe788f474945'
Diffstat (limited to 'misc')
-rw-r--r--misc/python/src/algos.cpp197
-rw-r--r--misc/python/src/core.cpp9
-rwxr-xr-xmisc/python/test.py35
3 files changed, 210 insertions, 31 deletions
diff --git a/misc/python/src/algos.cpp b/misc/python/src/algos.cpp
new file mode 100644
index 000000000..ed00c99d9
--- /dev/null
+++ b/misc/python/src/algos.cpp
@@ -0,0 +1,197 @@
+/*************************************************
+* Boost.Python module definition *
+* (C) 1999-2006 The Botan Project *
+*************************************************/
+
+#include <botan/botan.h>
+using namespace Botan;
+
+#include <boost/python.hpp>
+namespace python = boost::python;
+
+/* Encrypt or decrypt */
+std::string process(const std::string& in, BlockCipher* cipher,
+ void (BlockCipher::* proc)(const byte[], byte[]) const)
+ {
+ if(in.size() != cipher->BLOCK_SIZE)
+ throw Invalid_Argument("Input for cipher " + cipher->name() +
+ " must be " + to_string(cipher->BLOCK_SIZE) +
+ " bytes");
+
+ const byte* in_data = (const byte*)in.data();
+
+ SecureVector<byte> out(cipher->BLOCK_SIZE);
+ (cipher->*proc)(in_data, out);
+
+ return std::string((const char*)out.begin(), out.size());
+ }
+
+class Py_BlockCipher
+ {
+ public:
+ u32bit block_size() const { return cipher->BLOCK_SIZE; }
+ u32bit keylength_min() const { return cipher->MINIMUM_KEYLENGTH; }
+ u32bit keylength_max() const { return cipher->MAXIMUM_KEYLENGTH; }
+ u32bit keylength_mod() const { return cipher->KEYLENGTH_MULTIPLE; }
+
+ bool valid_keylength(u32bit kl) const
+ {
+ return cipher->valid_keylength(kl);
+ }
+
+ std::string name() const { return cipher->name(); }
+ void clear() throw() { cipher->clear(); }
+
+ std::string encrypt(const std::string& in) const
+ {
+ return process(in, cipher, &BlockCipher::encrypt);
+ }
+ std::string decrypt(const std::string& in) const
+ {
+ return process(in, cipher, &BlockCipher::decrypt);
+ }
+
+ void set_key(const OctetString& key) { cipher->set_key(key); }
+
+ Py_BlockCipher(const std::string& name)
+ {
+ cipher = get_block_cipher(name);
+ }
+ ~Py_BlockCipher() { delete cipher; }
+ private:
+ BlockCipher* cipher;
+ };
+
+class Py_StreamCipher
+ {
+ public:
+ u32bit keylength_min() const { return cipher->MINIMUM_KEYLENGTH; }
+ u32bit keylength_max() const { return cipher->MAXIMUM_KEYLENGTH; }
+ u32bit keylength_mod() const { return cipher->KEYLENGTH_MULTIPLE; }
+
+ void set_key(const OctetString& key) { cipher->set_key(key); }
+ bool valid_keylength(u32bit kl) const
+ {
+ return cipher->valid_keylength(kl);
+ }
+
+ std::string name() const { return cipher->name(); }
+ void clear() throw() { cipher->clear(); }
+
+ std::string crypt(const std::string& in) const
+ {
+ SecureVector<byte> out(in.size());
+ cipher->encrypt((const byte*)in.data(), out.begin(), in.size());
+ return std::string((const char*)out.begin(), out.size());
+ }
+
+ Py_StreamCipher(const std::string& name)
+ {
+ cipher = get_stream_cipher(name);
+ }
+ ~Py_StreamCipher() { delete cipher; }
+ private:
+ StreamCipher* cipher;
+ };
+
+class Py_HashFunction
+ {
+ public:
+ u32bit output_length() const { return hash->OUTPUT_LENGTH; }
+ std::string name() const { return hash->name(); }
+ void clear() throw() { hash->clear(); }
+
+ void update(const std::string& in) { hash->update(in); }
+
+ std::string final()
+ {
+ SecureVector<byte> result = hash->final();
+ return std::string((const char*)result.begin(), result.size());
+ }
+
+ Py_HashFunction(const std::string& name)
+ {
+ hash = get_hash(name);
+ }
+ ~Py_HashFunction() { delete hash; }
+ private:
+ HashFunction* hash;
+ };
+
+class Py_MAC
+ {
+ public:
+ u32bit output_length() const { return mac->OUTPUT_LENGTH; }
+ u32bit keylength_min() const { return mac->MINIMUM_KEYLENGTH; }
+ u32bit keylength_max() const { return mac->MAXIMUM_KEYLENGTH; }
+ u32bit keylength_mod() const { return mac->KEYLENGTH_MULTIPLE; }
+ std::string name() const { return mac->name(); }
+ void clear() throw() { mac->clear(); }
+
+ void set_key(const OctetString& key) { mac->set_key(key); }
+
+ bool valid_keylength(u32bit kl) const
+ {
+ return mac->valid_keylength(kl);
+ }
+
+ void update(const std::string& in) { mac->update(in); }
+
+ std::string final()
+ {
+ SecureVector<byte> result = mac->final();
+ return std::string((const char*)result.begin(), result.size());
+ }
+
+ Py_MAC(const std::string& name)
+ {
+ mac = get_mac(name);
+ }
+ ~Py_MAC() { delete mac; }
+ private:
+ MessageAuthenticationCode* mac;
+ };
+
+void export_basic_algos()
+ {
+ python::class_<Py_BlockCipher>("BlockCipher", python::init<std::string>())
+ .add_property("block_size", &Py_BlockCipher::block_size)
+ .add_property("keylength_min", &Py_BlockCipher::keylength_min)
+ .add_property("keylength_max", &Py_BlockCipher::keylength_max)
+ .add_property("keylength_mod", &Py_BlockCipher::keylength_mod)
+ .add_property("name", &Py_BlockCipher::name)
+ .def("clear", &Py_BlockCipher::clear)
+ .def("valid_keylength", &Py_BlockCipher::valid_keylength)
+ .def("set_key", &Py_BlockCipher::set_key)
+ .def("encrypt", &Py_BlockCipher::encrypt)
+ .def("decrypt", &Py_BlockCipher::decrypt);
+
+ python::class_<Py_StreamCipher>("StreamCipher", python::init<std::string>())
+ .add_property("keylength_min", &Py_StreamCipher::keylength_min)
+ .add_property("keylength_max", &Py_StreamCipher::keylength_max)
+ .add_property("keylength_mod", &Py_StreamCipher::keylength_mod)
+ .add_property("name", &Py_StreamCipher::name)
+ .def("clear", &Py_StreamCipher::clear)
+ .def("valid_keylength", &Py_StreamCipher::valid_keylength)
+ .def("set_key", &Py_StreamCipher::set_key)
+ .def("crypt", &Py_StreamCipher::crypt);
+
+ python::class_<Py_HashFunction>("HashFunction", python::init<std::string>())
+ .add_property("output_length", &Py_HashFunction::output_length)
+ .add_property("name", &Py_HashFunction::name)
+ .def("clear", &Py_HashFunction::clear)
+ .def("update", &Py_HashFunction::update)
+ .def("final", &Py_HashFunction::final);
+
+ python::class_<Py_MAC>("MAC", python::init<std::string>())
+ .add_property("output_length", &Py_MAC::output_length)
+ .add_property("keylength_min", &Py_MAC::keylength_min)
+ .add_property("keylength_max", &Py_MAC::keylength_max)
+ .add_property("keylength_mod", &Py_MAC::keylength_mod)
+ .add_property("name", &Py_MAC::name)
+ .def("valid_keylength", &Py_MAC::valid_keylength)
+ .def("set_key", &Py_MAC::set_key)
+ .def("clear", &Py_MAC::clear)
+ .def("update", &Py_MAC::update)
+ .def("final", &Py_MAC::final);
+ }
diff --git a/misc/python/src/core.cpp b/misc/python/src/core.cpp
index 07252e720..649b48a88 100644
--- a/misc/python/src/core.cpp
+++ b/misc/python/src/core.cpp
@@ -3,14 +3,15 @@
* (C) 1999-2006 The Botan Project *
*************************************************/
-#include <botan/init.h>
-#include <botan/symkey.h>
+#include <botan/botan.h>
using namespace Botan;
#include <boost/python.hpp>
namespace python = boost::python;
+extern void export_basic_algos();
extern void export_filters();
+extern void export_pk();
extern void export_x509();
BOOST_PYTHON_MODULE(_botan)
@@ -22,12 +23,14 @@ BOOST_PYTHON_MODULE(_botan)
.def(python::init< python::optional<std::string> >())
.def(python::init< u32bit >())
.def("__str__", &OctetString::as_string)
- .add_property("length", &OctetString::length);
+ .def("__len__", &OctetString::length);
python::enum_<Cipher_Dir>("cipher_dir")
.value("encryption", ENCRYPTION)
.value("decryption", DECRYPTION);
+ export_basic_algos();
export_filters();
+ export_pk();
export_x509();
}
diff --git a/misc/python/test.py b/misc/python/test.py
index 9896777d4..20c2a9119 100755
--- a/misc/python/test.py
+++ b/misc/python/test.py
@@ -2,36 +2,15 @@
import sys, botan
-def encrypt(input):
- cipher_key = botan.SymmetricKey("AABB")
- print cipher_key.length
- cipher_key = botan.SymmetricKey("AABBCCDD")
- print cipher_key.length
-
- cipher = botan.Filter("ARC4", key = cipher_key)
-
- pipe = botan.Pipe(cipher, botan.Filter("Hex_Encoder"))
-
- pipe.start_msg()
- pipe.write(input)
- pipe.end_msg()
-
- str = pipe.read_all()
- print str
- return str
-
-def decrypt(input):
- pipe = botan.Pipe(botan.Filter("Hex_Decoder"),
- botan.Filter("ARC4",
- key = botan.SymmetricKey("AABBCCDD")))
-
- pipe.process_msg(input)
- return pipe.read_all()
+class PyAlgo(botan.Algorithm):
+ def name(self):
+ return "PyAlgo"
+ def clear(self):
+ print "clearing"
def main():
- ciphertext = encrypt("hi chappy")
- print ciphertext
- print decrypt(ciphertext)
+ alg = PyAlgo()
+ botan.print_algo(alg)
if __name__ == "__main__":
sys.exit(main())