diff options
166 files changed, 4507 insertions, 1581 deletions
diff --git a/.mtn-ignore b/.mtn-ignore index 2cac84769..8be5a95a8 100644 --- a/.mtn-ignore +++ b/.mtn-ignore @@ -13,6 +13,7 @@ callgrind.out.* ^doc/doxygen$ ^doc/[a-z]+\.(pdf|log|toc)$ ^doc/examples/.*\.pem$ +^doc/examples/[a-z0-9_]+$ ^src/wrap/perl-xs/Botan.(bs|c)$ ^src/wrap/perl-xs/Makefile(\.old)?$ ^src/wrap/perl-xs/.*blib$ diff --git a/Attic/mutex/pthreads/mux_pthr.cpp b/Attic/mutex/pthreads/mux_pthr.cpp index 75a116fe8..165132239 100644 --- a/Attic/mutex/pthreads/mux_pthr.cpp +++ b/Attic/mutex/pthreads/mux_pthr.cpp @@ -28,19 +28,19 @@ Mutex* Pthread_Mutex_Factory::make() void lock() { if(pthread_mutex_lock(&mutex) != 0) - throw Exception("Pthread_Mutex::lock: Error occured"); + throw Invalid_State("Pthread_Mutex::lock: Error occured"); } void unlock() { if(pthread_mutex_unlock(&mutex) != 0) - throw Exception("Pthread_Mutex::unlock: Error occured"); + throw Invalid_State("Pthread_Mutex::unlock: Error occured"); } Pthread_Mutex() { if(pthread_mutex_init(&mutex, 0) != 0) - throw Exception("Pthread_Mutex: initialization failed"); + throw Invalid_State("Pthread_Mutex: initialization failed"); } ~Pthread_Mutex() diff --git a/checks/bench.cpp b/checks/bench.cpp index df346ec75..9b917c99d 100644 --- a/checks/bench.cpp +++ b/checks/bench.cpp @@ -1,3 +1,8 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ #include <iostream> #include <iomanip> @@ -33,8 +38,6 @@ const std::string algos[] = { "GOST", "IDEA", "KASUMI", - "Lion(SHA-256,Turing,8192)", - "Luby-Rackoff(SHA-512)", "MARS", "MISTY1", "Noekeon", @@ -52,6 +55,11 @@ const std::string algos[] = { "Twofish", "XTEA", + /* Cipher constructions */ + "Cascade(Serpent,AES-128)", + "Lion(SHA-256,Salsa20,8192)", + "Luby-Rackoff(SHA-512)", + /* Cipher modes */ "TripleDES/CBC/PKCS7", "TripleDES/CBC/CTS", diff --git a/checks/bigint.cpp b/checks/bigint.cpp index a56fd9181..86e37cd7b 100644 --- a/checks/bigint.cpp +++ b/checks/bigint.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <vector> #include <string> #include <fstream> diff --git a/checks/block.cpp b/checks/block.cpp index 8f07cd65c..c90e3e499 100644 --- a/checks/block.cpp +++ b/checks/block.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + /* We don't use the standard issue ECB filter, because we also want to check @@ -83,7 +89,7 @@ void ECB_Encryption_ErrorCheck::end_msg() } if(position) - throw Exception("ECB: input was not in full blocks"); + throw Encoding_Error("ECB: input was not in full blocks"); } Filter* lookup_block(const std::string& algname, const std::string& key) diff --git a/checks/check.cpp b/checks/check.cpp index 975315608..03579b51a 100644 --- a/checks/check.cpp +++ b/checks/check.cpp @@ -1,4 +1,10 @@ /* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +/* * Test Driver for Botan */ diff --git a/checks/dolook.cpp b/checks/dolook.cpp index b64c5a5a3..28ac60c1b 100644 --- a/checks/dolook.cpp +++ b/checks/dolook.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <vector> #include <string> diff --git a/checks/ec_tests.cpp b/checks/ec_tests.cpp index 53fc12612..fdd333b1f 100644 --- a/checks/ec_tests.cpp +++ b/checks/ec_tests.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/build.h> #include "validate.h" diff --git a/checks/ecdsa.cpp b/checks/ecdsa.cpp index 37880b755..8991c8a6d 100644 --- a/checks/ecdsa.cpp +++ b/checks/ecdsa.cpp @@ -112,16 +112,8 @@ void test_hash_larger_than_n(RandomNumberGenerator& rng) // we make sure it doesn't fail because of the invalid signature, // but because of the Encoding_Error - bool ver_exc = false; - try - { - pk_verifier->verify_message(message, signature); - } - catch(Encoding_Error e) - { - ver_exc = true; - } - CHECK(ver_exc); + if(pk_verifier->verify_message(message, signature)) + std::cout << "Corrupt ECDSA signature verified, should not have\n"; } /** diff --git a/checks/getopt.cpp b/checks/getopt.cpp deleted file mode 100644 index c0145ca75..000000000 --- a/checks/getopt.cpp +++ /dev/null @@ -1,85 +0,0 @@ - -#include "getopt.h" - -#include <botan/parsing.h> -#include <botan/exceptn.h> - -OptionParser::OptionParser(const std::string& opt_string) - { - std::vector<std::string> opts = Botan::split_on(opt_string, '|'); - - for(size_t j = 0; j != opts.size(); j++) - flags.push_back(OptionFlag(opts[j])); - } - -OptionParser::OptionFlag -OptionParser::find_option(const std::string& name) const - { - for(size_t j = 0; j != flags.size(); j++) - if(flags[j].name() == name) - return flags[j]; - throw Botan::Exception("Unknown option " + name); - } - -bool OptionParser::is_set(const std::string& key) const - { - return (options.find(key) != options.end()); - } - -std::string OptionParser::value(const std::string& key) const - { - std::map<std::string, std::string>::const_iterator i = options.find(key); - if(i == options.end()) - throw Botan::Exception("Option " + key + " not found"); - return i->second; - } - -std::string OptionParser::value_if_set(const std::string& key) const - { - return is_set(key) ? value(key) : ""; - } - -void OptionParser::parse(char* argv[]) - { - std::vector<std::string> args; - for(int j = 1; argv[j]; j++) - args.push_back(argv[j]); - - for(size_t j = 0; j != args.size(); j++) - { - std::string arg = args[j]; - - if(arg.size() > 2 && arg[0] == '-' && arg[1] == '-') - { - const std::string opt_name = arg.substr(0, arg.find('=')); - - arg = arg.substr(2); - - std::string::size_type mark = arg.find('='); - - OptionFlag opt = find_option(arg.substr(0, mark)); - - if(opt.takes_arg()) - { - if(mark == std::string::npos) - throw Botan::Exception("Option " + opt_name + - " requires an argument"); - - std::string name = arg.substr(0, mark); - std::string value = arg.substr(mark+1); - - options[name] = value; - } - else - { - if(mark != std::string::npos) - throw Botan::Exception("Option " + opt_name + - " does not take an argument"); - - options[arg] = ""; - } - } - else - leftover.push_back(arg); - } - } diff --git a/checks/getopt.h b/checks/getopt.h index 6d6cfe89f..67cf979f9 100644 --- a/checks/getopt.h +++ b/checks/getopt.h @@ -1,22 +1,100 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ #ifndef BOTAN_CHECK_GETOPT_H__ #define BOTAN_CHECK_GETOPT_H__ #include <string> #include <vector> +#include <stdexcept> #include <map> +#include <botan/parsing.h> + class OptionParser { public: std::vector<std::string> leftovers() const { return leftover; } - bool is_set(const std::string&) const; - std::string value(const std::string&) const; - std::string value_if_set(const std::string&) const; + bool is_set(const std::string& key) const + { + return (options.find(key) != options.end()); + } + + std::string value(const std::string& key) const + { + std::map<std::string, std::string>::const_iterator i = options.find(key); + if(i == options.end()) + throw std::runtime_error("Option " + key + " not found"); + return i->second; + } + + std::string value_if_set(const std::string& key) const + { + return value_or_else(key, ""); + } + + std::string value_or_else(const std::string& key, + const std::string& or_else) const + { + return is_set(key) ? value(key) : or_else; + } + + void parse(char* argv[]) + { + std::vector<std::string> args; + for(int j = 1; argv[j]; j++) + args.push_back(argv[j]); + + for(size_t j = 0; j != args.size(); j++) + { + std::string arg = args[j]; + + if(arg.size() > 2 && arg[0] == '-' && arg[1] == '-') + { + const std::string opt_name = arg.substr(0, arg.find('=')); + + arg = arg.substr(2); + + std::string::size_type mark = arg.find('='); + OptionFlag opt = find_option(arg.substr(0, mark)); + + if(opt.takes_arg()) + { + if(mark == std::string::npos) + throw std::runtime_error("Option " + opt_name + + " requires an argument"); + + std::string name = arg.substr(0, mark); + std::string value = arg.substr(mark+1); + + options[name] = value; + } + else + { + if(mark != std::string::npos) + throw std::runtime_error("Option " + opt_name + + " does not take an argument"); + + options[arg] = ""; + } + } + else + leftover.push_back(arg); + } + } + + OptionParser(const std::string& opt_string) + { + std::vector<std::string> opts = Botan::split_on(opt_string, '|'); + + for(size_t j = 0; j != opts.size(); j++) + flags.push_back(OptionFlag(opts[j])); + } - void parse(char*[]); - OptionParser(const std::string&); private: class OptionFlag { @@ -35,7 +113,13 @@ class OptionParser bool opt_takes_arg; }; - OptionFlag find_option(const std::string&) const; + OptionFlag find_option(const std::string& name) const + { + for(size_t j = 0; j != flags.size(); j++) + if(flags[j].name() == name) + return flags[j]; + throw std::runtime_error("Unknown option " + name); + } std::vector<OptionFlag> flags; std::map<std::string, std::string> options; diff --git a/checks/misc.cpp b/checks/misc.cpp index a49778dc6..ff95ed10f 100644 --- a/checks/misc.cpp +++ b/checks/misc.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <iostream> #include <vector> #include <string> diff --git a/checks/pk.cpp b/checks/pk.cpp index e8746ad04..cb25c9212 100644 --- a/checks/pk.cpp +++ b/checks/pk.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <iostream> #include <fstream> #include <string> @@ -166,7 +172,7 @@ u32bit validate_rsa_enc_pkcs8(const std::string& algo, RandomNumberGenerator& rng) { if(str.size() != 4 && str.size() != 5) - throw Exception("Invalid input from pk_valid.dat"); + throw std::runtime_error("Invalid input from pk_valid.dat"); #if defined(BOTAN_HAS_RSA) @@ -204,7 +210,7 @@ u32bit validate_rsa_enc(const std::string& algo, RandomNumberGenerator& rng) { if(str.size() != 6) - throw Exception("Invalid input from pk_valid.dat"); + throw std::runtime_error("Invalid input from pk_valid.dat"); #if defined(BOTAN_HAS_RSA) @@ -232,7 +238,7 @@ u32bit validate_elg_enc(const std::string& algo, RandomNumberGenerator& rng) { if(str.size() != 6 && str.size() != 7) - throw Exception("Invalid input from pk_valid.dat"); + throw std::runtime_error("Invalid input from pk_valid.dat"); #if defined(BOTAN_HAS_ELGAMAL) @@ -264,7 +270,7 @@ u32bit validate_rsa_sig(const std::string& algo, RandomNumberGenerator& rng) { if(str.size() != 6) - throw Exception("Invalid input from pk_valid.dat"); + throw std::runtime_error("Invalid input from pk_valid.dat"); #if defined(BOTAN_HAS_RSA) @@ -290,7 +296,7 @@ u32bit validate_rsa_ver(const std::string& algo, const std::vector<std::string>& str) { if(str.size() != 5) /* is actually 4, parse() adds an extra empty one */ - throw Exception("Invalid input from pk_valid.dat"); + throw std::runtime_error("Invalid input from pk_valid.dat"); #if defined(BOTAN_HAS_RSA) RSA_PublicKey key(to_bigint(str[1]), to_bigint(str[0])); @@ -314,7 +320,7 @@ u32bit validate_rsa_ver_x509(const std::string& algo, const std::vector<std::string>& str) { if(str.size() != 5) /* is actually 3, parse() adds extra empty ones */ - throw Exception("Invalid input from pk_valid.dat"); + throw std::runtime_error("Invalid input from pk_valid.dat"); #if defined(BOTAN_HAS_RSA) DataSource_Memory keysource(reinterpret_cast<const byte*>(str[0].c_str()), @@ -346,7 +352,7 @@ u32bit validate_rw_ver(const std::string& algo, const std::vector<std::string>& str) { if(str.size() != 5) - throw Exception("Invalid input from pk_valid.dat"); + throw std::runtime_error("Invalid input from pk_valid.dat"); @@ -373,7 +379,7 @@ u32bit validate_rw_sig(const std::string& algo, RandomNumberGenerator& rng) { if(str.size() != 6) - throw Exception("Invalid input from pk_valid.dat"); + throw std::runtime_error("Invalid input from pk_valid.dat"); #if defined(BOTAN_HAS_RW) @@ -399,7 +405,7 @@ u32bit validate_dsa_sig(const std::string& algo, RandomNumberGenerator& rng) { if(str.size() != 4 && str.size() != 5) - throw Exception("Invalid input from pk_valid.dat"); + throw std::runtime_error("Invalid input from pk_valid.dat"); std::string pass; if(str.size() == 5) pass = str[4]; @@ -436,7 +442,7 @@ u32bit validate_dsa_ver(const std::string& algo, const std::vector<std::string>& str) { if(str.size() != 5) /* is actually 3, parse() adds extra empty ones */ - throw Exception("Invalid input from pk_valid.dat"); + throw std::runtime_error("Invalid input from pk_valid.dat"); DataSource_Memory keysource(reinterpret_cast<const byte*>(str[0].c_str()), str[0].length()); @@ -470,7 +476,7 @@ u32bit validate_nr_sig(const std::string& algo, RandomNumberGenerator& rng) { if(str.size() != 8) - throw Exception("Invalid input from pk_valid.dat"); + throw std::runtime_error("Invalid input from pk_valid.dat"); #if defined(BOTAN_HAS_NYBERG_RUEPPEL) @@ -497,7 +503,7 @@ u32bit validate_dh(const std::string& algo, RandomNumberGenerator& rng) { if(str.size() != 5 && str.size() != 6) - throw Exception("Invalid input from pk_valid.dat"); + throw std::runtime_error("Invalid input from pk_valid.dat"); #if defined(BOTAN_HAS_DIFFIE_HELLMAN) @@ -528,7 +534,7 @@ u32bit validate_dlies(const std::string& algo, RandomNumberGenerator& rng) { if(str.size() != 6) - throw Exception("Invalid input from pk_valid.dat"); + throw std::runtime_error("Invalid input from pk_valid.dat"); #if defined(BOTAN_HAS_DLIES) DL_Group domain(to_bigint(str[0]), to_bigint(str[1])); @@ -541,7 +547,7 @@ u32bit validate_dlies(const std::string& algo, std::vector<std::string> options = split_on(opt_str, '/'); if(options.size() != 3) - throw Exception("DLIES needs three options: " + opt_str); + throw std::runtime_error("DLIES needs three options: " + opt_str); MessageAuthenticationCode* mac = get_mac(options[1]); u32bit mac_key_len = to_u32bit(options[2]); diff --git a/checks/pk_bench.cpp b/checks/pk_bench.cpp index 72c5f53f6..4a70a5899 100644 --- a/checks/pk_bench.cpp +++ b/checks/pk_bench.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/pkcs8.h> #include <botan/mem_ops.h> #include <botan/look_pk.h> diff --git a/checks/timer.cpp b/checks/timer.cpp index aaea4b361..9f3d34607 100644 --- a/checks/timer.cpp +++ b/checks/timer.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include "timer.h" #include <chrono> #include <iomanip> diff --git a/checks/validate.cpp b/checks/validate.cpp index ff26e855a..9500589ca 100644 --- a/checks/validate.cpp +++ b/checks/validate.cpp @@ -1,4 +1,10 @@ /* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +/* Validation routines */ diff --git a/checks/validate.dat b/checks/validate.dat index 9d319eaf3..7d6b5b515 100644 --- a/checks/validate.dat +++ b/checks/validate.dat @@ -8123,6 +8123,16 @@ FFFFFFFFFFFFFFFF:651F3092AFA551D0:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 00000000000000000000000000000000:BA6933819299C71699A99F08F678178B:\ 00000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000\ +0000000000000000000000000000000000000000000000000000000000000000\ +0000000000000000000000000000000000000000000000000000000000000000\ +0000000000000000000000000000000000000000000000000000000000000000:\ +BA6933819299C71699A99F08F678178BBA6933819299C71699A99F08F678178B\ +BA6933819299C71699A99F08F678178BBA6933819299C71699A99F08F678178B\ +BA6933819299C71699A99F08F678178BBA6933819299C71699A99F08F678178B\ +BA6933819299C71699A99F08F678178BBA6933819299C71699A99F08F678178B:\ +00000000000000000000000000000000 + FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:52F88A7B283C1F7BDF7B6FAA5011C7D8:\ FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF @@ -22950,6 +22960,52 @@ F922CA875B991A31:2763F255636A34C1:22EBE7A30E8855B3B453A6E926D4F187 B4ECC305C3DBD8E5:FBBEC8F5DBF4CEFD:1B5E23EBD915C1FEE59F57DD91AF7347 3DAADD7A9633E19B:4DE5C07EA1564A64:A6BFB85FA91B8CA4197C8B502A62F972 +# Cascade tests generated by Crypto++ 5.6.0 +[Cascade(Serpent,Twofish)] +0000000000000000000000000000000000000000000000000000000000000000:\ +E78516D21D23DA501939C24C48BCC79DE78516D21D23DA501939C24C48BCC79D:\ +B50638F695AFA16F9378D43374CA8568600135ECD1E513838722366346BC4B21\ +01422291558FAA30A3196CBEB42E67F4C075882482897F72A8A30AE9B3AD426D + +47CB8147C5290D6F94FBF3351777087FA731610A3F66E3CCFA6D9B18F980E687:\ +F234E056923B3DB26AABC8F604F0CE2C1A7F4C35B0B74958014D791668FF6BF4:\ +9E8F6BC09768AED8F533FA4FC35FF6FEB8020FFBC8350DDFD20ACA7ECF1889CF\ +BFCD78E261B9A3CD825401AFA7ADCDFA88DBA8230FB92D4B942C25EE92F27A02 + +B9A28D32734EF678BACD5539FF9FF951AF81F44AFE223256E5D8898FB862A767\ +B90BD2D95E17E4411D02D49481CCE4191EE2C7AE8EBDF6312BDC66317AD42140:\ +065E390C4FD10E9929F30D89A67E0D4CFA3AF90BEF46B2B435B53CBE0B7DD1B6\ +12D4C5E2D03028B488000C06517434FC70F7B62C273CA5DEBD9CA7034D853087:\ +1EF34E47005028F2D95120052855C6001225200A333CA4D7D5A356B5554EE2AE\ +7EBC9BA57BADA0DAFC84C2187C51CB3CCB5EEE40F27C00537FFFCA2851DD8BD8 + +[Cascade(Serpent,AES-256)] +06CEB2B4FD2F0A27B3C90D77D2E9BBD3665A8DCAC9187B1EE9F6A60D39042A9D\ +3719883B3E87845B9D4A8BE258379959775969CBF5768A359797B2FA19FC2FCC:\ +05FFBF6E8097FC746FFAD8C3306E6DB668148796180F26CA5DE06AE76DE16D07\ +8A0E72B259982423ED96FF95719DEB160CEFE7697752B0CFA984A18DDCEF2EC0:\ +EE426051D1ADCE09AC02E2023331F273BB1B2C4C5905DEDA3E1032CCD0DB5611\ +5B011F05688F781E3F790364968E06DC6E7BD5FA38DB068CBD34A85B6B3A9458 + +FBAF0DE6C09D10EB31F21A7C784BF453F82F51EFFA8B363EE6B33DF15204F434\ +45170DED1E39AB922548ED82AAADED6BF470A5226B69D025FE3D532AADDA069C\ +464D2C8A65E1A18698BD521AFB3053229C1539626392031F8C36229FF3178A7F\ +5C716E30DBEFDDD4AC2113071977B795A8B29DA7F467471A996FB63136387C28:\ +7ED1F730EED52DFB63E073A40EAE404E443ACEB9A3B55132E740ACE1EEDF99D0\ +F22B3F2326E2E124594E75ED1915C8D155F24269254B22B6E8C53E9F64E70552\ +D5E3004782C6C47341EBF8716B59DAB49B512B6DF7F9D7FB914FFA56F7F89B56\ +1B6A5DFE9334B7561144B25FE0F57BEBB4058EC7D9EEA57AB62825A86312BBC3:\ +CDCD23F5518DB5DAE8C69B56EB352D4F3C4A64A5FFC8E5BC2511B8310993C48E\ +FA30A0F9E2B98A0FB1FE64173E6A8038047AEBAE22E17392FE32CF1D0DE3BB76 + +[Cascade(Serpent,CAST-128)] +27EDE4B2A3784A33898FA330167317BF7354072672D49DD03D13D3F0856CF3D9\ +C17C1237565E7320BDD23C03BDE195A4FE58623A983DB9C308D5A976D92CD6A2:\ +2D7096A03BAB4DBDABEDB9F069FE68C3E12ED65ACCE43ECF7F6D810B5EEC36A5\ +22B605715BE12003E324436652BEA06BD289DBE886A5DE9E51CFF6C065A21F2B:\ +EFA9CC5F3E245AB463CC60A5015CB0F663676760832CEE6C633A518112E518D4\ +5DD4B627E9507CDB03A1ADD870E28362 + # MARKER: Cipher Modes # Cipher mode format is plaintext:ciphertext:key:iv @@ -22957,7 +23013,7 @@ B4ECC305C3DBD8E5:FBBEC8F5DBF4CEFD:1B5E23EBD915C1FEE59F57DD91AF7347 # The block cipher tests above are distinct from these ECB mode tests # for testing reasons. They could otherwise easily be CIPHER/ECB/NoPadding -[AES/ECB/NoPadding] +[AES-128/ECB/NoPadding] D8F532538289EF7D06B506A4FD5BE9C9FD7A929E0FD917686D9520ED236A276D\ 69E63C821F9DE0BF23CF1D19C7374FD1C3139DE2E1BA4693C3E9D29D774C2FF4\ 69E63C821F9DE0BF23CF1D19C7374FD1C3139DE2E1BA4693C3E9D29D774C2FF4\ @@ -23202,6 +23258,1020 @@ FFFFFFFFFFFFFFFF:7875DBF6738C64788F34C3C681C99695:0102030405:0000000000000000 FFFFFFFFFFFFFFFF7875DBF6738C647811223344556677:\ 7875DBF6738C64787CB3F1DF34F948117FD1A023A5BBA217:0102030405:0000000000000000 +[Noekeon/CBC/PKCS7] +13:34B809F9AE45A52C3C8509DB14932E88:\ +56C5E79C74EF63A2B64D831EC0FE0F5A:\ +D79A4D3B34BDE6BFB4DC0BF752987080 + +0D67:162A78296327F770DE69D67E4457A8C2:\ +F4983295EF1FA592DAB2310E2E880FFC:\ +51F3733F3165D6EB65D5B43EDF35D740 + +63AF95:D174647B1A88041C95C7F008C7BA4A28:\ +A91A7BF471F67C1A0965E581A2222406:\ +1B5F5B8141905F070FC52D9CD50968C1 + +F7EE3026:9C1498690EDD348D517ACCCE942235F0:\ +138AA1677CA227FEFAC8BFECE91CC2A3:\ +AB60820C1B2969460532B9C3AACF2863 + +0F330C110D:A3DB1F6987910561A9D34CC4B614CE73:\ +FB9DA8B850ACDE73B5995D5E913E9B7C:\ +A062C36CF4F5CDBF6424D6D37F33FCC2 + +74322DD18E42:D18CCAF4D22AD3D84BABD35A63DE9BDC:\ +387403BAE6E59D5E028D9AEAEEB3EA82:\ +62200EBB9FF187D0502B4DCFFCDE6314 + +C70A03E92ED032:8544D24B952DE66076CAFAF6908B61F1:\ +DEEE15B8CE0C0C413B0AF67C25BA154A:\ +B357D26FBA489278236388C9E6A21495 + +AF8CD43A3261B258:D504F374BE690B207353884B04C5C0E2:\ +CF66029926B58A127BE0EC73B2077100:\ +522D3061784EAD56F460947A6205300C + +839FB81A72FBF5C48B:53300ADAA73B7D064C1B988D188D7F69:\ +5818851FB541EA23F545CFB969436D98:\ +EB8BC39214CAA0EEFD886154433D3E3B + +58AFB2B30F6716934B01:0907B00FE2F8DEFD08FE54AABB5A4B10:\ +C5E00BAFA4F9E1705589441B9EA9505F:\ +24F146DF583FF0B84557446575EC3284 + +83F62FD42E895E13B7E34C:F64F02BED29282D976A61F6C02851B27:\ +2864CE9F3A5511F63903CF0CD0472240:\ +96C419A75FCEFA60E11312CEA3241EA4 + +99D8D0271E5D6C510B38CFEB:15CAFCF3AA4BB5A1F018267C81482B4E:\ +6D5E4E6B297C7A69AF683FCB18C4DEF4:\ +202DD513E6D521842CB116CECB1F17A4 + +58E5DD103A644F47351FE13A4C:AF390EE66A8987C6777B0070ED0D759C:\ +DFF926FD70664DBB19833EBC9068AE5F:\ +7E62EDC1E23489D5CE838CA3C5E327BA + +A35798EE1FBF7F92187633E57FAA:1C4D55E9F8B8D8458B751D8016E0CED2:\ +92D13CAC6300EE6F17197E299ECE8671:\ +3F31171C66235B9D9EF6DCBAD5A33AB6 + +D8A412EAB58D217D70C7B9C604B783:AE9DD1426DD34F2BF7B3B478E59D51B9:\ +99F1B3BF5F635B125C6E430BAF0FDE0B:\ +2D64CD72703C8841F8F451E586CE52BB + +2CC0A7196FFF6B14410437639D4E52A0:\ +21698232D55EB045290B49C25927502FCD4314242F2B9DF225514FEF90E313D2:\ +ACAE925B9F91D3BF59E6344D1996B7E6:\ +66BE0EC9F49DCF852451439BEF133EC1 + +0A6B5968D3AB48F00C501AF499BDED6FDB:\ +432003A72A1ABCD2A463465B9794357E209C315C087E35C5F48336295F67F685:\ +2AB3F9635F8ECE37C016FFA9DD5A5279:\ +596AB3D7A114DD167A147FCB4E8FA522 + +7E96CEAF7F052A4D85C487FAF30A712E5D6F:\ +790C13E773B628CF27A92925CB3E605351293D031696EE1EDF738727CC523DAE:\ +C2DE2993F036A42278976FA347EBBBC9:\ +D6AA4E2906CE2A41DA17CEE09FEFF11F + +D3AFD0D1F52D332005205944E465EA567D3DEB:\ +3707DDB6A30F4D69A5B37CA8ED053A7F1C638D9C9B940AA09AC57A4ED51878DD:\ +B20DE0EFD63F108EEA8BDB70D0392F6B:\ +329D0EFC4231C92E04D9A0F2BFD2AB0E + +5A82E2FC993C66A31C005313B34193DE78B4E04B:\ +AA1892D23ABBC7B9654155C9386C87D3D33BBB6086E567E1D713135E2CC2140B:\ +8A8A3F7D5FE8F459A1461153B4F76211:\ +947C1AEE44B94B91FC1C62C0E9028284 + +3077002017E6E8E72AEF13DE3FA8B6634F9ACD2F33:\ +897D3F4494E271915383322EE393A6C8C24E456446A04CEF0F183B79A322D9C6:\ +0B45B853970F62B6F24BC5498F1695E9:\ +860A1A59C1F3236B58069AE9B3F58BB1 + +8A6D053CEE814DCD67D809E325236B08658736119D36:\ +BE86C4BEB29B375D461B48A1838B689B6A22379442997C2ACC8D3BAFED8D4836:\ +A51BC2500F49C9CA2B684EAFC3929F63:\ +8E982F2645F6CA43C0E5FE6AA349297F + +BF4704F12FC4573DF7CA7A53FF1AC9FC9EC2D0A0155803:\ +392929D03CC9C781D66F57FEA40984985006AF5C5692359E40C3089A0C08DFDD:\ +6D0FF160740C3F2007F1A2D9FF0764F2:\ +2024652B0E280F4F8A93E1C4D586BAD4 + +DFECDB8353EBC87CD93D9032C85B6FC7E325DE835F69EA2D:\ +E706FDBCBC6678583BADA7959B49ED4FA21F4E601A7A68D2FDB60B676AFF33C0:\ +678B962676645FCCF06DA0DFCBD33AFF:\ +F120FC32EAAFFB07E35C0F15A8D9EDF0 + +ABC5F54DC200DD2DAA7EAB951F02181DD9720A80049E01BDC9:\ +0D37E7254C1ACBF30A7AC5C69490E90B65A0E359D2146BBF50B5BA4787EF9ACF:\ +5C592FDC4B2B3DAED6B5A7F6A2CE9CE4:\ +BA1583958621CA564AFDB695A0A050DA + +9EB4D3B7B4C56EB33A8030807FBAA27D22246071D983844703BC:\ +2304C35624BB448BDECA623D39445182AC592C71C20878F5E39C8E9A39762A1F:\ +ED4B91F32EEA0976A33F64FC43AF2CFE:\ +6EB6F57BDF2B1591FE46CA47D0DFC0DA + +AF7676154A55F1F3D15B76D19CADA03A5D8436FD2B6AEAEB222A5F:\ +FADDF8B2B3B5B1685923E5618022A832180493F47153AE61F8404A538B4DB737:\ +EBD731F49D23576D1E8CAF4BEF574A05:\ +CB9E26D5905B16EA48D219456C48EBC2 + +13122D32A60EB988D34AD32B788B8CF5CCB567FADA3528B0DE384050:\ +4B951CEDBFAA5A5178D22CDA8664AEBABE478DAB09FC0BF2DBE973C404FE07F6:\ +9A912A664FF96EE3F469C779155501CC:\ +024D04B050718AB5682DD19AC6A23592 + +E19A1FA72689052C2B9C76A33000D8A0EEC8922A1BE781A6896E38659F:\ +71A71BCC755B92120C31F1B99C085E236EC462FBC6C6296FAAC5AB0EF6CA811F:\ +2E7E22C4EC84A63DFB9F98306C0D45E4:\ +EF523F0DA968AEA82E2F2D23E8AD0F07 + +D0C9073DD44DB4A4970ED69029EB9FEC5BC336E9D6E92A680A75EF0C3151:\ +AFC5FAE5E52AC9CE466881AC5B667385234F6792DB7645F42D2CF36760FAE219:\ +1311EB599EAE368A9C1E74F9D1D47BAF:\ +4C7502264C3C81E0586EE0D9945B8649 + +20C167D950AC5A84B6FD9CBA41945F66C24F79969EF9B19DD116D76CF64A5A:\ +148752675C1DA7236701AFBBEE8245158CB80829CBE1079B5F4DFCF59DA4FA04:\ +F16CD73539227EC5BA4B516C7CFA75B3:\ +D17E2642CDE1B30AC5BD01CAC83CA84C + +C068288373DB250F6714E0F9DE4A63778C91E1EE81963BCF98F2CFF2BACF3553:\ +31E053FC7124B23E6FDC33878FFEB9A8421207456460673800798E422A7E94B1\ +195EF848BF1E063CAA7576AC094C1E4F:\ +EC35A92D97B902220D88C3386EABC55C:\ +5431D970289E7E024CC0BABADD674C67 + +03940BC21C33D89773064B8A35CD9FD282F090BDC208A0EED18AAB45AFA023A1\ +88:\ +D3B49ED8640D32CF6A088F8316929C703039D9D3B6C43C32DBE99F8CFE54CAE4\ +0C6B9B587F11F1E1B421D987AFDC7D71:\ +EFC07A770AB4FBAB2259B3A3DFBC6782:\ +5E3A9763D6DB8699B903D230387FD45D + +B6B8DE15FA0A356241354E771BEF08A82955F7F35DF8E286EF17DED946C770B0\ +5356:\ +D3E2469F505D7DC2683AFF037A1197362F40F5A623F7D8350BD5BD090B63793A\ +13A6958BF9E0AAC0A8A792B92584A295:\ +0B747E8737C8555F5FCC1418A8E31B5B:\ +0C403788F70790C0503152208A8E9CCE + +923EAE6FBB20806FD86F7EBE2ABDECC838EF66D8F9AC1C2C185EE3C1BAE0D9FA\ +32444E:\ +327E33EDEAD51CD874420D8FF3C0641CF4A1187B2C56259A71F60C23EA6D8CB7\ +DAE38198A8321B6ACC834D27EB509CCB:\ +F43A11C50188A97B132732245D88E2A6:\ +377F526D07DB430BE1C478225612841F + +9057941CE977D02B1F6894251363F425DC515C68150BA5CE6F3CB1AD2EAF1B56\ +66E67C16:\ +DE4DBF13CFF69DBAD566A98916B1AD670F6037DBA9E06B5F9A3CB59E08D24157\ +C6E6F2250211B5F32631D6775F06A579:\ +6158B9B7AACC9DD9643F0627A616ED3D:\ +E21158CCA6D0656B58C64195B3618B58 + +8DDB465D9C82EB9C14BF2C2E26D90D8F1B5E444B12ECF19791F16DBB2DEC2D5B\ +612F666D64:\ +FD774E848C09A079ACDD9D44A419300F2847F93478032C6066FA9E89359C1280\ +E7AAE4C1D1933A47FFE0E02E9582569D:\ +C8424ACD2EFD7C436FB1585AAE45CCF7:\ +C15FC97E431ED75E523814EF991E3D82 + +124B752BA886C4ABD367AA6DA00115EF08C02D9308F739A63197D132E7E1B21A\ +AED339229E3B:\ +2994CA132E3A30DC1B04D9368DC9F37401442E78AAA935A63CD6C7C9DFB1ABF8\ +18B48863CA8F20E8B4F5B582C3AF6284:\ +11F33F15B8C0682B634486C48BCCBBFD:\ +0D96D9FFDE5C617201E0997747EA02E7 + +37FCB3C6DBE79BA1FEA19FF5C4F14DED4F403E970DFA9501D57751E38A174514\ +862575CAFD31A4:\ +08D6FC20CA4B2487929F9548D7D43E6E6E0676B2030FB539FBCA79BDBED41315\ +AD1E1C6677B2B83274BFD5B6D62CDFC9:\ +B522777FCAC3652A1FED51D8FE3383E7:\ +C9170B715D6CA0EC9CC569074A21CA7E + +C7AF9A384643D90CA1FC461209048836AABED909BE8971B4D2B7613628A3A909\ +64A0891C4B658333:\ +B3D53C6E550347335D677019EB675DFEE6EF263946C43CA4C07D68340E745F51\ +B5019BE2841B834154F0D219598E0884:\ +E258D2823B59737DDEE65B6139C8FBCD:\ +32C7481FD836BC3A9945CAAD3477E16F + +A9F2347EE607A05E505CE488B779BB6908ADD5F7DCF20F47F895B64B029EDFC2\ +A3A84946BE935533BD:\ +AF1C8D0F1CAB3C4627E31B69A9207EBAE680D8D092A411994507DB4764399172\ +3B6AC3ED37CCE02B2B599F7A4C265011:\ +0F52FD5FBEFCC7E25CCEE870CF00DC25:\ +4EFB84578A93800AB7DA40997A79BD89 + +5FE50D3ED686D329D7DF5CC4952AEE83E0FD0265CCB032474152A19100C85154\ +CE0D68947450EC32D66F:\ +F08F5BD75CF2372E6B5D82FD25AD4C8CA2250280C1B611EEDEEE4715B9974773\ +E9D9E2183CE3DCE2138F9632472BF184:\ +1DFE339178BC2FCCDF847A885B026C3B:\ +8D1A7B3B4E1F32BD9D34A6FCA9C4689C + +1663DBE5C893D4FCA8DE266978D7C48D70197254796D394EBA09ACC27D528B63\ +DF4026B8AD27DB07988858:\ +F60B2CA4AC382B2127CF452CC9466B7388A7C78E1B8D9F27F3B95B70DA3D74E2\ +F9F092C5168FB96EFB220F90CE1AFE03:\ +98120F0F48839DC5E9B7472ABC73B61E:\ +F5D19A16FD2FEC948458C8ECD96A20EE + +AB6B6488895E81DCC4298427FDAD9EAD39561C5C99D933BA15F5DC705B5E094B\ +5387D2E88D91294FF6F3B8A7:\ +5401EFD707525F1E4915EA8E80BBE80C9FB5E6C45600426297FBE05ACAAC7DF0\ +9912C000F643E6E9462491B30D67658D:\ +213FF5A5FE08326FE2E5C5DC05604A01:\ +465280C995DE276B0B6B6378C8408CB9 + +392477CA63A896B14131842857FF6A2C30C1DAAC96818F89D313BE2EC14C39B8\ +8A855E30ED9504131CEF85640E:\ +2E196AEC24F2D6B59B57722F58BB8CD6585813B7050A83482C8E5C38825C1A62\ +65B7BBDA707F5E6CBB02C86643BA67D7:\ +2F3FC6D862409732B91F426A12EAA155:\ +D16992DF8C17F4CB936810C81CD963AA + +E14EA57790067110020E72DA6AA2A972352692F86264C3CEEF69CBA1AA5E58DD\ +23A991F988BE7DB99821333B7895:\ +D01D65E636A981F5F3D4AC9A829225E82AB76DEFD23E0691712CDA65FA6E6538\ +BC512D6E44EDBA17BC2D1CDB064DCC9E:\ +63D77FC7B6ABD00AAEBE33C9B2EC1E5D:\ +6F12888D71AEFB2420B163811AF9BFFF + +038534D14E2FC942B0C504B92C3DC1977B4C962235DD3BBCB5DE9D0E8A1B466A\ +BA575BFB125BAF3FF480FCEB6E4BED:\ +E344F758173083CD3813410BA07FF8F9E781E04890B27A598890DDA728D08B2C\ +19401462F2A649A76234F6D428160E32:\ +5A82107DD3B3FC7D9D1E4CC5117EFA7B:\ +0803AD8DE267CDC8BBA99069E8D892C4 + +564677770E8B7A02485987661EE2B6EF8EABBF80CBAE9404E75A2FF7C4E6834E\ +438FBF09E7FC2EC63521A12A6D4BB30D:\ +ADA7CBFB49234A49CF6098350B84A8A440504671889126C1D0F93B2CB616F988\ +D4FE79C9C15929843B60C35348FC91BC6244A225951C0A07F185DFEB127260E8:\ +D337AA8F200C073F4DE5E042F352CA42:\ +E5FD769526BBED0E5096997B57FF8D3A + +CE0C994114AA7919D9454BD386008A4B87CF2A54BBBCB122F2992F7B3FC01C5B\ +F0E4DF661265382C57F57A5D96F226BCE2:\ +CFEC3737847E8C27A58F7A616B76D875107C6E6DA75F2DBE21F6C2090AA45F08\ +2FF3ADE9ABCE4692D85D3EDB17C6EC108D4FEEAA67D5ABAE6BB8E5420F0F6BDD:\ +3F65622E95331BCCDF8A6514163AD1A1:\ +55D4064906F2C6F67F2ADB2D1A9CABE9 + +37B6E210FF6F2810B29653D3C3B2B80D939AC030C29C1E2D61D9C4B5432B3FD3\ +883D34C99DA9D701EBDD96273D3F292F3753:\ +7BA7D4D5A586552FC008A7A82E8D0475F3DB4C0795C9DE735700C0751634B329\ +F8F71D21701F74E1F179F87778000B765CDB3865CF9569713DB023092CA8B4C0:\ +64D7B821DC6916A464D41B2D3A352728:\ +CF8AE7BAF39569FDAB4BCDE9283E4EC4 + +ACB7AB275B18F55C0A45CE3B2CED3BE4DEB113CC4ADA87EE851A1196BADF0B9F\ +91D579104772040B3A33DD277F2A33843EE909:\ +11D15D948182EE585F2690F236A4ABFB74029D525CA579AADE4FCECF4C47A288\ +1BC6F04535C514D13A03B23D06B4BCA6EAD0C2756D6B5D5C616B229DAEB58848:\ +0CC7AA03EAE54E833C10616F0DF07FBB:\ +B77D7E2620DD96499F46F311696DDCEE + +27C36747E9672CABAFAA5BAA95E95FCDA760FAA3FC1C6C7F248C374E4C6C9A1E\ +4A44873BE795DDA3ECA213B2146DD8E722277619:\ +07299B862884F6FFE4657709404917F411BC24FDC2B6E504331E6D18E94A71F4\ +F5CDA54DF8FC3A0E77EFF63EC9D0B82F8CBDE1DF86B917CDAA45EC4E603E364E:\ +ED590A7F005156105AFC45D9CB50F525:\ +C5F2970624FDB6B7DBA0A6C2214EBA3A + +9581E9A8251C7DB9C4B15D2B208FF66874959D134FF812FF3639D1F1D05E02C7\ +806EF336D67782E8D05D1EE900785F7267BDBBE76E:\ +EF5E6E49F0A3A01BD37C078516E6A85D6B5B04B1E4CCE934FD3D2872FCD08BB9\ +49DD606B4771C02FCAEB09A666DE721BA86A68CB975BB394D1905E3A1A233B3D:\ +F567648AF7EF8A506E5F22542A3C2867:\ +DDD7C1DABB2436BD0FD28D6752359863 + +0683980F2EA98F5BF000D2E9AF1DC15A6311A13F398DE23D0579BAAFDF59B0A0\ +3F051AC214D80316416222305A676B17826565065FCA:\ +D96932925025F6D2CE24CDC3A4AD07A90456F011681A669C1C45B685CCFC7350\ +6514BF22E0DB166F37628F4B8DC3FFFDF60552C96B6840D0BDF510059467D7DD:\ +79FF68FEC504D32A717CDEAB94A7B5BA:\ +B30BB4EC282B3D4B6135A7E17C2D34CE + +4DCAAAFDF72971AED4B15B46436E19E7C8F79220C8EF7855FFFE378C35F578B7\ +5D0872A37B67DAC675083F9ADEBA89DC5C6A057F762F25:\ +BE12616523F94449F8120B6BE35C84511A59E4D40B0430EDA4C4DAC995BF0F08\ +856EAC2DD4E709BC9D813A40D8FBD588EFAB275E1A11966666CBEFC08050104E:\ +573A08B1064652C81BB99C46C7C1944C:\ +26FF1AF8F21A79BA6F59A7BA710A51E6 + +D41B814F718B82CD1B1F64071F9429BD180E1DE6F121692D17AFB7AFE64CDFF9\ +ADFC20E10B02A864901F90B863BA85D70E7CE4F53162FEE8:\ +70A7862DA2217F3374CE05AE4772231A489F2912BC1B9A3483A6CF9F11AA05C3\ +30BDB25BE9EA678F73868B29F908C1B4B715DF760DCB23B3172D7EBA94477541:\ +B493509AE30EC0AB626D2920D9E929DF:\ +43491F9196D8251FD46759222E3CBDBB + +4AAD61A9D21D7F76BFA86A6B054EF02BEF75EBA59DB3D7A8F6AF2472923E283D\ +0BD50DF43FB832B74EC6AC1A5B6C55EB8A929FC143E6A2CA5A:\ +59CC595EDFC1FF1EC7E3D179273EDDA43BDC9B7E91362C89E19910FC4BB131A0\ +0B7684E147D0912F3B71C8F2F9B00482AECEBB107923C38F89B7C6CB232BEC5D:\ +0BD6C4A47107E38C3C234BBA38F4794D:\ +0888924CB3C8DF8FBC8E3CEEECE1ECED + +1A0AC832E284616BE2EC6705DEBC789465339B961D029B00B9ECE780B32940D8\ +4EC00EB29991BD92572E51614C37312A44AF192C189F5D0B034D:\ +12CE713413361CAA87DD2E584677B44AF5449D09CB083BB459EE47F65C834A59\ +ABE9E557F4D961A6EA7C058B479243799B291FFAAA5B1771BCE62C0F83902A3C:\ +1022A5A56788270CBF3303D958D8E365:\ +BA4179A2F159004821934A0ABA0971BD + +77D91E9A2ED17549724830B17B5394B44C6F5D54862EC45D2124129471A3075D\ +75108F34662056550A4ECD24133FBECB413EE5BF58A5EB089EE8D3:\ +CC5DEB0FED41FF63865638826E70FB572CD040CCF9273183BAE3EDA2124AF444\ +44597AA311A182C59C6F2612A0A55B7CD048A1F735FDAB8E4BDA44EEE347DF2D:\ +A6E9CBB2936DCE26BBE3BB14A22C0B43:\ +0D061B14FCC07756F78590BEEBDFE3A1 + +508C2A9A589C470FE01A24303A63E7F54C4AEA5053805D1DB6B1F6481511FBEC\ +1D32BE1284B0CA1E24AA234EE9F6A77A448CE623C1EE0FBB343610E0:\ +424E77DCB1BACBCB1954F7FF54C5ACDC398F98B522E556C0362D9992E8A00953\ +D94514AD35311016DD51AE95BF7DDBE29E89F1827C65C278BDB0FB9D243E7B75:\ +930F2051D3BC4BA985241990B92C6C29:\ +6E12ABF415BE763B09326743C4D03EDF + +3DFCFB4B32C9FBA848403256BF0D3AECE761EC23D492DB5B9A6845123F017358\ +48487CB1CE198028B4FE605D40F7039BA46371436E2653EC84A132A7CC:\ +49355D300361AECAED24CBDBDAFD6A31EA8358646F84FF75B7900F6AAD59DD25\ +15F8FC834EBDDEA297D2AA36D1103FAE5DB9C60D213C4CDBFAABC24E62F631F4:\ +C5E25A158442E6248D257114484E4FF5:\ +6371100FB16BFBE598590476C43F143B + +C50339C7DC951DA35A36F4F613899000069F50A41BF957A75118C596C7CE758A\ +2BDF378E4B83F31EB4CD596D301B1617DC1C9E08C70B2C3EA410B546756D:\ +8ABAA6655CD7D6ADB51E22ACA8AE019743F47BDC8190C05B0FEFD88B5669434D\ +3202F1C121D51C5E46AE46B28DFF3195F2F8DF2A94F5CD0F7D11685AF6D10F0E:\ +478C7266D82E73C4C3882CA4A05C0A1A:\ +9C8336BEBB6F820268F2E6D0807EA389 + +1E570542A73BC1A212A8503E190AA8E24C7E5D87469ABC1208275E17DD5D7882\ +EF33F839A2CFC503F07641184C77A0B1B017EF916F638EBCE5B253C18B8212:\ +13638206A95985F22D055C9350F00926154ECE397C1FBBEF16B66A3E4B0D4046\ +9966E45C44222B903027F20D7AB620DCFC0AB5FE2D7E563B631E191F762ADCD2:\ +527317EC7A1D9762E6891BA823FE3500:\ +6B3E5D8466A4D655DEC67CD62807AFBA + +2E83482C2ACA9B7C9010809C25597D74D19F8AB95FAB3A469D1B31D9968BD375\ +5D26F12B4D0D2D54E83ADEF3DA53F879F095EBFC4AE8D1E8562E90C55B22FBBC:\ +857882CF9E0B8C298D1A4BA1AD25ECD9FA50B3512A9BE93632A1BD8F27E768DD\ +23C8955AF6B4EE745F6CC162D9EA7D9B99948B3F256078705A192FA527AF8D59\ +4FACE3E88F0D3844B1E24A7857477233:\ +6D632D11E9FD60638E3F7D11ECB29D2E:\ +66FC28B235FAA4C012262C716F9F7204 + +7BD83E3AC317811A304AF3428DCAB0379EF114DFB9971F6BF67677A2E513382F\ +AF0E352A32D7F3296475A39F3A7E851CD3E5225D0B0F675B94014DC9165A1D9A\ +1B:\ +0D15F0823F83D7652B4655D8ECCD0633FDF217CF477635269D6009DF41738236\ +1E413DF7495006E9967E82090A2D99D5A690A2349C9E6A350290CEBD1EFA4959\ +691BC52BD8BB24913C440B9623641A1D:\ +5566DD5873F4C7D4302AEA5217B1D5B9:\ +2C17CF9E41895A1871D5F3EACD478E20 + +1D464A69C8E8DDDFF2205F2E7336EB89C7EC1002660649CDB1ED826B5E8283BB\ +02FA96F18B4570458BFF5086B46EB4EF0F87CC9F39C7FF9B3E881978F7FEF9CD\ +48FD:\ +F4D03CC920684F92865C2E5B7DCD21A39F0223990AFD50C38A90325FD038817F\ +BAA975F2C3AC7EE4192B71104921B9F852868276192EB9545CC14B8F9BE36964\ +14745BB9ACC575C0DA3A1BC72DFE420D:\ +9AD3C01359760D2B9D7114ED4C54E35C:\ +1A0E62541D7AFD5ACBC18DF5EA79CDA1 + +44A5F5D7B96035F5A554499EA17B9B0193484376812C2C2DAB9F459F536D97A7\ +1FD4F723123156054FE53DF577BC448C124AF49AA9D003157272750BA3CE5712\ +776EE9:\ +E697871A69D625FC8F8894E6056097E354A88118E5189C215254E0AC2C85A6A1\ +092A34314CE547C56D60E14E494590C9965BDA9D75F47B20E8761D14AC2DABF3\ +51767830040808ED9673E88A89050BBB:\ +623FFF24CFCD55E89911987DA599012D:\ +5CE090821525286F0F60E46909107087 + +6FFC0D5515AC7AA12CC56503CE163F52789BA0FEFC324ACE7DB228187FF7E1EF\ +BC2EFBE3AA010B8F6D298952B0497FF677FC464B1FE51FD93E5C2895EA1CF4FB\ +4A773919:\ +1DBCA0F4EC05DAABDA02689166F93B7FB4A3229D7DEB3C97B3846E53F7671383\ +DE567BB10D8457E92B1947F36C5BD4B9AC68B5633AAC16453050D65CF8B85C88\ +E5F7B9EAC641038A6D225BC5B60BF39F:\ +3195B7E2AFE39355D556F29F21800597:\ +FC64A4493B82CB958966E1F93DBFFD8B + +FC9D3C47542680D7ED0FB2388D42361F9583D2ED2285AEE599FF6E5DF9471B80\ +E477F347B6C88A83ECD1167EBBEAFF93745BB0B06735EAF25579C679DBEBCFBC\ +335AD348B1:\ +A4652823CE03E688DAF56F93B2DF8C9F55E399B1B13ACF7E6AC344A7AAEFC327\ +185BA29AC9FD0A29C42367D8DD4740A4C464A5979827C793EB29068F08A4A3E5\ +FC118CAD6C58CDD04A6F925617010727:\ +FAA44A1072FE894478C7557B6FFF6394:\ +6E5B9C688C4A5C8EE4B4CA1A263D6E00 + +EAA0F53C3414A0B7B6BE05327F5F2D76ED2E5169E4ED5CF7A5F066B1196F4DEF\ +208D544116F2774B3A02608DF263415CAD366963F791C7808E2E248882880E26\ +65436C7E8B44:\ +D3AE352CB790D12797DEC61BF8C17AE0557A764B4E3F2ED2371BC624AFCB8A6B\ +340BC68A4E97447FAD51A52865B5A6A492BAF5AB525653F34392B299CBB74FAD\ +14A16F3D7EAF4C00DD73FCF4FC885EC2:\ +E7D0BD991DB9DA63027561A13D620F72:\ +DEFC409F9D66328C93426D55BCC5F3C8 + +0C3A5198A1F0D228611124BB18A94A59637B8EE8C3BC128003D90645067C1D7E\ +3F12440B08DFBB24493A50D963EFEA835497F85DE87A3857B1C5FAEB0354281D\ +76BD618D1214FF:\ +9A13204622AEA6CD7F70C34518555A2DA17A3CE11E7A832F6AB69F8EC8880BF7\ +2921470897BE8B0B90BA88020847BAD4AE5E9A37E22E6FAC568E6EDD1FC8BDC0\ +E4D7663CD573F35F43BF4BAF85BAB7EC:\ +6B422723B4A706C9A184FF4FC38824CC:\ +CD0ACA21752C4EEF842DED5A53BE27B6 + +DC05E863402163187548943B43533CDE7642FD31BE2A177EA79CDBE52053B538\ +A394EC65F09A1091593892D6251F325A38AE360D6D7AAF234F9DA6E841523A2F\ +7AC724447C9631EB:\ +3A927FB3306824B549B18FD5699643A08B64EC3B9E1322FECC32036875545F56\ +DB2FC7B34B7A097FB4C7E211BB5FD8E1B69813BFEED2DE4771AA6A4D4557C232\ +BB4A488ED9DDC5CE2CC8BB67A7B66932:\ +BA37159B1AC79AF43E716741699FE664:\ +CF45A98BED7B6ADEA83EA03B6054D857 + +6768571A03A74594A20909B61211C99F91D3EFAD8A72FA0460B5B3A404D7F0F1\ +94677A90AFB6857B05B923185C6AA6043A7E8373178647F528645E68E0FEF4CB\ +36187E0083613FF998:\ +88CD0288FBE70E08403BDE580AE08E23CD0DF5C7E1BCB076E6F0C274C48C3892\ +05A58F7E17871D1F3DABF5DD3DB597ECA98606DAD8A5F6F66AD5E5AB16E6DDDE\ +E91C55EB62CE86ACFE87C4C703710ECF:\ +D89F12C903BD9E3D82E05CC72F88DD2C:\ +2A46464A0975A3D77884BBBA01508D2C + +A6428DC3C3398CE37098E1F059873CB92D937C437A7D75D2129BFC5528544E4B\ +C50D29F6D882BFB8E500B2625BDEF5A6EB1DF2F3A5FFB9260C540EC67C033769\ +E6A84D6A137B257473E9:\ +B6218336CE13C1589B1892BE8507B218DFFA2018AFE90CC17EA792955069831A\ +DAC30AC868339EAE50B10E513E7F29EE2914FA41EA76B6CDC99C4D300DCA5E9C\ +2A96023F8D834B7404956F51667239A8:\ +197EA77B0320C3E2F913EBABEF18EB1B:\ +DE295D509AC3165B53922EA9C199CA85 + +FB413ADF6745E383C87EC50BB8DEB4CAAAA4C5D24AA3A449018DEC8A6B85B10B\ +774891EA61757BB17292B38ABEB12DB3B71C71DFA92D475963B0F1B1FEB93AB9\ +A753D11B753EBFD2A3D74A:\ +740830C6AAF2BCEA878799315F5C842C54D760771EEE19F172C9289C0876BDC0\ +3A608B81597EFA11BC8A7A7EBDBEED5761822EA62E22B9A6EA530C9410225BD1\ +A6398CC8E257EE054B2C3D87A05DB73E:\ +9741F404AAA4838905C2386DBEE885DE:\ +7D57C18C4C0BCA04FCDE6F8E38D413B7 + +B647566525347CFCE42CC44F4EEB9CCD8325B0350A4F123065621B7D03C04DFB\ +2A1F5C9F41D3B1ECD3814A2A7BDE4DE46EB0AEA673EA2FD582D00038F256D888\ +A94AA60488A7ACE9F4C29667:\ +70913C486EDDEB34D7E1D7A8B9CC75234E0B3D9000717949A59132AF2D2B056D\ +D0243E11748F6D2820D29C0BD15747A61AB1B2D87FA6E4438EA053DAA4D39A2F\ +BDD62DE2AD36725E9688E1A31DA8DEE4:\ +C18B48925AAEF9C1B8CE83C3C0541C5E:\ +F4358C6E2F0F1ACB31433337BF9630C8 + +C8D276B9194CEB3C01B3DD0E0B0F84FCE5D548F7FF60C634C0ECECF4C74B8154\ +514CF766960E34DDE8F9F7C60215C932589647B1548B0B408210727D4D4ECB6A\ +C654A6A4E786F5C124034586BD:\ +68EDED1A1230A88040241932A87C894C0F3EAC2363ED85EE077BCC869AC9D982\ +61DDF9186DE665CD5D70AB210CB4D266A2A9D990B37AD6489B55275019BC8D9B\ +06F19765E390156EFDA6DAFC6205321F:\ +8D12D956B50250AECAA4380C2FB5FB99:\ +C8F19FE75D91DDC9FEB38B71A47250FA + +95095496B695C5CFDF83F196F400CA78266F2CBDB9F58DDA77CCAC98FEE5BD13\ +8ADEF80CC73400B0BBAA66A3D57B0158AE49E393F3D78EF8196827775DE2F005\ +0C531C5EDF2528331BAB2C703AC8:\ +C3B78AF1743A14F1268D87EDFA707968191FFBC9820C410DFE39814681484965\ +8D5ED951E7EACEEDD27F2BCB821DA56B31FB9E2181E836A54C8E54763BF9EDE0\ +449ACE3E0F5757AE3BB07002DE63C25E:\ +3CF3AEAA654897E706E2AC1239667209:\ +4110B8B8CE35B9BC3523B05DAE24C69B + +A1B2C52B1B10F73DCAA6ED822B92B61C27245D344DBA2177F509D28ACC108642\ +F2013A0777C4B69B76C707CDAB448B451295F636163B4528EECD717DE79F3A12\ +8F32EC8D614412FD3F5FD2BD0FE633:\ +797323F717303F224CC9FC15C29BB15C9296D7C4885882BE3D55991607DF0058\ +67179BEFBB30C9034F0C6F94438A537D33CF4F644372E09F07BD023902AD54D2\ +CA2F14EB04D43FE04B4105514889EB02:\ +40A2DBE5EA11E2AB589DD95F71D4BF34:\ +6397EFD9F05A5A87C43730CD42C29033 + +1D156125591DD8E4C30B09961E5560DA5D201B6EBFF5CAC64A1DB78F33D3C2C5\ +CFFCD3F1E55B246DE700CBE18E045783B94195CE141E483AD9D70EDF28C61055\ +33BADD7DA4FFB971D1778756D11C8D3F:\ +905975D4AB9A1B4AA6C9A39A999FCF7581BAC9C9C96F0B6DA63020DB3877136C\ +1E9F8E89106942D9405C73486737AD57B4098A2AF29EC587D6B7DC07F469DF28\ +C075435735DAE3F6C2F7CECB9623174CC62EAE8DBAA72679E117FB5EC92F2267:\ +23822FCDF96E4DC4088077C0CFD93336:\ +6E4E85D4B38E442544B6B04FFC81352E + +F252679F2DDA76DD110584CD0D9E5FA64296BB880606A150122A7EDDB6A682EF\ +BE655BB59DF6885240AB11E4B74FD0A159C8DA83A8E3731DB39C8937E2927BAB\ +FD018F17B155BB818B3C0B358B6680992C:\ +B48FC12FEBE86486299CB3FE14C1134D2F61BA984334F8C3AEE08C8A0E2DEF12\ +C476096E9958576B81C6E05968382FC7EA17B85B8FF8805EC695BCBAE5608054\ +D5C830DF39CB646DD4798D3AC0C15B572953E5645EB37F431DAACC60B874A180:\ +B107244D1A4445A3C7ECE0B64FA7100C:\ +58CBBB9601C142CDA4CFB02A45861808 + +90F67AB45A02E5894862F15F0A919DD6D7833A2C1C46DFC9127D29A53B5A44C9\ +3B21141173F53CD4A854B7AF496CBAAFF654FE2B28A7B48048CC9D01113E0017\ +6DF95D7DD3CAECC5DA53367DAEFA377F84B2:\ +2BE5CC556D2E2E67C37FCBEFA7B0FED5C350C0B2541F85671556207BB847C3C7\ +E8B1910A7854B8590F0BDAC7CD1E52ACD6F1584D25B86407EA92222E951339D1\ +1F8D847108B0545580B5BFA551B9C1D7DEAAE8C100469F9A6E9A578FA2871104:\ +AADE936E95C2EADDC9FBB708A6753851:\ +04F4C5D43118F5568DA176A140913851 + +70A355394A84A1C6E0281A6E4D744248553F9F6C6A6E6E01DE13AEC21E7D36C2\ +B6BD7C608917A4D9F723229C020A677DDEDC2F3EBE9AE2D4AE490DB9E456212C\ +9AEDC04C2D34B2384BC75C8A9196FCC1CC642B:\ +9EBDBD9117F03F340AC4EE7BE24E45CF6A18C76CF4C79A8B19EB83D03B8F6202\ +E9F9E0D3BFBC351C407E699F4B592C93D0E6E037419C48167ECBA7531EB0162F\ +6D236682831409D1831CC309F227DEBE4FE0B395FA201E1E2633354381D30CE8:\ +2B3AE9E5A047CD4A5C40FBB546AD4CA3:\ +CE4C47854269A5C40CA58E56254B2264 + +DC75958667FE6AC96BC6B291DE43E04BCBA6500FBE005D5ECA3AE57AAC2E7754\ +8AC38A6DB461986F4523AC48FBCADF5B78259938DD037ABB4947D1F85538AE2B\ +89F0323FC1F7539465563A816B3FF633C1BBC6A2:\ +1DD9013DABCD617011B0E2C45549A3EFD665BD0E6ACF515A3AA4B3FEEF92DA1F\ +3391685E8824BB8767AB1FA38F8C21E02518319A42C15307FD645541B543E98F\ +74BD9383A5047C89D40B7B685999C086391E1FD2CEAD877361DA89BC89EDEECA:\ +0AD480367F7085E45E72A001A4B8A43B:\ +6A6841A5E07DC00A0015006F5F60D895 + +C160B510C45E17D2A5B38716E4A682884AFCD7BF1DA22E2C482FD291A713E623\ +18F20AE2A6369CD5F958EF3A03EF2A23ACF0DCB68D27112B2FEE8E5E623E4F91\ +849A061EF3D1707F698D682C62073D7D45A8406D16:\ +7129EE5D900251E38EADB39DA6F0301E85266848C1D014D2764757AD5EEC1960\ +FD8A46BA55A79EE64080D7808F2B967F9F6F8BA51F296D3EBAC8B653E920F8B0\ +D2632EEF1C96A5E36B51C1D0F60D1DB0FF5D55C567F4393EE790C0BE87610845:\ +10E06819D7EE77E7D55765948D2C21E3:\ +CFF4424C5812922ADBDFCE029CE63235 + +871D3A83E921FDF2902B25660181FF81260E671390472416F9E6270BAC539203\ +A93D4AC5F00DB1B63FB4E8B840CE4D118EE967AD74E6308CAE8850BE61B0CDE8\ +87FEFC61B341CECAE98A7815F5E699766F06B3AEBACC:\ +09AE43E962C2F9DDCFCD5AB82471CFCDAB1154C64DACD154C088D4BDA0937708\ +4167CB7D41A7F87D5DD0E702CBB78F0CE1BFD05C53485A91E7CF333E276A0FE8\ +4915FDDC7708F696F49C95894A4D6CB848DF06D52B0C5F720CE23A493E7F4DC1:\ +9A937835746821DDA24AF556C13D7DBC:\ +2866E153FE0BE9DAA8506D59707FA3CC + +2D1799655E6DD69CF3C2E40F700F8C2F1EEA99B3C6926647BE7A07882232E1A7\ +901F3B06829ADB9BE11391C190BCFBFE908C08CA5BA7EC5A5DED518B0F469A37\ +8D9ACB7F1E0B8D7F5E829799D1877604FA0F801D4A48EB:\ +A1687F960FC0DD54B32B86B4A6FA988740456FC8E2CEB701E841CE897265A7BB\ +FDAE0940D288355E894467CD703442D86C40D3DA31601FDAF990BD1576951426\ +F8FE6AD5ACDFF881D103C5FD6F40440D95DAEAB2A3593DDDC152FE9B09F1991C:\ +FAA109A3632C82622ABBAE17AABC60F0:\ +E057120AA0B73247D6608D148BA05399 + +311FE0F676F81A110EB931AC3CD2590AB2F3730A4077961D830E8B57C224EC4A\ +738D27CA58C205FA0872F2BF6EA1732761AD4DE851AB06220AFD82C1DB0C0B2F\ +1064C6F23AE0C092F0F5598B73F4CBC80F4FF249FB90D1D7:\ +2816A89C908CBC999D1D8E8497B15F5697D66265D05B7900ADFFB41139A57FC9\ +6D9249EC2DDD805B83DE85CBB97A4C44A5DC85BEB18D7064855CA38870CD1E4C\ +62EB78FDC7B95B32B93D146429830E76D48D56D1E9F6297ACB5EB959B30834E3:\ +A5DCC797CB0383C344617502A5908A43:\ +60284E3971826821263594FC36FB6E50 + +9154A2ECA919ECEC8C9B3B9BC0C68949A7291B9A645B5F2D2935C77AB506FF7F\ +27B5FE0962A9A912B1A05DBF5141D03E4401E3649025947EFEF8C0AE5A1FDFBC\ +FAE5487347174FB40A92550F54B7C8261413A50B8D4E6884BE:\ +CC1EDD80A0FD2D06320F90174E4DA2DEE7CCC33AC342C03FF0FD9ABCDAA269D3\ +EF75D24477B888F32221EA51A41866656A8CC3B95C601A95CFF53783179DB18A\ +F5BA92C5631342182F283E083AE3E7461A809D1BA74F591235BD66F338ABCCA0:\ +FC62D9B01185D06CEC0261D6FD496086:\ +4D689251DE48BBC21776AC578B59F6D8 + +A15E33298652A3E42473AB035BB94443A4CFCF9BF8F4E072898B9375E0CDA222\ +B07F8B902BA73F73806F08F85C13114A68EA480642CB3D459F0E1B04E4F88133\ +2CB5E05E9E358C91000C09A9F129A197339BC2A8B456455F0EAE:\ +BB98AAA7FC7FAB8FB8252E69E54C2DF97F7D0D2C0BC3A679F5BFE2E51191F8DA\ +0218681A3FA59B9D6584C4F2B1FD3A990764799084CAF60A45735B3B8A480CE2\ +8BA1EAC185601D4D6D76F25D39891DCA762E21D7D7911E4F4ADDFE7DB52DDE7D:\ +1BC51FA499556AF60332AD5D287C01DA:\ +8A23C560B6F0DEF3540A72423DF2C33D + +D253DF61440DCE5FDE0C166E99670CE05E415CF2AF02D55A03F9419DC53B94C1\ +83660DF91681809E64B5ECB77C9180487B95B4AC06F484EDA769194AA3E72FFD\ +6F95E475A925A2420040B004610B212102423D879F821E196A5A88:\ +775D59961E58EA72CE8F2173AE47E6BAAFEB68FD85BDE05346AB017D38954763\ +B90B63989A1487326510BDBC75637B06045369DE798BB97FD4885B44E1B42653\ +8F5C904E44D85AFF8828DC56329B55BEC8F64BF7957E837B70AC729D03A249AB:\ +F7B9E5CB7DF60D8F760D691B8E79C834:\ +B976C6CD3730B031060BEBD10E832747 + +B97529984693CE0621DCCF68F1690B49396E381E885AEECEAB3E1A7F61A8B7B2\ +C5E58BEF82FDDECD29C9D9CB5F417005BAD6B7EB0C57907F2E3AB3E557F11BDF\ +383EE5AB2902D46DB97827B26ED8C4C47368F677291E50ED9C1BEB3D:\ +D02E1E17E9274C18017105C929CB1FC9C84071AD0773E4880C84AFE08D243EC7\ +2B3570768506285CE5708E0D280673FF9F0004636B77266A9CCCC21FC590D845\ +D685B0F5292B9043FEC8F413E58D20844FBD626AC27F4A43A1CB0677098392DE:\ +6A42A8F7A638089C2E55A166F87444C0:\ +3EB4E4AC62EC1B18C96DDF1465C74286 + +5DA55FA078498CCC7D509213E96F8915D466AC5504BB9F0FB922ADD1DB7A040C\ +438470962BE659508C37F8C276E3C312D0ACCD1AD77755CA575336F2CDDA3B8E\ +39BF99CEE435FB23312576E3FAC190472223FEC1D693E2A717D12E7496:\ +4652C8A3FE43D4E4C8CA7C952AB5505F42959BFE42945B466F6BE08B512F21B7\ +C0AF4A818A699D8A61C2162D8FA4DEB2B94D28EEBE99A0CA5819F386F1BEE4DF\ +BF11F984D6594C6D2E4A5E75C0CA6EE74993AFE6817445290E0CA0A109AAD624:\ +483A477C5D7EFE8D7EE764194FE8E902:\ +F496A4D3745931C47A814F0D9F0144D8 + +92C61E6AB26DC701A371CB5B5BAFE00B2C44BD2736E856B1E893B7AAAA62C088\ +35784F02E3C1767D8FDB5DE91118CCA28585C5F03CB46591F8D3A3F09A0C602B\ +01EDE470CD42EBCDF4C72456639DF2BBF7897246D7F82FF7D083805EDEB5:\ +180659EDD79D6DDDDA8A64607957A449FB11EDBD4387863136650CBABD58411D\ +7CEBF5C7CCC8F9A8044626C644E1A1E303AC8B6E638B0817419BEF4FDF5DFD6D\ +6999CE8BD64FC09735DCD0CDD654824B6CD61A52B698310D116C1040526E7260:\ +2A2B340ED14BC9746488F04E2EBA7683:\ +578AF21489F2C8A42CF412A32906B1E6 + +9C28215AD7EB481E46752C39061377A489523A8DC9B62FC8E7CEB12B4E26CFD7\ +6F863B317999DD6F5A76686F9A4DD8E7558F64F9A0BAC89949A12D3F1599D7C6\ +4B6EA82A36F334B6055D0402048CA15127420FAC555E5E647814C4F4C6ECFA:\ +F3031EA9E88EB705899C304DB9B46F0817F3BD87FBB8178E3CD99AEE040D818B\ +2BDB27AD8034B3D31BF96783AB56EE91BC0F8DAC44C43F2BB0790429B8936991\ +E6652D69BB1F0C2B0577D7155BE3E5B34E1DE64655769740B2C35EF8DEFEF596:\ +3E433ACA43F4CFE3ADB678991613F6C6:\ +1073F4ADF297DF3FE37A0AE2B25C4A1E + +45663D4795BF75D79EB3BA5BF5A9675C257E526B190B598562BC4DB4D441025E\ +B9E61E95243165B21FD6965E2973DD04A141097EE5A85E535A80862B5D14ADA5\ +214A98DD161620D1B98B0AA3FD66A1D31005AC822F290D71D88B3B02F1B9EFE5:\ +85B49563722FFBB04C224DFAE52B97D7B69DE241C854B2CA795527957BDEC3EB\ +E3A47BD259484F0BC10EF487B00B30638418F1F069888FD347F4714589D12B64\ +7DCCA4F275B5DAF428C4EC28122FE7ED0E980B68FBD5B89925DC0E3BE1CADBA2\ +C9797F7FD5B07BB55CA139700AC5CC82:\ +94EAEB3A2E109BA196DAD6179CC6E4E0:\ +D0D97DF76AF11FA9120CDB1F4A0C5519 + +25994469BA58D88BD0A68A82D216FF3C15C8A1175CC712138529433FBE2E4058\ +A94968C115C29AA80094E99F34CA98E0DBB6FC2DF165472262B2E4215FA63613\ +3B9674B2098CBE807C6565FB2FB4600CDF9D81861EDD9C7B01ECFACF711CB7BD\ +31:\ +39C4F62666E8B240DB0968C11645DAB7F39EA201CAC1DE82CF08754192FB70F5\ +6DFF8E106E22711F7C11B1E08C973076075812B0BEA56BDD983C0891C1075295\ +08510E47BAB4080319ACA3AB3F5C647BC1962D3B91C4EDE3DE437D2C496D7653\ +16A153AE368FFD97F9D897A7A4B41B4D:\ +931096F41AD63122418B0694F08A5D1F:\ +BFBCDEC1E1336D3B0AF876771A8394E2 + +1F6C82684870A592B8FC13963078BA8A18BE42F6569396D9749C4E729742F3F5\ +94613FE0D47C681A9ADF5CB1AFB4CBF48B6783E679B5782486EFF08834908345\ +5DD97106FAD8D34C0219C32A2948810973C04406A5055629B3FEB44F086ED1B0\ +782B:\ +A7860FCD31608F84276797E5E62105D91D485D83EB591675B2D180EFFE41B795\ +A0BB525D8C963257156C16BE7D2F23F2303878193ECAD2B790681AE7D9D4002E\ +3644EC064D633DE7AEB9FE7F2F7A323F369AA48F28FAC66238BBA99E0263F51A\ +3181B804043C835F61F3664B1B1085EE:\ +54DE58CD3277EA8CDAB1E14AF30B96E9:\ +DA5A911787618709C0DDF10D4D370C9B + +CFA3BA888B4985577682E7BC34390EF53ED46677D6ABD2FF005D9B47CE9FE9DF\ +64DD6C89F61912FEC07B212CE6D4A8DC88AFF9F7E96F2CF1803FD3FEB9E538CD\ +0EE34288A3C84FFAEEEF7789AB99CA574D6F71A4A82E28396532830A1737E5AC\ +F1B768:\ +B4A9126CE1706351DF0AABE9EDD2F1E1BA10928DD2A15448A07DDEC6EA78C854\ +B98E82B6AFDA1BFBA57EDFA627A351C2F3819906FC9950844230AD32FB1EE0F3\ +4ABE20D488B36C693E35A1A177EF69307C675F4AD3A182AB20C395582DACD33F\ +30B5C7470D9BC2CCB5AC4CB39D5E665D:\ +DF2C9BDE5AE112FC52CB4CD935650ABF:\ +324E72A3E627412FB271C62D87106AD7 + +11053DEEFEBC7662CCE5373FF8624FFF4832229980A212A8CA936FB6459A53FB\ +4731936071BDC21D916C85C6E5F0560E6294E67979A8FD00AF9191DF4807B3D4\ +54D4F57FFBEEF3CC2728F9306DFD77AAB3259D4A72771939EAB7B78581CCD272\ +6DA93339:\ +22EBAB368D5548D61691A4F77B6468A4D9AA2C2600009C808EC8656F58E49D8D\ +674702E090E5910A4C67FD91335D149126478FF6FE2F342F42B8F50618EE6DD7\ +5A07E4A90D3CBFB0C2AD6CC1B9226E2522871C017C77A0345ABA7E44688AB5DF\ +E4691ADF90FD48843AEE7D3C289FB6D5:\ +F76BED433BAE0EED648D1B28878D4134:\ +2F8F480D2EBE3F01D63C7D1E1AC6AB64 + +574A77F969620F53546B46BD2CC524DE9DED870EC2F6B9F61063FE9E9A2C4C55\ +483B6B4172C034F04EDED86ACA242425241C984ACEAF7EF04001FAA887E66BF1\ +C33594022A968BBBFDA3A7D9D9C735F461DE459DECBF12093009E84618504E97\ +037EE7A648:\ +AAA424FAFC30A2BEDF0644E693FF02B2BF1CA14285092E980E522611BFB3A372\ +7F68BAB53F5B9098C1112716D4B848882D4ABD847DE3A6F5AFA0BD8D7834E853\ +D90CC96F1C35F7F3E1DCAF6B227031C70A29EA6B902A5A1266E16364999D5BC7\ +E9374A7467F4673A995D9D23144FBC6C:\ +9C0A96F10D955F3115174158E77BF4D8:\ +A0F912F87D0D937E388F9EFB14900921 + +1C5AF4082A03011D343A22628667787D1ED78ADCDCF4609C133DFDED8BF179C2\ +96A7B7E023503F42ED1ADC8676909A42DFB8CD7A5B57F77B4F13907B25A1D28B\ +787B33631B46240FC36B5D13B059312991F0A54DBC269787EAC7D4C02E8BA8BF\ +511375F0D18F:\ +2F86A992559C65306CCBC9138DA2C1987C168FF4278BBEBB4B48B416DFF7987F\ +9BE993AB153B8C3B03D7FF1E4ACABC2E645A108382F995C290FCE8D881BAFF65\ +3F1DBFCC8B957CD7C424EB5D91D758960233A48153197374F1649830CC924437\ +7BBDA7EE7C363096A1E0B94F83A75F2E:\ +0E10DBDCF81E7F360D3CDB71AA1A6200:\ +A44C029268CEFA5C2665E9C883C9179A + +C40A8815E2982C32C417F4B9369765F53D1546EA3A39CD5E07DB465DF161F878\ +D8A361069AD0BA13F158D6F955A20C0F0225B83CA4C6F1D92519F26A8C711ABB\ +68140270218B13CF2F85F008CFC5C62490FEDBE6DB2E0DC5978A365711E072C9\ +13F81B782C1A8B:\ +D57A23818F90CF982C32648BB61769DB8654CC81E795668A7AA6CBC1597A8086\ +E92EA40A8CF4950A87D3FED3260E5B30C90333CE3E90AF2452A6BD0D00221449\ +7A850DC2E3E1361FB689CD4AC25BF304F40D0ACD6A77DC96B5A52354AAF09EB9\ +E45E34CEE834EE78583ED0763C2D9583:\ +E8CC72398A38C02705E33FD308EC023D:\ +0982EF5D081AF4A2130AA9DC5895F4B1 + +8C38B56BDF41611178CB12970D12CDD3BA2A09BC9C90684C853455E70D995F94\ +D0C7CD30B572AB9E24356FD3FF66CA1AA913C5E4B596A30C504CF22592AB5BB2\ +66956C8706EBCEA543ECB8C07A9557B65F72A66328B92037A9D1EE4DB32EE7FA\ +DDB037BD75C5A711:\ +AB5B987C10DC96162447A9DA1B70DA9C7D6944CE39EB0D507715671E7AC4FFC4\ +663ACEB5FCF4AA8ABCA5CC155EC57FF43AE23E8854022F176D620B89B01C283F\ +4866696FDD03B4CC262F3C6BEE590E26A25914F569592B70D017D872CC3D3A2F\ +47B0194D7EB425442F3335FF0EE3AB05:\ +A9AF40EEB9D7057C167C020C922789E8:\ +DD54B94CBB23C203486F41CDA7742B75 + +05EA52CC288620CA6E4A8232F1F3CC99097438471E6709C146B9DA1B1AC166EB\ +E968FA273A8EBAA577CF673959B10D9008CA182F5075E86DFBD5BFAEAAE69013\ +5CEEB445088EAA7F870B71D9BFEA7DCDD2AF5C37D4DAAB468D67C70C1D556A10\ +A33DEE93C2B1FFB758:\ +1410F5CDDDDCC1FEC3E6793CCABCBDD2A1A14FC0D40325A9D6E69C4FE4D87191\ +DB1BD4ACF6E4727D7370EA59B77FD5E8F02F38CCB35448201363966106388A3E\ +007C4F76566F589C5326A847424FD0AB647974C3CAA452D95AA4CF8D86BB0939\ +B430E6746D35D45576EA810DDEF7DE73:\ +42E4792765C8D601F647096128C22E6C:\ +C0115D81CE8541848E778E2B90652AC2 + +7104B9314233A3DDFF2074862A21B3AD6CA9693785516E2C7A4EE69A823D82EF\ +0A4C57C3F5113C62D9B1E755F9EB7943D432C87EA9C6004F14281355DED99982\ +1B1ADA56C68736FCCDAB111ED640E9ACFD4D164310925F8E3AAAE63C8AAFA382\ +7B0E45FDCE03EDE162F6:\ +F53F4386FE121FE5B734048DA923054DD12F244CC12763FFB8DB1E9E842DA312\ +1827DC297AB6F11B8278E6E96ACABE3CE23E3C251078734F337E9BC92FBDF38A\ +FD0FB2CC86BFDF16595E01F361A2F042974E6DDBDE8B2AA10CA755BE051A0CD5\ +8179AA4571664A3980B0E1DCC8369F15:\ +7B4844C6EFBB9F47BA2AE3CD350B00A6:\ +2AE654A8577CAFB65B43407C0C6F23F7 + +328C825FAD8E873D66178434F534E832EFC8B273BD74E133701184D59EC5E3B6\ +1B58653B6646CD1E91AEFF9B4A569976FD055C3039CE76AB5DB5AADB8D479064\ +2D99346D9FBDC193B782F4F5C16F2F1C60084BF57B40736DF186EF9DBEB12B83\ +45FACDA9A957D20666A1C2:\ +6865D8CE0ADADF051BC5751DDC7DC02BD3E8425900F493A9866F9B0FF11704B2\ +6F949F38547859DFC1F7E4EC9066BD6825CE5596C32D97C11CE6ECBE63A58E32\ +C3B423114C1E4330789817AE298381050607A1F8FBD37246763CD98128565AB8\ +9FB05942B02BA92337E30E5F9F87A1D8:\ +0C76977CEDFF0BED19FD14FB31914BAE:\ +867FF78C9084E6B866BB74FF1549F0E1 + +1018329626BEEAEB50A5B078726E9BE6074CAB2FD2007790102626241CB54114\ +52B28C696FB5DA1BEA90BAAD90DF0F15A559FA821423EB500F0D76B785FFB7BC\ +2470509006CF192C3A5AB61CB6D5F7C6506C740C8BA763527FAED51748E33477\ +5D759F904B3CEB9520EEC9FA:\ +E3C6C758EE636F36B674E5D06B3FED93F848D5C781772E31A88EEE0F84D4DDAA\ +BD6BD6D439D36AA5EAEF61302BE6968EE3B786B5CAA20040A15EC740680A4E0D\ +788E445AD1D00CA2FA8A4D32D0C80821AECC9668CCF8D60D74B1BF960AA42861\ +D9339A064A7B50555ECAA71A475A87AE:\ +ACB06A6D35664BA240105546AFB89D88:\ +C4C566F5BE990271C34EB38B66F4A6B8 + +D30D40FF5BBB7E7D4BFD03B39DD4F7CDEEA3EE36CF59735140A2CD884C341885\ +A2ABB16B42883C17D0F8A8EA49932906C51B4E0B195438236C929E46C3DF0400\ +D6BFBF7E7CD09F78ED819E51CAFACF184CED6D9854F0C7FC3D4E2E92BC07B979\ +3F15240C221F9CD951BC1D8F7A:\ +D99D6BE44B4B07DEC16063AE56D734955FBFA4BF24156531336CBDFF718D1CE8\ +DD9414A5137F0F193B22351BDC56E4D62E827ADE0A414DBBCC99DB1FFB700153\ +0AD06D22C1685B7C608B97C9F282EA506C87F8F1E861E2F56AEDF96D02BB615E\ +222B9F83219D7C79E30E0A830DFDD089:\ +3A57AA735A2A5BEB67002A4B4E0F0FB7:\ +0FB689E2D76B4CB6886813714F78A471 + +D3C88CA0AD414F6A88903D4B2BB756CA44717CE6C542537066A898A343A3DD6A\ +E2609E717DA65C9E82777A29E5C134942455B04E5926DF69CC1B86EA95805AB5\ +267E9C456B29C89FB7D5EF184016178C8F5170F6456CB2D3A288264C501208C2\ +F71578A794526A40C02267CDB749:\ +12143011522BADD13CA2D5838548F63585804175B21B47AD9907FB3875049A17\ +A27EE2C7E3C9FB61C4F1BC8795D9FA8B267B698A216BC3E3370A04E27CDAADEA\ +D0C18E6F8564F3E82A779B2EE149F8DAC7CF9C7DB7E83BAAC17D366E3497135C\ +4D59C1C4D0DD8BE6520A1415D7A12729:\ +25C1B9E50A35623397E026342290F381:\ +99CF0F3E276941A23B8BA3AE4BC36FB5 + +1FA6BF67DE5B0B29BA7B510166D06CD100BA68E03EE4CC8D8340E1BDAAFD00DE\ +840147243E746C85F68409F62E474505BB8FE6251FC550A2D8C9CA071CED983A\ +57EAB7D7A0E636E809163E29677388B2E96F81165B4B7DBAC996D9DA923BF3F8\ +9BFD7E659AC6BAEEDC2C1F223C85E7:\ +FE2F1AE7085001374F5FE74E6C243763BA979839C7275B817FE5B1D93A8D31A2\ +C265B646ED0E9BAD5EDE61BC9A6BD7FCBAE22D818DEAFF76C39CE6F8F4302F0D\ +672628B36A1FE1DF90697408AA636F0F2EB12D00A87C1660C03257EC7F98FB0A\ +2750958FC5769FCE8681001134A4EBB2:\ +3FE0B766CCDA7B8AEC8FC3433DDDF5E4:\ +E5E7B817F2B2C47395F3DC983877C6C3 + +CB81F985B3551A1F653816EBC8472DEDB58C5BC66049A33543F92A64D9B06806\ +78C5AB54FBF03B7CF1CB964E903E92FA1D7D0C3A5B4E2A8393687F0CD73693CE\ +EFA32DBBB854CDA1BABF629CE10CFEDA1F16C8A60B9419069468A5D8E3070403\ +5EC4F7CE7D67A5547129FD136908C33D:\ +BFE9B413104A26F4B3B86AC448F793F138BE0DD31CAAFEFA7AE2AE69BD09402F\ +70F921081E66D0F3A092D3BC28CF2C8837991A200930F260443F9755F8AD46DE\ +F08FE5020792BEB7D2241F5D9B290A4F5F849E378B8184AA616B081196A38439\ +3FFD2A15622029829F0BEC293AADB6FEB5893AD9DD2A4B46A32A033FC06BFDD3:\ +7E9BD6AEA141BD2399CF9C34D8FD0EE0:\ +4265EE0DF32B9E35411F3890D981224B + +AEEC500F45E292E59DE2A9C4BF4B0BAB26E920386B8AF44934C5DBCE4BA66ED3\ +B294F0C4F4A88E70CEE9F9690E506A1C6E1F2B6E9085397BD3C8E197E8295728\ +815C47D859E0FAF1C5FA2ED9237FBFCA5843A9F99EB40E53554043AFEBE394FC\ +02F47E6734D3F01FBF0E4CD7D21FA3E631:\ +DD6A11239F7AD4FBAC8948E6E2D2F27D6EC5C818FA6501B910151B8CB3B5142D\ +AFA7141C0310F3668C7C79DC1ED8144F01D6B0BF1E9574896997545BB441A5C2\ +5CA4152492A1CE498B42B0D8681E47FDDF2F240C9D0E52B516F459C5AC029938\ +1FC7964D9A4EA8A28588F62D8BCF98C10C23999B81C20E971E4427CF32B72EC9:\ +DD22660F816ED9248F192406874D15C8:\ +5C25277D16E491388E300E43463ED773 + +255BAF2421268D3A748F891E76B7507BED31C86FAD52BF775DA0C6DDB4849F13\ +8E4246BF66449217FB62AC389B70D0A772D3B786526D358A83EEFA4E963CF5DC\ +473EBD53DDDE847F32D4B62D9616D1B0B37DFC552EB853A66FE62B58370756E1\ +7EF4D4ADBAF23091E5FC9D67CA0DA3FCBFEC:\ +E73F4EFA1943CE9EF9704BB173B14371056DB816BF9CD52D5D509D84417393D1\ +C3ABFCCF929F66F01E7CA8FF4E78BF73E3CF63F4557075875BF049A8F92CD8B8\ +B69F40CD384D94A2D6A217292834033CD94BA0A06D0B41B26E4F8B2C5F7B6079\ +630CD17CDDB518811A107D957645C7FF570E7F16EA4204EE79C625A5E9A873B4:\ +85F6C7EFEBDF11A904C8741F0C67411E:\ +60F0D61421D0D6F46D6BB01213C2AB33 + +F3CC75785335B638C1299C6D28856E4D66C060488BF17DB58E989EE2EFCE3D86\ +71A8949051543F360D9ED2C6990D41DDB9DE2EB9DE00D93B058E560786F6D065\ +C8F31B980275AB44F8553610ED91868B0F2200010B870C5F523F4B7059CBE889\ +F87103241B4BBD2303445144E0F183781801A9:\ +EC768FB206FFCBF14D21E57C2231CFEC6FFCA8F1679C97F1CD7F295E4E1A531E\ +F9846B2AB7B4D897D7814A124B3BB4BB6B3165A6B37C2DCD5A8BAA3F74735213\ +E52299B793D058D3D6AFEFFC08AAB7B746D4446BC264DF72AAFD9DE23091287A\ +A93C5267364A292A56EB20B011B4896021422527FFA26F3B8B833EC117BA4020:\ +B52E2A13114DF2F34844234C4A170705:\ +7818531571C5F69B1B4CF26F75DE0F21 + +0FE31EF68E81FD5CCD82FEC5F2CC6014AD31E41202A0E4C9FF8830C79DD77EE0\ +FA45870BFB3F8F8D0572564793A348BE277CFEB269EC1163F898E60CDAB5E729\ +87F1997B09732CEA505E59E6EF1230F638123CC2305DA0DF6BCA214D7775A8B5\ +6A712E73E426FE35C3D0B3F2AA2664EA0D323F35:\ +FF1155A412C0B8009C06A8518EEC87CE4614A7946E6F06760FB86B8BBA29485D\ +B78A2A15D168A0CC53FA494463A803FD8D702835754F0A1310B8AB33978D05E4\ +4C7E2155997706F65CEB71388B822230DF2EFE65B02FF949DFDDA0B6C6863334\ +C9F58B0AE50E3867514D53095483A19B0A44DB1ACA793BE988398FD3E523D3E9:\ +0E9881250175DC9F6564D3553B3DFDB2:\ +116C34C3DDB5321A21F100401EEF6390 + +A6EE4E43B382CC75FEC27BB90D2A3F204CC995033AB707FCF8EE2E7E76A3D189\ +BEB002EAF964004264A7D712AC5560AA19652C0BC593DD2231B15194D9221631\ +E09E4CCEBD1EF599AEF836772514B6D256F6BC22F05CBE6A452BE56328524EE8\ +B7A1C1683108BEA36BDF538A8CDB871038420CE29E:\ +52F203A1ACB1465A9D2EB0FCB9CE83957F4207C7649D74FFBF8EAE6C608EA87A\ +EF9CC76B90E28A73004B5D9B074BAE04888FB02194BE477B18DCDCE5E738DB76\ +10029DF664EB8C9C5887914760D69257E35A5B40885E2ACCF160AE0B0E0E59AA\ +CBBEFEED01108AFFD9A8F6A22EAC8B504D084BF6949823D5F59DD924AC52318B:\ +C6B2BB588ED1B6A954710036DB0166F0:\ +5D54E4FF322F6E012080E8FAA242FDE6 + +D69325940CF2E33246F5C0C931BECB9E0372173963F58FAAC297AF7AEB4784B6\ +0B16E98E2E4174FC1CB73EA690A4ADFCD38E4A955C7F1D915480C028D30E5849\ +2C0BF7DAB257D5DDF2230B3FE0B62B73B17B82F01D661E1AACFED564B9615995\ +EF7E0C81C373601BED078FB4668E55704119300BB31C:\ +6D0A03A606901BAC108C80DD968AC128964588F8E5B3BEF30FA0AAFE5092C5B1\ +B118B2FAB9AF379D701FBF9354B99048DB408B7CE3A954361A2110CA97386DE9\ +E0A8B52B86704D69BFAC08B77F3B961D39105FB3646E2075040C169A9388E68B\ +C36ACA6DD627036B15B2AC7424D11AFFA0BEB4414F5360B4349B656D8332D638:\ +86BF4DF958BE53CC007923FE8D6556AC:\ +20B3C91A3B5A66A6AB8599D01674AF45 + +E05554670BE695A32D397A2A6951DA076F4B760D0C6B7413656B8D38143056A6\ +A6074E4280D4EB70889B39ED6A27AE0F67D7FFD31A4933F8CD300BAC7C810162\ +D2F91CAFC8BF4238A44C09D06AD503E638AE1299E1575B2B3B3229A9F6A240C2\ +3F1534CEAB344FCA12724D8D185C1A96DCB3E040000B95:\ +05B2E6706BCA5507BCF4399F466212CE875C9C94436F7AA133630A3CA67A9C84\ +3230FC445177867E73A9AC89F7BB32C6653F1A30E4859EE98CF7BE8C5E1479A8\ +0285AE091AE932060F8093A63AF1417FADE414F33190359587A30280B330C657\ +E3DC35C8A003ED7ED92E61ACD08049C716AC2F12F362C4FFA1EBE7B7590C6876:\ +915AA4BE886620705DEF24FBBBA40598:\ +46A4D05C91E7931956C459CA51E4869F + +8E97900728874829423FF9E65CB2F3B4E3E720BBBEC1A3485F34A94B7580001E\ +5CC450E6D76516DD9A8E450320248441074FBBBCF9A0BB3702B100126F5260F3\ +81DEFC536D2905E78A3783CA969730AD188D34381D353908BE269B10ACAFE287\ +BFB37E93349A7F6FA96912975B817BDEBA0500B87CF95680:\ +2B1C832A0210ACCC143745BF8B4A32EE68C86584868B2AD2C64BB802D831303F\ +6028C0646107311F22ED520E063DEE06A2AED4F22D6ED762A299149B3723D30D\ +264847CCB233E8C522B1EEC6458DBD238CF15A33B55627470359A09483C66B66\ +2EF012EE8C26A92BD6E12634B413A1A27813C0C6DD39165B5FAE54069ED2486A:\ +6FA0FBBB491F305F512982ECEBEFCE3A:\ +20CFB9FCC146145657841CB97395B14F + +7D15F0ED3E7D504B3051AE6C00E01DDCD7FA4C6F3A3F3E0E9FC945847BAC9207\ +6D92C9BE830AF40D473DA1741DFF53EF78502796B21B66E7E37707A400EA7BD5\ +44FC234B655115394DAFE31C5CBE48846AD62E8F15B6D346A50CDAB34FDD2859\ +3D5B369BCD7D8F47783BE8CE2F5735C50AA266667E421E1E1F:\ +91F4FA1D9381C08E9C635ED7BB5D12421F44F80E13CF665AA2EBD06052B3DF7F\ +7DD1952D1BFC6B61E37953D7EFB4CD152111F74A80CD937FD88B83139E7860B6\ +78512C8A2D891B1AAB080C77B25C226F9C319B6B21D804471887A8EE9DECA336\ +B29988AB80D6FAD00A7E1DA5CBDFB757E146C592323CB381EF40166D644570BD:\ +5896FCEDBF16D103B6CC4909222B1493:\ +F29D9A05434E704CAC05D280A8FFEE5E + +9FACDD624D109102570E789B4BF006C1F0C24E95ACB8082D522615082DD933DD\ +550921F38907BA5AC30846F9CC63AE18BB46852E8E802CB9BED8C09F049D6B35\ +292767D4615648656FA05BC1CDC54A78B00E70A5098A884D0133171D5D884621\ +7775500B2F33EDFAE01109DB72BE4782C3EA1F839A1134C01A55:\ +F2D12969396FC6DFE22BA80E9F6A176C9F3D91536CED8CC2A83E1D2A7DB83C1E\ +AF6B069522CC1CABF7B30E6B1C082991D662F847B87F3DFF40C7A3CEC5D3D966\ +15640A3B48B95E755CA22B3B0B635C2A56A61F2A8435E1106F62C79D37372B82\ +BF71F6043C44813EB2E12729AB30565FC718392D5FEC1AEF0DFAB649EBA8EABA:\ +BF380C44E37BCA81F3C6036EA3586935:\ +32F440D2ECDD949684D4CDA9586A28F4 + +6A22387417FC3ECEC9443041CEE5E8440652146BBF214663631A4ABA37A5920E\ +1BC9611FD936729CDC28084B451C3E08F313F31612C2189E27BB73B48F581C71\ +17DB75CC22D821911CD70968B960AB771C83EC6BE2DEF41A22E36734EF56F250\ +0D3EAE610A860661DDE7F9EF7BB75FE765C427B79C545463747BC1:\ +6A9A030F41BE6BA42A1E7BD051794848D8A6EC6B57F4A0CF44A937A42164A767\ +D8799B9923F501621800E05BD2B3F65A890AD5603641ACB2E980A06CA3FBDE32\ +43CC2BD2AB50119576FABAEAEE19D75AEDD91616279A94F8B8B7F6A89E423055\ +718DD356250A3D466BDBD35322ADE654DE176AB4F2740716D4D6B61CD80C065F:\ +B81F13EAD324F6F9F9E45659D72D0EB3:\ +122A6645EFE2F81E6FFC8E4418ADCA30 + +344C97F9A847B33B5A950F5EF4EAB59971EF86D2D11C77B4196DCA55305B5F71\ +3303DA12E3D5C736B129706477BB8F71F3C81819766DE583BD915BFC4C9F528F\ +32D2A4DD4DAA5C5286415090DE7CEAE61BA1B18937CD41E69055BD5A99C73DD3\ +92606FEDC0D386696F2BE9002980CB5F1EE5135974CF859E802806A7:\ +16984B5B5369FD385CE7EFE789D8B2E80F3A7F3ACF0AFD8D00E7C31D7DBD24EB\ +0C6DD509A4AE6A1C04A7A322BD897D307C421EC9A1FE1EE935CAFC27C6FAD7ED\ +0617D184B75726FDC26174ABA388836A99CAF23818A4707EB60A233302E09CAD\ +7B2F7FADD02A9466F8C861D481023016ABF6E57BEDD4B288C8A81B7EFB8A4485:\ +20FE5765A855346A157FFAAEFB7CCE31:\ +F9147EBE79608EFFEB722B28AD6138E5 + +FB5EECD4A3BF6C6B1B0B4B4FF7F702FCF538AE425B5F7419687ACBF263F95872\ +90F32BC9D146A651F4036346934198DD14C0187BBB50834A627ED9136D8E51E5\ +EE2D4DD3D71A3546A3DD91F205905F4A4ECB83F1882E8D20A84371CF8886651E\ +DA9601D6A3E7A6B60D7B90552C19F786D4AEA805A7C5F9ECFBFA69776D:\ +BB60147DB21B8968AA6C60DF45053D8FDBA5FF5C95D468DC01A4030970685AD9\ +1FCCFCC5D35E19E50530EE6C3BE336EBD39BAC07E8C3B966692F2BE6149EB26F\ +E160913CF23BB49B30ABBC97468F65CF347EFE06DDDE60E899E28B801AE21F45\ +1470041F98F8A778F75E03649EA7CF6013FF285F8EB1CFBD8760B3DF147AA796:\ +01DC3A0701B7CE3EAFEAFA1A5FFD1B88:\ +213F409C520A489A000F30016C01CC21 + +7B1A9F40AC8BBB0E7E000CDFA8A715D9AAEA5C8488DEF0C31C4F5C4A2F2257D4\ +80F9C669B3023699C14F59D8240D86382E8DAB49F1F4FA10C69CE63137A21D17\ +DA7001BBA5434C577B7F17A22D5ABA62CF0169FC686AFA28EC780A955DC00332\ +81F569AADD0A7130FE25E8D517C78D90EF6FCE96863A0356FE9664DAE677:\ +1C3C3D5AB36DA982C99679AA52D3B6D91E64688958E72BCD7DA933DD509B5E24\ +6277CB1603125002964FF838EAE8769CBC63792BB5F087D31F12841D9776B523\ +3FDC4247679A99C050DCF0C14E8963D39551885F905FBA72C4689A92CCFE4837\ +82723783D560E6E8ADADB6F6BEA0762BA6F21F539E14BAB48AA69675CAA69069:\ +9B9B9E1B898CBC46D32CB73E38F4C3BB:\ +41C1C33D445AAE243A762D2A5EC6B719 + +AE5940BD642AE3A0487BDDDBCA420107E8A42982812995C5B6F97CFB7B1D1898\ +4D07151984685989294BE42DEF6CC4D0BFB41F2F100115ABD1F36407522C728E\ +84C3EB0E5C156B89C41BEF436FC0EFB1BCFEFB876936654F0738893D601F57B4\ +E791D0854AE1C6482D68355FCA5BE8BAEC3CBDAC383D187BDF85845843D400:\ +86F1B8E57A56C1936D226EB3133F8FC7368E172ECE39C70C39736CD17711C20D\ +AD4BFC8C445D1E94C6E313FEF1BFEBD4865805560E295F20E6860F26A8B35ABD\ +B3B64C230585E1E12D1C83BF8ACE9BC76141B2E9C7A7D7E3BE69C504AC3A4DC2\ +370918C0930B660106B90EC6799463EFCFC7FD057113A82134343AD3E51CB32E:\ +763992E428859B04AFBFCC8EA1670853:\ +38E2D175E535CC3CDAF3AE49A5D80385 + +18A0F0ADD69013BE387385E4B600D765FC39204E4284DAFB6A80062855C3C044\ +FBBBD10C41D13FF4247ADA22B6533647D2B5BD3C1BE520282BD087C04850017D\ +EBB7A2DD47527B2B9E3F148795994BE379790556C530AE12BDA2563FA0221168\ +1CCF34514DEAA6ED6AEF8568CF577A58606AE7E6384D572FDB7E17143E000B2C:\ +3924800EC62AFC28F39542F994316B1FD00CE52EC073030EA54493CBF259C2EF\ +96AC4FF8815A35408ED9A619A82094E3CD94426FE09469F6D940BA73E7F9472C\ +6AD14E8302CD46481E1971270B3EEEF22E0FEC16B530F9DB34385695EE904FA0\ +34DE7C6C1FA6D971DE0EDE7129DC0F6FC7404D7686ADB22383B0506CBDAA7888\ +DA1DEAEA3CE196301B311A59C8C28499:\ +79D8EE7B194C1DAC8D6AD992922B5E13:\ +A709D2673AF50F72F03013ADC79F8D61 + [DES/CBC/OneAndZeros] :79FCDEE6F5A94E74:0741219814F4369E:DEFD8C15FEB10458 61:AFE5BE1DF47E6958:3FAD1BFA365F515F:587FBFB91B510842 @@ -23587,13 +24657,14 @@ EDE3E69EE5B55AC758EB39E70E6533CC4D89C148F6AD68293E743CD82B9638F020EE589D:\ # From NIST Special Publication 800-XX (prerelease): "Recommendation for Block # Cipher Modes of Operation" -[AES/CBC/NoPadding] +[AES-128/CBC/NoPadding] 6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E51\ 30C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17AD2B417BE66C3710:\ 7649ABAC8119B246CEE98E9B12E9197D5086CB9B507219EE95DB113A917678B2\ 73BED6B8E3C1743B7116E69E222295163FF1CAA1681FAC09120ECA307586E1A7:\ 2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F +[AES-192/CBC/NoPadding] 6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E51\ 30C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17AD2B417BE66C3710:\ 4F021DB243BC633D7178183A9FA071E8B4D9ADA9AD7DEDF4E5E738763F69145A\ @@ -23601,6 +24672,7 @@ EDE3E69EE5B55AC758EB39E70E6533CC4D89C148F6AD68293E743CD82B9638F020EE589D:\ 8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:\ 000102030405060708090A0B0C0D0E0F +[AES-256/CBC/NoPadding] 6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E51\ 30C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17AD2B417BE66C3710:\ F58C4C04D6E5F1BA779EABFB5F7BFBD69CFC4E967EDB808D679F777BC6702C7D\ @@ -23608,14 +24680,16 @@ F58C4C04D6E5F1BA779EABFB5F7BFBD69CFC4E967EDB808D679F777BC6702C7D\ 603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:\ 000102030405060708090A0B0C0D0E0F -[AES/CFB(8)] +[AES-128/CFB(8)] 6BC1BEE22E409F96E93D7E117393172AAE2D:3B79424C9C0DD436BACE9E0ED4586A4F32B9:\ 2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F +[AES-192/CFB(8)] 6BC1BEE22E409F96E93D7E117393172AAE2D:CDA2521EF0A905CA44CD057CBF0D47A0678A:\ 8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:\ 000102030405060708090A0B0C0D0E0F +[AES-256/CFB(8)] 6BC1BEE22E409F96E93D7E117393172AAE2D:DC1F1A8520A64DB55FCC8AC554844E889700:\ 603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:\ 000102030405060708090A0B0C0D0E0F @@ -23664,7 +24738,7 @@ DC7E84BFDA79164B7ECD8486985D38604FEBDC6740D20B3AC88F6AD82A4FB08D\ # From NIST Special Publication 800-XX (prerelease): "Recommendation for Block # Cipher Modes of Operation" -[AES/CTR-BE] +[AES-128/CTR-BE] 6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E51\ 30C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17AD2B417BE66C3710:\ 874D6191B620E3261BEF6864990DB6CE9806F66B7970FDFF8617187BB9FFFDFF\ @@ -23678,6 +24752,7 @@ AE2D8A571E03AC9C9EB76FAC45AF8E51\ 5AE4DF3EDBD5D35E5B4F09020DB03EAB1E031DDA2FBE03D1792170A0F3009CEE:\ 2B7E151628AED2A6ABF7158809CF4F3C:F0F1F2F3F4F5F6F7F8F9FAFBFCFDFF +[AES-192/CTR-BE] 6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E51\ 30C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17AD2B417BE66C3710:\ 1ABC932417521CA24F2B0459FE7E6E0B090339EC0AA6FAEFD5CCC2C6F4CE8E94\ @@ -23685,6 +24760,7 @@ AE2D8A571E03AC9C9EB76FAC45AF8E51\ 8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:\ F0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF +[AES-256/CTR-BE] 6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E51\ 30C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17AD2B417BE66C3710:\ 601EC313775789A5B7A7F504BBF3D228F443E3CA4D62B59ACA84E990CACAF5C5\ @@ -23692,7 +24768,7 @@ F0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF 603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:\ F0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF -[AES/EAX] +[AES-128/EAX] :32E55CE0C3FAEA48164B122C1BE22D85:\ C61A0851AB4E515D11525B92E2B9D850:C825FC7C4D539DC74887CECC70884F37 @@ -23990,14 +25066,14 @@ F71566B677596557D4C218DEC8A7D2611FE6FA07633C558FF372308F5D680C0F\ E9E5E812B623D9E72C23518F082EA48C:\ 251AD494D64DAB08B66A96CB8C7876A6:F87A825C39326949EB19EE5BD30CCBF9 -[AES/EAX(64)] +[AES-128/EAX(64)] :32E55CE0C3FAEA48:\ C61A0851AB4E515D11525B92E2B9D850:C825FC7C4D539DC74887CECC70884F37 60:710DABD24D400F3B6B:\ F956B879EC7F807F1FCB482B53623671:E64F90B4619D93137E6237929EABF297 -[AES/XTS] +[AES-128/XTS] # Vectors are from IEEE P1619 D11 0000000000000000000000000000000000000000000000000000000000000000:\ @@ -24225,42 +25301,6 @@ B3D32466028D0BA36555E7E11AB0EE0666061D1645D962444BC47A38188930A8\ 2718281828459045235360287471352631415926535897932384626433832795:\ FF000000000000000000000000000000 -000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F\ -202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F\ -404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F\ -606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F\ -808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9F\ -A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBF\ -C0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDF\ -E0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF\ -000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F\ -202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F\ -404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F\ -606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F\ -808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9F\ -A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBF\ -C0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDF\ -E0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF:\ -1C3B3A102F770386E4836C99E370CF9BEA00803F5E482357A4AE12D414A3E63B\ -5D31E276F8FE4A8D66B317F9AC683F44680A86AC35ADFC3345BEFECB4BB188FD\ -5776926C49A3095EB108FD1098BAEC70AAA66999A72A82F27D848B21D4A741B0\ -C5CD4D5FFF9DAC89AEBA122961D03A757123E9870F8ACF1000020887891429CA\ -2A3E7A7D7DF7B10355165C8B9A6D0A7DE8B062C4500DC4CD120C0F7418DAE3D0\ -B5781C34803FA75421C790DFE1DE1834F280D7667B327F6C8CD7557E12AC3A0F\ -93EC05C52E0493EF31A12D3D9260F79A289D6A379BC70C50841473D1A8CC81EC\ -583E9645E07B8D9670655BA5BBCFECC6DC3966380AD8FECB17B6BA02469A020A\ -84E18E8F84252070C13E9F1F289BE54FBC481457778F616015E1327A02B140F1\ -505EB309326D68378F8374595C849D84F4C333EC4423885143CB47BD71C5EDAE\ -9BE69A2FFECEB1BEC9DE244FBE15992B11B77C040F12BD8F6A975A44A0F90C29\ -A9ABC3D4D893927284C58754CCE294529F8614DCD2ABA991925FEDC4AE74FFAC\ -6E333B93EB4AFF0479DA9A410E4450E0DD7AE4C6E2910900575DA401FC07059F\ -645E8B7E9BFDEF33943054FF84011493C27B3429EAEDB4ED5376441A77ED4385\ -1AD77F16F541DFD269D50D6A5F14FB0AAB1CBB4C1550BE97F7AB4066193C4CAA\ -773DAD38014BD2092FA755C824BB5E54C4F36FFDA9FCEA70B9C6E693E148C151:\ -2718281828459045235360287471352662497757247093699959574966967627\ -3141592653589793238462643383279502884197169399375105820974944592:\ -FF000000000000000000000000000000 - 000102030405060708090A0B0C0D0E0F10:\ 6C1625DB4671522D3D7599601DE7CA09ED:\ FFFEFDFCFBFAF9F8F7F6F5F4F3F2F1F0BFBEBDBCBBBAB9B8B7B6B5B4B3B2B1B0:\ @@ -24316,13 +25356,48 @@ CAE4803A93AA4334AB482A0AFAC9C0AEDA70B45A481DF5DEC5DF8CC0F423C77A\ E0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECF:\ 21436587A90000000000000000000000 -# Generated by Botan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erpent/XTS] 53514C69746520666F726D6174203300040001010040202091E4F9BE00000000\ @@ -25785,6 +26860,1003 @@ AC52A4BABAB8223A05549532ED8386F6D621E2CB97B829C0FE9886DC67CDDA9E3A0D19E8\ 00276019:\ A0C7A1DD857747698B49D1E6127F564E +[Noekeon/CTR-BE] +21:D9:E6CB9AEBBEFE8C4EE3B4763AF201BAE3:\ +1B17F86B0A89CB174F5DC673C187803C + +0FA1:8EE1:A4B6826186ADDAE5E4E5055D899F56E8:\ +4247E4911362FFBF59B407BB5AF5CD82 + +193D02:3E6DA0:DD4A440EA6DB12B9A7B59F8A56F9E0E8:\ +81ED06DC0A1318D286945F012C5D5CD7 + +96C298F7:A47A2E54:323B98A8D64754A9A33FFE88A3611896:\ +3CBE77BDCA7742A28E46BDF357674539 + +E807140F0D:1954A24EA1:4784F2F3CC6AF39DDF680A99C7771864:\ +E26C455121A66ED165E6C99719572BDC + +5B15EC624053:037D86CA7EA9:8E525E8F28A847EE0F0CD2983CBD2218:\ +1798DFABC785ACA2B0947B2200EFA751 + +45E0C038C4EABE:1ECF07B2734A04:42A9DF33ADEFCB8829DB8E04325B84AE:\ +0D0DE03906AE076872ECF96A1C8032E6 + +366BB3B18C1EE9BB:7EFB806DD92DBF81:F427B0752E20A18707FE6EE3A5E618BF:\ +509920DDFB13129FB166D7F15F4F7A08 + +CA3574A484B30C861C:73C3DF6535E7EA2513:3D1493AB0D6FA0480759227590200870:\ +33C02954E7B23D691DC9E55487B93544 + +7B7C1CF2E041771A7C66:D5382A6934345A7CEAF3:C3F327FD724506FDCEF4A1CFE91FC19D:\ +83BAFDDA70B7F521325D4666B097972F + +6F7ECF3563E45900D78870:CD7B586F2A1F6F1C33A203:\ +9D193DDC4FF8FCF4059DD58B6619A4B6:\ +7FBCFAE85957F510D3BB234A8CE3EF48 + +5C354F161AB87D48978BED40:7ED102A25E2D50B7FA437F92:\ +F7307D92DB9AF3F4F3D86E07066F8605:\ +4951661393781B8C65DC17E14D0B6117 + +279745A7F70E9C8F8279870A5D:FE2C6E2726177A56F151497E13:\ +8EA31DF7E30BD06FCA94C76015FC7971:\ +1DE58DD80BF16E30CC11EA53DC00964C + +F803982606FD583BF5AC8CC06AF8:90CA27B45F3BBA71239A2B7D695E:\ +D139C37458AFC755E2152F71F3977A84:\ +CBA8F0E570AEC74BB05AD388AD00A971 + +EAB7D98D9394C39C8F8B414892D34B:00106AFF5E616269337A1D03F9A293:\ +30934136861FD92DB16CCEE4576FDE5E:\ +1FC104FA8E1F5E7A163BCE1393C9FE9E + +5F1FCEF49BB2CCDEE1B0F26E69A68979:EB5534749B9FEFB16AB0B8D5E4A581DC:\ +3676C4095C06E9013491AB481CB4D526:\ +8C3B99D61432DAEA2FF8D5A72FFCA449 + +4F9CFE3CE3E86BF2A01AA4925D922B2DE6:5FBBB53B53852E977E7FD7BC350B0563D1:\ +8E23F92D86C55185CB5121B04C366A58:\ +A1BF4B384F7BC0E154F081654D282957 + +921157A2FA3293584B0AE4A63326251D022F:8F9D3B44559151D9FE636DDE0B029C3140EA:\ +0B04F22C6219A26CE72D989F120FE3BA:\ +FECEEAB827516C3A7A35A0A4431234B2 + +AA30402A478C8FA4341A98F17C03CFDBC6CF66:\ +3D84E0B9FEBDD66617EC4CD40B8DE06E3A550F:\ +C7AB8FE20D48280AC05348EB99E60856:\ +9BB889897236F3D9934432E39A678C9D + +F268E0F11C1C53B18373F7951DC04DC85F69BB1D:\ +D8D4BF072F0D743D942F15F082A2F5662367159F:\ +9F493B0FD458928C9F4E14E3BBAEE80F:\ +E41AB5247E989AB4828CA3C2A65128F1 + +59D4C8631BF4F21C857334AEE6BCF1585F5F0C5CD3:\ +5FF9E4072585125EC1D08AB79B744C189136D8394D:\ +728E75F900674124142AA337CA1DD561:\ +A488B3EBBD9DCC78F4F63EEFD6F95DF8 + +BDC114F0241652BB4ADA3B33FDA18722F7C8CA0F0EA6:\ +A554815F48F5E97A9D79F074B40D4553B7614BC1E1E3:\ +B176CFEA51C6BD14EFF032BC66F6C7F3:\ +0F24D4CCAEF29554B886B75382B6CAA9 + +CFF7BA8451ABA766F874E708A2762CB5FA20B0B880EA2D:\ +DA5EE8406F03D84032207B50F84DD490E3B78C8DC9AE3B:\ +F47516C38DBB7B8E879F0226D29318E0:\ +F85828355C8913A3D52DCA893C6AF736 + +AE60C714E058625A84B905D94507FF7A0D91CF2FD28FCE9C:\ +4FE77BA0D3C58497290AAF37D5C129C22B7BB62B450C43ED:\ +3EC64B66F25B7DF1B6AF3F64E072A4A6:\ +A1F158D936BB8D54E10B590EC36FCCFB + +D776BF1BEFEBA895F63816B634836D04BE7925C360B847A7CB:\ +012A6BB13F3BAE6F9BDC69DECF667CE8753E2B6F5C2875B45F:\ +29561184F97395058CC4FDE45B78AEDC:\ +77DA790BDAF8445CEF0B3C7CB5682FFA + +A34724CE5BCFB822B3D60BA0CB5AB46C63B98424E46CDAC89A92:\ +D7FEADCB3909C594CEECE8BA38C3ECD2CE77508F117095350458:\ +B3C263C819CDBC8E7A7296D9D349115C:\ +7080A7A1ACB9BC675DE05186805CB4D3 + +F935DF934AECFEF97B2F3C289E8E5F444CFF6EC8043FED9912F5FD:\ +79C745EC22125C4A5EB67A98E56154C4FAC1749C8823C912830B47:\ +945EF1858BE2949562316E1AFDBDDA39:\ +F621DD4CF531940FE1EEE47774E3A6C8 + +2F7B4634AE008B66DC1424763FFCD771521DFE4A8C55B83B3EB59A72:\ +887D0AE0873FA0575CFBE21018E0ADC15ADDDC4CA446FE9961560B5B:\ +EEB53F967B99F636DAD0E691DAC87E7F:\ +4AA26B55083FF42C0106E35767FCA76C + +DAC816A9AD72387DF047FBCDF545B67939FCC12C589B1B4358944CC6EC:\ +C62DFFDA9DC4451A0A4356A2BD15B570BF93CD885784C8DB3709B93E79:\ +F1C8548CE25FBC255D6AAB47D379DEA4:\ +2F03398A4FA867F855D844EE45B8EBC8 + +7672DE06D10FD6B5F1B3E5AC61F2B27746586CAE09930C336E46BA801F0B:\ +22C85E005F98728A845775998F23F5F9CAA6631B05FE3AD786551CE8822F:\ +1F534B2B8F89DDB9F70B83A83D03984D:\ +53C876314889F9D06C990384D3641EC8 + +C1D9527AA95E22C82B06DD6179958B528CDFDBC982E099FF1BE20132AB85E5:\ +8D6FAE173EC8ED2CA49DC9991955926DF776442DC1B017099AE357B73B69C2:\ +51ACEC63AA4B0DE98B36531375EB30AD:\ +23DFDDDA97F97A1BC58A5E3B228271B5 + +F49311B047ED65667B79E02E347232C305E38DBADCE1557BC9766D0837C808CE:\ +33A4561CA1D8D7E59F3CCF80202C2BB05342C4BE8CEF2D1C413C5362E71EE39C:\ +AE1F2169BFEB95359CB55717D36631FF:\ +4694AE380F4932DC01A035040EE4DA04 + +FFDB5DD9D9A73FF949F98031B8E54CA7D086D7BD83F566E8CBE817F7A5930E68\ +27:\ +01B2143586C36DEFB4300F3179A9CFB0C981A1C3AB7FD6134E83632FBC5EC885\ +B2:\ +17FCC4B22BF006E19FE47A7F3D1ACDA7:\ +9B24E8C1B46791511094FA0822AB94E5 + +985BAF3296A7807B36605FA762CD74033B07A0D19A572032CC90144A30A22B7B\ +5AFC:\ +95C1717EC7071A9C9365E8E8AB56A63C3F6F5188FD56D071515E654769263E75\ +23B4:\ +A744181C72A954702461521205CE235B:\ +F1E5E566D925F72E67FD7C16742FC5BD + +A571D98D9FAFF69964D8FD5AE62D998AA948E64C3EC2114F2966273722DC9A85\ +361D4A:\ +2D3776235BFCB3F176C7B82FF34B821DB0C637B3F906FC5E6EB8517110385CD3\ +6B2A23:\ +5E752ED4C2A65DFF022F75750E622126:\ +04E3BC70FE0B5287FB8F3B563B4B39B9 + +5A96FB6B4022B903049C1DC7B209890DA31B16D9A4161E861DEF53FF461C98B5\ +0D18F805:\ +5C7B8E2A358CE90696FA9CEC20C5E2D8ED1A2A6EF5E4824DEEC0BBC0E843F39E\ +F74F706C:\ +690C8B04CB3AAD2265D6CFF3D1EA21F5:\ +7DCD6F2721D22132F53484918EBFE4DC + +77552AAB1804ACF379E9FF3CD8210D36CCBE8B5DDEF1C416668953B4747D4315\ +D1D5643BFD:\ +D6222DA67139F9CB63E66E51CEC9B8C7F2C371D3F1417AAAA99A47BCAD4BADA2\ +9F8E552B79:\ +6A6B6FB6F30634782A4AC05DC64186A3:\ +EB992E4B1255989D047D486DCAED9117 + +E139C1EF006AF64F6EE97E37FC12DF87F93317D7F9067BB80E93690CD03A54DD\ +F8009032B41F:\ +7FBFF983C5B55472AA881DE7D639B672E53CA89112C454FC1BCEA3D5CCB5360F\ +8325DFD38A70:\ +F304C4DB0E3669597A8D760A596C14A4:\ +3446DD04202AE3F7DF2FB86B324514EE + +658A21D4E0B513DD7609A820BE3A0F55C4BED000A009567BA41EBC3695719CF4\ +2A835B42AA8CF6:\ +1FA58300ADEA19460C194BFBD799EE58FCACD72C943A4999959E74EE4226A72E\ +CF022C95637FB6:\ +5993951EF368014469C049140FF4C774:\ +A8CA0BAD1B2F913D0907D0AAA8C40AB0 + +A4BB6603C8706616B4E3932F4D17392A71F7C1798C8621E7420BBA20B7FFE69E\ +76A43D732E851EF8:\ +BE78096ECEF8D4A521BCB2FAE811AC748177438FED3FA3B69DD294038B189AB4\ +7D3E6D1725362417:\ +C15284EBF517E72FF4D6E700240B1924:\ +0403E95837CA6FCE033E1609EBC2E137 + +1100C1895AC0A3A551BFBF4007E7D14CAF9F7F4C6EE1F70134D7EA376C819AF9\ +DD8A5387DB47A68C81:\ +CBD14325C9691735B07716B0137F9323B9FB8A09892382CA2E58613551A52D14\ +65577C2ECC5F516E8D:\ +630A843465F6748FEC11706E0C1A30AE:\ +C327AE44C20C6B7AAA39CD482B0FAC08 + +3D9EE4E182C06BAA806BE849E1EEE0F1204B4689CCBE5A76A3FDD8DC814AB2CE\ +102AB08EEF4F7166065A:\ +F930939B3DC17ABC2128B4F57DB554CDAE8FB753E5982B63923F0FC2B967A4D3\ +EC37694390A5DE94E5D5:\ +71CCC4B282A3B8683CF7B23212C9755E:\ +BC3BE9DEC1C4CA5753C7ECABBED3BA03 + +6A429CD60FA9DF30151381700B21B297FFA3B422A6E5743E1A17014F1B4DACEB\ +E5D4E1EF5046B88F347BC6:\ +78F328303105166AA2A007F5A781EA11A4BB64A333BF379F05F7D8615520E8F5\ +6339648C2FB0AB9FB12281:\ +365207F51C75603FDDFCA7FCFD0AA943:\ +6135D9DC5EFCD2336B7BD8504F318522 + +19026566E90BEFDE96EA10ACCB15475BDF4F051451FFC7F42E93B94B1FB59C33\ +94E21960374B4E694A94B79B:\ +2B3C08655920C3AA770231AA83D05316299EA120EADEAF94884A32714FC1B73B\ +0A9B3B573A53D12890683A29:\ +03D889839F78DAEE42EB1A64578B0735:\ +2841BD9252AB693AD1488E74572BFECF + +4964BE4642F182D57708C17AC58BE92555CDD0A0C2B9C0F373FF0093EADB02AF\ +E934E0D316FADACAC1AF457E3E:\ +EFEE5CF69CDAB2C2D1AC105C6EC38535D91020D1B54D04C56D2C37E592FFB487\ +06131A352330813F047686D534:\ +7531E248C3607BF709BDE889983E8BD7:\ +2C6804B5C23BBB1F41DC3DA8B9B135C8 + +320A987FFDADDBDBDA13911C14438966E2D44BE18270BA5B65DC6799C981E34A\ +BF277C49B0EB6F147528F0E05DDB:\ +DF6ABDC41BDB76425F2D8CFC5F6E372D269FA011AE3C2AA493DB30F569B75DDA\ +1552920A9A0AFCB574DA7EBE5483:\ +9B9E8F6A1E642D3F148141F44A702B78:\ +11237C7423EDA19C1EAE0C84F6BC3B7E + +9A891EB88E6F35BAD450EFBC09CEA0779C139A9679AEA59597C98EDCC8B3172B\ +36683AB62D3249E8E31538592C8668:\ +02A25E9C253CCB466B6D34FA3B36D113A287F7AC406823EFAF0E3EB21120DAF9\ +2F484E6E9A2C913EC2B8B86E913DE5:\ +0C8F881ED6BFD47B5B8F458488634ED2:\ +623F903A40E152910B828F7EDECB0CC0 + +EE2D21B3B4D7BB0963A524126B86ADD09F17E07FD7A41A4CD0B957EFC9A9DF32\ +047CC4626615B34FA5BAC3EE160DEBC8:\ +EF6064B1616A36CFE516DE3DE86C273016E2AC92BBD2B5345E3C3D25BBB6AE55\ +F1CB79C896A5115C61DF76BC93687DB0:\ +E0D6BEC46CBA9137A4C19DC9ACA26B22:\ +53088D58E6BB077E85B752DDBC902C52 + +61C4987F76789FE99F310290AB2444B4EBA482F29BA3738FE8FEEE66B4087BDC\ +2E2B0745EFB15B6F9FB93E60CA5A55A8EE:\ +61719F9D07B0F044E8FA6980C220D4E5297F7612427302DEE94F2F381F10AD59\ +26C133C496E65A3293498D2E2CA5C3F41E:\ +80254224459BB50962188755D792FE3A:\ +38063270D707EC6D3EEA123C6D4912B8 + +59ACE34D84974EF492E04A809FD3D45CA0B8B445461B59B6524F2CCFA3D2FD59\ +B018D4CEBA2094AB668F9671966B165BAFC1:\ +11D166C2ACBC481AFBC65D461864D9EE04C879A4ACC14A1693A57C07971A4B9A\ +A3A33BB094ADFD6BBFEF0AF61AFA0C311BED:\ +F340A9624C475D33A2CBCC1A5242FF6E:\ +7C76FCFB3D19F64CAC2A7278AF846A70 + +9B0E3DE0C6A835B46112E807B1BC3A8384DEE51ECCA166D6A757963FFF766AB3\ +2D0E1565861775CEFE8455C64E81C7EF6AA10D:\ +D17E90D24691B153B8917DA9C3520D405465D4F2C7FDB2DD82365D0E356DB712\ +C5909C594D83AE4EB079F5C392317BAD0EDBFE:\ +977184379DA6CE1B1E3132AEDB6A2FE4:\ +7445CC4DF79D018242B1E6B9EE22E9CD + +55A74416A6C1E33A09CF3C1514ACD9FBCFDE9741D0C386AB84F1F01815F3A7A1\ +626B1CBDF9D6D25712FF220B6DFCC91FC97E4842:\ +6268AC60330EBFBE8F3C7762B6B00DD92F0D85396098B57474BA98ADECE9FD56\ +8AF86B5695AE6918648BF883868A17BEB4359D3B:\ +A3A5F12ADF2EE262843B4489245A0A92:\ +57C202A720888F578CB6481BE5214CE5 + +10302F2893D19D0429A4B893763302849B8DD13F79DD01FC64168C938278F7FE\ +9F399DD4271C0B832CEC29F1C26BF1B5DB8B1BF793:\ +2C1F2FE864FDA7D93A08AF5F0FD4186B5ADE3A0833F7029DE495EF6991E72354\ +280F385430D16DFED118C984DB1E3065ED57DCBE7E:\ +E72BFE997F80D8D8B16657C6B754505A:\ +22F9E33AB71D200A64C2F05CC426A748 + +701BB84145F1DC20F7A457624AF353F0148F1C2091B840C49CB5FCC9B637A27A\ +ED4AB17BDEEE88FB982337E8BAAE35540283CBB38F38:\ +A8FD582216D3FF768FECAEF5F619B056362692D8F43C2E3E75694AD274D753C4\ +51B7AFE90089012445D470C5404A74F40B88494EAB5F:\ +5C6E15752D992AEF84C7D61385168ADE:\ +689EAE57ACACCDBC3C02265A42EF4965 + +CB1D8554194AC2AE0E3C9F9C2B7E3797848E6AF752690B2A30EEE0D545D41E33\ +6C2EBCB7C24CC5038D79265414F74453AACB5BBEBBDDE4:\ +BD19014FBC75D13E2F2EB1F18D8C1D8336B6DCFD2D17D7D27F62331AB78637BE\ +DF9C1F4378165D08C79034FBEAC9B2B90D4FD6F197177C:\ +C56BE3DF2461B1CE444FA14943E121E4:\ +284CBFEC11CFDC509E5EC53CC2E33AFE + +348A8FAD0985490F232862FAE0563E8AAF58A4463F9C6ABCD600B8F6662C7291\ +4666583653A4B9C3FB499C2594ADD05EAF82B8DDB27FACBE:\ +2F10D18D90F9471996EB7127D1219439D1867795EC1911E75DF16AE6019FF569\ +611D9A7043DBCCE61B9D261E1CAC663851C4A0303313DD47:\ +4740158FBCD99CF0DCD425A55783DCD0:\ +312B1208A28974B5135DD517D8F6C643 + +B15B6F7C6B48E6C6F9499E72311DBD707CC3C3C9534902C988729E520B9DC997\ +B3D246F009C93E16C7F54AA9E2DBB870DB6FC266F254A5EB97:\ +4A8E6487E3676E1111C79CD542FB77E20E0C6B27F5502FE47A70B0E328568DA7\ +5C736333E23707AD3A53D65C091B5A886B4F0121F7B90B714B:\ +435E6E1F17830FC1B3129CB31DC25BCD:\ +FC83C06D644CFDBD069B8C01ADA12184 + +8916C5F7DC966C0D7B9C6FADA33BE730674861B908E08392A9FB7F66A58DF32B\ +2BD3D8626274E848235C7A213BAAD607A3377D116CEC891B33E2:\ +56070C7041E650EA2C28902560BEF65100959E1FB2D2B53888E69286861A7117\ +48B7693FB597A657C27069E91F386D896727340BCFBEF79AADD1:\ +3FB7F70F55A40D38B40070F047F0A845:\ +101A58E039261D052C457D83FE99B7EA + +04DBF311335F163FEE6A1588FD6FCD433E3AF7D4CCB72FE8507C23853F3F6738\ +6DCF8019AF7C58B20A1CF7F0BF915E9C2C8C6785B702AD4EE599AF:\ +174F696EE3197A93384A8E53B1315C3C448E4F2B1AB0086AE68221383BF12C9F\ +43833283CF54E4EA421E09702724D59B4760EF4FE935692ACB837E:\ +F4CAFC7D939BEFC4B7C9BB5645C2863F:\ +DE8BACE1BCD71A743E153EDAB0F6C8B7 + +2F5249B8FC8326634C5D80DA4D6EE63E77162E211C4C562C100B861571034266\ +27C6182EC81439662BE17C3ACCDC8E23AD637CCFADB6EA97816C3395:\ +CCDBBF547E5F39797D5BB8BE1A7D840D16A8E60555F84494C551E10E1E9B2950\ +55A1CFA85CD0DF95A9E90F4AE6F43053BABB28604F88937A384225E2:\ +7725DFC7A01FA56A262FF5DE277C9C58:\ +4E856EFEED281F39164BB5D426AA42C0 + +B3FDFB3E75FC0B934C084152E96DFFDB625FCADDB005345732643419FBEE2760\ +CCF336B7B76E45A4E441AC88C94C87F70C48AD057C9440E032A20003B6:\ +021A9DB9599E243EE850AE3803359248169DF6F1E109B5DEFC3E3181A7F54580\ +B6655BD4B886802FC7E0F32872A93D3729B4C4E4CAB61DE7C5D9F3D687:\ +276AE6149D3D365BF4DB65B31BD3C10F:\ +E998FC4FFD8E0171069FF3F08F66D984 + +3D3FAAA063794263890F4DDECE9EAF9D8E8E89C11A8F779D82FCD178615F5E23\ +25ED84378682169835C7013C7E23CC9BE74C71BF9D6CF291C3AB3304C13A:\ +CD1C1D2E2539E6AC4198125E968C2E68D16427DCF681FA2006CC79AD23DEAED2\ +2CE38DC53D84445E5628F87AC621BD781E1BE45EB83B0979B922EC41D1FE:\ +86F47F53472E329EDE94D33D391EFD51:\ +3E9AD8839B92C6730D1E1B4BBDDBDE08 + +C7BE811918B7292EF452E75842F1C8C744A9FCC616B1267DDDC9B7761922B657\ +D2653DC1DFE1BE4D5F20BF76F3C196ACFE38EE1038FF3EC62470DB25825701:\ +E2128982F4EA238ADA0AC44FCA33D64F1FD1D3F8343EA61683BEE0E3D330EE15\ +6D18E8C26EEB4010F8CB0B20FA964E479DC129386D30460611253822A85507:\ +1305148EF4895A0FC12CD652FA9FA2B7:\ +BE33A68DCBFD831CD6456D77A2CD8E12 + +3A2BB9D146DB73B3CAC8C2ADD1A1D06BADD759A0968E978E36EA82E8C918AB24\ +A85F9AF8BADC2E19350B4C04E9F9894C8764B64C6BD00AF8C44AAC04588AB10B:\ +C03B4714C9E4BAF3A42E2EA7BF63CD28325828B25DA057FFA79BC56E63B7E419\ +C9C67BCC2F61085849665F549DC8A12FEB9026B4D6B041948060F0F0C9339490:\ +5580BE3D3A5A727F22B4595BE16E0F3F:\ +678ED31CDE4D6CAFC8BAA875713FF0B9 + +315FD1212F0B4FCCCDF9951DB7AE90F980E6CDAB1EC35E41332007F3FB00DB05\ +4FECC6F0B639BB916883F02423A768547144D5B8856DD1693B72329A73866459\ +9B:\ +8EC652D3962EF9CF22A2B1849730EF08730F74A0EB86FD0C4EE9E7751B45F45F\ +F6BD85167F9FFEDB8828F5D4F3D442A240180E1F296BCDE462CC4B7DE977C02C\ +FD:\ +0A127BC8C04D7718AD77F62927CF0B2E:\ +C97672CA375539D43E6CC3E06167A001 + +16B82523B23A8C431B7315C307EF103CFE366E76D7F8A6464FE6C7E3BC78B9DD\ +E6A2DA4D09D05D3DF2EC2CC71E2C5E2ADA89E2C4C263BDB24BFFE8300B0AB3CA\ +B673:\ +4A0E874F284057A72F55FE2FC5733F2A81E8DA3C35BA2B2758BB4376D8B88FB7\ +203932F4F664B0EB848A182AF957AFF953AE69A59480B40D13CF457ECFE4F4BE\ +E41B:\ +D5781536A2EDA21FFE45B78B49F5293C:\ +60D2607E881FDBBBBB215CA56F9E1855 + +83AA1A09444886437356E2833AFA415AA29EA1C16E8FEC269DBD7E502B1D4C09\ +24A42E357F8896C2D5FAE8389A369CB365F771F14229A506A5056EF2CA9381C8\ +08316C:\ +5A16F9A3E1E29371E72B3A96EF2BDBE312CC353AA464C88789D9DAFE2C5024A1\ +EE2E39FD450C62DD85E48566D3771ADDE03222178705D7128A6A4912A8AB1349\ +DC226C:\ +3ED48E0EED488B5D3F3B4D7A6C36679F:\ +659ECD5DC78B7435CBCB12B50836D477 + +86AB436404A846C845BBC3261E367E43B71C1CBFBE83A1E678259BECCF7E7878\ +5E2D473402FAB1DEB3781910B24FA07966634B8CDD3C8EACE0E0503196211001\ +F31B9738:\ +77E4424C70A4AA48521D003A917803CD0FBC72FB7E4E3F61D6618A84EE7436DB\ +BE3B103BF55B367990FC1607CA89E07E694D0E7E4237D0748E9370BBC6C99D2A\ +72024534:\ +0FFC4C7E8EDC3704A564CF4848BA0ADD:\ +A0B0AADCB21B64CE81E6FA519D9071B8 + +95B0C1A5D1D183C95ED5B77A473657CDAD06374613F94B2731157947E2008AF6\ +A0A343442A69FEF44EC1C3A9A526C1B850E3196E67966D8CA2467D2D8C8743B7\ +4EE755E1DC:\ +F8D5B408682F43946CB95B071F24AEC63E94C74F7812299C2CC7F63A6C9C3218\ +6FFCE730D98020748639BE446870BFE848AD881D02B8213A6287ADC00F430E5F\ +590B6F6F8A:\ +648A228F34AED9F09440653A56299825:\ +DC35F21F735FF7890B771720B46266C1 + +A65E02A60F709E2CB021CDA6BC4D3F580138DD86FC32014E3671D4B917077BC7\ +E81BD7D9BD4C61DC5791AEEA8CB37D18C0E2CAB4555C2C797120BE459F050F64\ +1DD876666D67:\ +05798DAA3D2815D7A6C84ED8CE2DB04E183B9072E7472176BC23D6D0F55A938A\ +8C1700C4838CABBC842D5313D389301C23E6B76D62A2A7BB6A605ABBB5A50458\ +2A1373A690AB:\ +C8473A5A85EC5D7D67B0DAE1BAF55F0F:\ +7FC23300A2B3F939AA57ADAD11EA06C1 + +4A2357AAA2042E7EF941158FBAD441083CBDED6F0361246B2A1C28751B657FDE\ +C5BD1A197A0E5F90AC47C84218673BC6CAF33A78E2E499E0FC5B7A08A300FC76\ +BE7FF78F045513:\ +C8659F0DCF964501606EAC3C3F91D17D0F6B8E6076E6C85CC8BB3D0410553E1A\ +261C4A4ECC6C19DF80EFED89999E67035AC997CCC837A2B19DC9AA514E7EA9F1\ +50A9A22BF029AC:\ +F4FBF67893DF61037133787730E27576:\ +11684438979AE34D371EBAAFA7E28C4F + +FCEAB567A1DB78D58043E922B56DCF529FBEC49ECFB44D4E90ED9B5352F1BE95\ +6B894C438202F32DB57D0066B2E2732D495B7B77B60BC3EADB3B8D22CB71861F\ +00710DA68D8CDB68:\ +96FA555FFD8542AC2185C67F6C2B1DE9D037F570716CEBB9AB31258637D9B066\ +AF2D2A46D0BC0F4F8DE7DBAA79E1D7771512B7CC788740FF68E5FA26A168DF23\ +74D8602D525AC547:\ +18B9EA7CD25DFDDFB21FCB5EBBCA965B:\ +58E6A7597E2725CE4151C2601432B094 + +9DD176CC9D27F2B8EEDB272E2C87FF9C7944CFA57BD12A9E1E7A4DADF9F256F8\ +BC33E959487CCE2CA07E04DD29A1642F0B8B7E16DE15E45EB0C5CCE687962483\ +8E43EC6BD4A1F68AED:\ +660549FFBC7351074ED0433212D7B57A8D4076DD137D83280DEE8DD50DD7242D\ +A3266ADBD2027CA03553F137EBD437083C86AE3D88136D190AD25431EFCF94DE\ +0E38406C9B592A3E5D:\ +AB1242B47A230D3CA9AA74A65AD314D3:\ +2DB97AE77EF56836261C2B2857B37C4F + +484971404DD0EE0EEFF12365C8960632134926A1C625BF847EA6AA61568F9961\ +4AEC5C688ACC889BA25BD0BE6D39230A422A997E6C861EFDD2724B307A9FFDB2\ +2AF4401ADA3AE4C269C2:\ +452D66F14FF4092DBE60FDDFC469CB7807A4BBF727EFE47F9DD3898B0FDF1D22\ +9F5864C7F22C60DB40DD6F6E4C6E726A949CBB297E251F9687B089AEB1EFD472\ +936FFD8B6890062FDF1E:\ +0F6E2F2743E2459AB610AA4905D3FB13:\ +044478F8EBABBCBA92283C03729CA544 + +9ECFAB84D359E87B8E46D6F0CFC6BB06EF2F8AA27D66864E36D2840D3606624A\ +BA8BB13E53C55371CE7D4BCB1BA5F012273E131F79CA0DC72D89222AB0A32A61\ +33FDE7740BAE09BB1E08E4:\ +CA9C5F1C3C49D22C03847418907DB46363A6B2BCF6AAE9D982B502B0CB8E02CF\ +DA5C2AC9B0BEC8E4162993C2DEE53B48458359AA7BFC2D8827D8B98227880419\ +32037A7DE2C6CAB4CC0762:\ +5188AA01382907A2F6A586FBC29EBBEE:\ +446D533F257AB6335457D53772391AC6 + +6878D201901DE244EC5CF495D04794918C150CB6F5C0D953E5B4F8B9622389D7\ +F2AA3317CDDC5571E0F7974A6B2415B7547FEDD7316747B949A224F0C7BFB46C\ +DD14BB7A332CED6C8813F668:\ +9EFB38AAF7FA4F5E249E128D3F17593537C39E317B766F256836E9F7E3A17FCC\ +C1409F1C5CFDA928E74969848DC43FB4E941FF5554F06C50185A1182617CDBE2\ +43E9CE7D9E7DC3597EEB91AF:\ +447CB21EAF8051964EE8781F901A8733:\ +36F18B4676A549C0DE722B2659BA5A8C + +23CA3DEA8D4D6E4F568BBE6EA90640EF95FC7429E2A4466FC30BD0D9BEEB83D9\ +B35014DF8E7ADBD38ECC65B46E6CA23D89664CF28258D73BCFDD3227FD428EA6\ +FA5B11F03FF154BE1598DBE70C:\ +ABC4F45E59A9071E2EAA2A58049B2579CA0595090139F08F66C27703F8B83327\ +62862924395D9D345360D082634FF4B5404B296509216E8E276BD81BBF180F8E\ +9FDFA80F43C7F285782EEEED1D:\ +B77551B5360452D628085B62AD73F5A6:\ +1D682D5795A81A894190FBA6B24C0F1F + +83C71BAD6F39E2A0CB7D925A2933D195FF186ADB4ED7CFBB9A0E4BA50ADC8250\ +EED58A02B37831DDE8D67C765535448FE1CACE1B63B352DE87BC9E10EA1911BD\ +A66C62FE3671AF87C6F3ACD24A3C:\ +90BEC207BDC7180A465F153A622EFA99BA31B01F4DF1AA9D3E8B2B85DDF4DEFE\ +D5991E29E45854CFECE24FEE5FC08353D4C25C56E19AE2FD2CB97CE01CF39D90\ +5315BE033828B4BF30AEF84B8968:\ +773FAFD175509B681A7AF4617A6F432F:\ +8550EC205F5C64480E294FE0C60D73E2 + +27EB2A8D1DC6DEF8142C2E35324F19BA17DB1B24F7C94836DE9E7508AB3AC9B8\ +37DEEED54723232B7ADEC3AB27534E1B726AA7A47C182003FD09991B5EEC8CF1\ +01BDE534BB8B486E1D74612D7D1568:\ +281B411FA4702FEA5930AA30F14C6CFAAD7CC47B84334C03D063CDF52D8339CF\ +12EAD9632AA3218476A953933FA4D1287FB0DE5CABB0EC8AE298DD0FEC1844D0\ +CEC638A1D167C7BA24619053F26D9F:\ +11074EEE43942BAB676A6A54C0F680D7:\ +B5F1FD9945A0693DF1372682FBEA929E + +A020AF13D35857A95FC8745EFA6DB000F6627A41E3B2429AC57B3A862828BCBB\ +22152F68530FD7FD7E2889C2AE6B4B203AB136E81126DEBDB673F1E8FDDFA1BF\ +53CFC7E2B8E00107BBA47E525D36D990:\ +E91AB36A19C2050F7AAB135988AA74F36CD5252EC92CC7F5E66E76279386FDBD\ +131A09BD655E5C788C9142A3418EB40C15A29F8262406E4BA790D364907821EC\ +7D77281F6F2B99E69692AF8D0BC229E2:\ +DDF28D5F03B45367C97AA207D351C92A:\ +53666B1F1E067310CDB1D4B22B419C50 + +DF2FFF4CD40DD8B4A6563C086F29A800C5D56517B28EDBE26BDB95EF2E51E40E\ +EC70B6EC5132830B8F64DEF59D8974597351F9124B6FBEECC054E76472A3D8D4\ +1DFB6C5CDEAF4F8F655818AB707AA711EE:\ +102FC701D542EC9BC687BE8DADBB953C2F328B009A4624BCFA17212387A13481\ +205A6C7F55CC81FBF97EE5A595597E4E6ED3903C4D91B4142B73B0B15030470C\ +6936FCFFCB15DA3C26CF8207659505D054:\ +83E81608A49F2F4CD6D4CE9E38F8F9E7:\ +02279A85D49830F8A904CD9484A87C54 + +F17144E09A92D6390CE9BEB91CAA4ED3E5D1FCC65630FC7FFD7CC70476E97F83\ +430EAEA112D52912DBE6CB77F774AB551EA321D755C4A62A7BE4FDA10BB0E89F\ +60C882A239ED2AEF199B3C8F48FB10013019:\ +ACE1B6EFDA7EE7407DFCDBE573B954B7ED7E8645DAAFBB25246E15446D2E4CA3\ +A3A2EDC39E66636E763153D8BF37F9D3DE907FC9D98C3ECC9782E8B510216CC4\ +14C4F4D28395821A35C4845A850382DECF86:\ +8E1F0454359FEBC2471FF02259561758:\ +AC18B91487815D98AB996E940EAF2287 + +1CFF90AB8BCF241A734AF795E3DD1FB0F63C196F423AFDB2FC3342F416C00D61\ +208AF7CF38F4C821B29F07E6A55DB219E8BC04C325765C47D87C281189ECF549\ +82F752CE7ED382D194B08D03B4A7534F916129:\ +DF5FB08A8AE10DC102D61877CC48DAA16843EA8CD807564AF2B6F4F82B4C3350\ +F318FC2A04D88E805098C71C63E0937CC8DBF7701A48A37E32A67E33304C2286\ +6743B83B1730BDBE219B93B695A24C6D18115B:\ +5AC6369174587D48E1AE1B7744F46C97:\ +1DE42C0FBCCD3D87301E750B0066E847 + +9CA6CD595F4C8A21F6D5947A0DE2B61C76E422D6C677965BD2C5559A11E0063B\ +4F93E09EDCB777D6B3EC51B379C5437BC88AF8EAB8E72F8504952B743D2215B3\ +3C1C98A1BB16B07CF3C1893ECB3C6F440B75E1CE:\ +6EA26BE272B9D9A53DE12B89F9EEFD6425FB9AEAA2642201B1545F6C3D97B0EC\ +B4BB6C37828AC99C9EE23AEA72DB4C8FBA438AF542EB262673BDA1E0D16BC933\ +4CE74FE1DE6B851C9C21EC245020F1AE124D58F3:\ +D73F74BB2331CC59766404A7FD68FC12:\ +C912AA5C9C69FE793F9B0D13E79A491F + +C0F380619D41DE3D3C0FC84C606DA8BE129644EED457395E263A3D56A9A109DA\ +BE2F925D4ACACF2176E8762C4ACAEBA27123C074DA90B1F71D6E30B283265B32\ +7B0C2DBD94EC65A70FDE2953B5E25AA9AC0DE428CB:\ +7DD11E74A9568DC2B22267E13AC51F15EFFBD02F64DE4388AB2EFEF3ECC7282D\ +930F52336E7A6283CA638CA4CD98708295997576AE4E4BEC3495CA57F2FF7B07\ +10B629E9F67FFCB91C99F7162F250956D469D41B48:\ +02CAB723734573136AA95AD75F64BB54:\ +5C9CACC35FE500E156BA2CE520CDB23B + +01513EE1D2E470ADCE8BE57112727AAEF1480C38D92E68FA99D568FF4979EC51\ +A3A63E21921933642002B99F41E590CBCF257B735AB586E3F2CFADCCA522946C\ +A1CED4EA49D07F5C70965AECE0A7678FF56DD9CAE320:\ +2FE8BF3C296F7E36517DF326103D7BBCFC7AA093B6034373E6571E1CB2AA808F\ +E0166EBC122458CE819ABCC6DA5BA4E6AFFE98F9C4DE2F7BE01225A265E57621\ +681F0CE8683DD642924F54734D510A660ADB7382E438:\ +4DE074EEBA050628135F6E0BB6153455:\ +7DCE705726988AC486109D330CB4841B + +158604D8D8A4508C2CACA26910C43941A7737304EF901B34ABEC9BCA8F7395A8\ +6B6395BC8B60FD952A12F4321A0C556280B7EB192673B758ECEFD4ACF1EDD738\ +5705E97B661B24CBDA98777737FC1939A7DD84DFA810FE:\ +A7C9B667DC31C97D5095776AC3967E9F3B2912C7E596FF507F2D10FBA8881C5D\ +6FC1F17643E83600CA5CF78B28E3104C4A97A3B3AD9ED537DE2AF85737572438\ +C200FD3D8E06644CA347618B85243FECAC8B062F9CDAFF:\ +529AE17D04AF5F81DF48B7BFEA78CF25:\ +D689379FE4A642D0A6E988BBC0B0A74B + +D93C5846F4647B17032AB3548D81116644B093B5B19E4E2AFC49198268DF9750\ +716F537D9BFDC9B466909C496FE259134F8950E2994336A3EA2D3B41226FEE6C\ +05A279B12D23370EFC7B09D6313CCA54D5940C828D066889:\ +527CB7BC14045AAEC07C679D842DE0F7DBEFDB86FC6DF79888032A872C91D12C\ +E8778F2F7A0AC7D2FFB3A6370398ECE9E532AB4550F269D0CBCDC116CA6C60B8\ +B2A161D34AFDB049A32665A90541BC97051B6C73E2264712:\ +F02044299833E58B08F0DF2E7CFB1559:\ +4B88F3384E330930637851DAA0FCBD6E + +BFC943E6F9FC3E8967A860BB09AD85EF183000779B202B5E5DE738F010D32768\ +3154F5C03E8BD2FB9B26C9385463B2B198F160DE25E7D6BEE423E4836524C636\ +87A31BFE042759C3BC94D3D2CB8219DE07C9444541D148CF24:\ +9DE102B2350C51B27B9A209001ABA87F74DA02B3EC7888EFD095D350B1670240\ +CCC2868B8DE8F75AC21DAF34A82BF8FBB585C8087F9309C30EE7FE1516BB8DE4\ +D93EFA938382AA834ABFF1069EAB633EA817890BE0340C7471:\ +5DE936BAB4C06AF24B4083D42006B6F1:\ +B355BA45A1690385C48B557E22DAAF37 + +D1592D0C67A705130543605408D6F919FC30A2BEF6D4D0CDAE5A7CA1AEBCEB4A\ +EDF779C9DC7F36E1742CDB993A8FE10C3DD02878F9B906EDECABB5B6ECA1CBF3\ +13B31B0A24C075626027E113A27D9A8D2AA466FFFBCCF0A69ABB:\ +D2F41E4F5FCBA0CBA4B116BEE8A18E07610AA1CCA0309E9FBF35ADBD2842AC71\ +7F996C569697F73BBBBC852622781D2F9D0A06F59070019109FACA505C91E70B\ +8C592020364C8DF7464C1F5170A0640D3910F74BDFB22BF10FF1:\ +BBF991E78408A06E251F1C3A5CE70D52:\ +9BD49245886221FBF69C849460E29BB9 + +1C1B4F2F4297E12CBCBA6309AF806D4484683299500447C0C7E89910679DDCD2\ +D4BF27F759A9D8E8D6FC5C3B358A510F69F4BE2A460DA4183985D426E1E5D171\ +D5AC363330FF4C42E893F20D9BE08CBA3FEF9E4EB56260B866FED1:\ +1DFD895B9E4C944D6965517F115729D6C6CBA48F1FA75B63CA669705FDB31EE7\ +D73973988F5B73CEED023AA6398AF1C01ED3CD9FCF9BE04AD675E3D49A50F9FC\ +386533C12F89BF5CC0C8800A2F769D2BFC01FE0E4D7BFBDB254FC4:\ +270DE1437695766D234EC8AA7550955E:\ +EC6DBCF2BF725BB446A026DECDBC3536 + +96E90DF1B05F9FCEBC85566B90AA6B54CB45B20F86A2FF093E09014109D01D82\ +BDDE0FC837D2BDFE461E8C280C517B1E9C4899D19E35939919FB29DCBDDF98CC\ +59C29298399A9E3B75DD0AD13061D785136112251DC93DC6458E354D:\ +F02AE9B596A60B1B55A0A1AED885AA41CCAC58A620ACFE54F222592C4F9FF9E6\ +38A6F8E57276420EB14104940F128DF0DCE8998427A1FEB6D0077D92061CA9BD\ +AB42554329C8D44597A346CAFDF19DD6EF1E271CB444E1594EEFF448:\ +65B0D4643037333894C2567F1200651A:\ +5CDFB2A7DCC2E1903BFDEC88954BD0E2 + +F41F334F73D002068F64A43533BAEA6A0AB6703D68AF6D85621AE7993CCF08F7\ +637E047C0B9E8F679B7228AAC16ECE23B3019F80900100AD079E5F9FE571C524\ +9C3CF9B8BA13C7566F0EFD29AF4F4827C1676D2E895C8C743DC9B48E33:\ +FF27467D014B193A4A435A0851A6F70C27BA92ED82A2E4ED18152EF20FD5E7DB\ +1EFA494ECB64588B29FFF34827A49EE511C29A93B68CA661732C286AFDB08727\ +1421D4F4AA8D0BC9E71C59E4CE6169227435BC2652EAB29F3A63F1E9BE:\ +37C4175403C4A0CE66F44A0D89398150:\ +2B447659DF9022B1EF5EC995B4EED6C4 + +0A17E8BC90EC5C507694C084AD918F6B42EBCBB0FA695794CB8A41A3B8F9F4CE\ +3ABC272B3B1F2E46F55A89E13A99A4509FB68EE322AA95ABDA5DD65519056210\ +FC327BCE11E8A772998ECEEAAE0718D5677746FF68E4E24E890C775AD3F5:\ +176F5728351F63009F37BDFF6D7B305E77CBFBD621140530BC4B9CFC65EB7761\ +13BFA8FC6282979907E78E0A14D2C7F97359B3648F841C98EEC4DDD0F15BA1D3\ +057A0EBE0212EA54D3F41ADCBF5315EE23926870408FCBDB0D47292A1F01:\ +30E5E7F3199B6F4B9B4799D0FF8DA9B8:\ +8443B0454B241D603E3A4CAC72D562CF + +1F322F9D6F5CF8D38AB21E1B655261316C1CA0BBA2236F9F2FF5550998B0CC0A\ +376826CF6142E3D1165B3949D172A098C6ACF50468BE1E498FE020CCE0B37C5F\ +DD32233CDB4DCC5BA2A70AAF1F27683B1DE6A210DF857AE6DBEAA5477320E1:\ +D3930D3B1915CD157DECA33D14B79F62D0BEC44F51A669E07F2899CC21A849D7\ +6011453BD064189415B726D9AF12C8F50CB887AB6714FBC71CF83E3953BF52C3\ +7FEBEB48D14C62B1A64F04F987BFC6F311BBC27C79F4520C2C710B69047BCE:\ +711E9F19B40F63409045565634E94FEF:\ +00D36E6FB099D38C94DF4CE767A26DB9 + +C830A4AA5EDD5AC64121F0D47441884D2E9CDEFA5F7138B4B8505DF55185170A\ +80164F8B1BF583A0EEBAA52ACA5BAA81471CAF81FF79E234FB5DD5066F8E1DDE\ +FCBEA047B9B02C80DA480FCC5B67378AA3554DDA138256696A875FEDDBB233F0:\ +35A8F3F1C7333DD3F1713680B1ADBB4268FF3DF157C7E1A83DFEC1C224723FDC\ +864559B9436CCF36A6F930AAA7BA03CEF94C2A01ACC587E3CBB334779833ADBC\ +22B873E71506207A4A1320FE881C0B5F6EC5B384B7C50E88FB8100AFE85C0E0F:\ +8D2FC9D115F014FB6F61AEA91DA55153:\ +0E0E45107F52F186FC2F38B35565B8D2 + +08155837372A1F8587F31553D0CC20BFF1B499D0EA035FD3809CC14F6BF2A5D9\ +565A734831A2EFCF4EA5939FC74BB76A0C8822958C8FC73E77D4C856339E5790\ +22EE3AE26E737A8E9C6E3A9481796EAC61035BD97AD45EC7CE746AA0D587369E\ +D2:\ +E9B72DEAFD9DF0839B94F32937C8F4571F83C648EA7E26193A264A75734DE940\ +006D9CB5F10E2647E5253D234898021118578CFD50F7D9A32E59C48A98859D05\ +7CFFB16F9C345002A0C577E875A561A15C78983771D75A7DF7286B8924EBA24E\ +59:\ +6F7035148AA370DE95DF32625C61DF1E:\ +89D60899E5C54E72C9E86AFC88E283C1 + +652D41B854C0D18458B8C583D5122DA3AC6B278ED180E9A98A2CBBD23854DB32\ +DBCF4377E44F339DD6571AE16693D9E5AD9834D38836A71002C40BF320C28EBD\ +C5824F6701EF35996C8D6C6F843C585C83A42C5F775073AC065AA1FBD61F7F18\ +D68F:\ +3C56B8394BDDFF0471148D0A9CD7B0F6B179EC21B829EA808D6E55450CA688E8\ +EDEE29B1AC3AEAC76B0C3A2D8604F09FF3E777085B522925CAE621DA0E66CD80\ +63440838FF3FDDDF09A64F3ABA5CB43B88FEEF6572C053076BAEF92454729C08\ +7AD2:\ +7CB41B5675945EDADD9065E47EB1A2D8:\ +883FECB5355C16D075A7DE014BA9A05A + +3756825A44E0C3D7E90C0F4EBFCB2FA4561EAA12C693E7FD8707AD206133D0BD\ +EEDA0BA65EF58030546076FC9904214E65CD9DF37DDAD962626868A3B32AB476\ +BB694534D37A77953D6F1109515C5B5FC239C88FCEE22BACF54C44E03E9E3784\ +CD9099:\ +FF9FC9F00DF578810D3D9F7D50B881B2578E9D7EE8328A3F8C702F9298800621\ +DCE4CDC2E55E2B75B0574A57A9296400F811FA6E899CB8214583B969C9D5CB03\ +EA966FDF32A2F1FCA8B0B64BE84C18CB4A7F7BD8DDEC03953E744520D95A6D65\ +FC735D:\ +21C9044F7F1F71AA0FB698E80120DE7B:\ +FDABFE4911247EFA953293DD7FE6D5DF + +FCD4675A023315724B2BB939E6E1A62E403B90C9DD267DD6C2E4B39DFD171117\ +4B9D13004827B08A65193BC21A9A6C0AAE8C2527ACE9C62AF6810ECAD8671403\ +CFAAF86BBD72E3BBB1875D9254D04A8209AE9E800E41A7BA5514F9913E94CD84\ +69A7B6F7:\ +5C7AEC623C486C256635814A95F07235A4D6932FC23CB54CD0A6C76ABD58DED9\ +EC90B9802B7D4366ED11E7AEDE696D3A47B716312DB0577662C1B8B8F8523EAD\ +62FFCA8F3C6D15CE2280B7DC8144782D9CDA5D609F871051C79FAAF9006F686B\ +068E9B97:\ +E06085A98E76F04B2B78476A4FEFA542:\ +9A619CF8924C6DCF2CBA067A34B3A761 + +9483B567F791C819D9F4F607AB82E0E2F75DC02BFFF7836563B1F89CF0F3C859\ +AD93852485A76A5D51260376C7877E2A875BE3C6528D339C6BE1597688805022\ +AF963A47A188112C714CBEC0435AE99B9441CB7D5D3B3048CF9C3CFB91C7D248\ +3C3CBABE75:\ +3FF3298943869CAD3CE99857B849455232AF6A0420985364BED603D012F1AB29\ +DAE327C27FB107FF25E061A60933772EE5F9FAB717378E739ACB6D2F09FD8A3D\ +1B02C2359E0AA8C07593367BFF1C5FB70C20BA8742D4EBA2A9D12678FE08CB75\ +8F17428DCC:\ +BB11666DCE893166774A99EB9F4E4A55:\ +103399E7EA5A24A0CA60FF24DC08B391 + +00080A114314369DF72FD1339E2A83F2427DF458221236C416ED129563D07E71\ +1BB378FFBA1787809C8AA09B031D23033EA418E0BFD8E694B0904C73B964D73F\ +975462D3264C3F8E09182F732E8E14A2FFE3F50E5A6F81BDF6D49D8579AACD98\ +52E699C23502:\ +04B30B016A92070ED18565327AF7CB82C4940B3289B28BA4A1208357B8DB6F79\ +930E885E05F617C5C152D619950C1B986CCCDFEB7F9BE26C41F2142DD05C25C3\ +B92857B87FD7944611AC6ECFFB66011CC313C2BC96581D7624931D061ADA6FAF\ +4EA4B72D2E73:\ +1A7031DBAD6A06FDFC79B25C77E9EB9A:\ +64D45D74ADDB71224104B3A4188916AC + +D5576F37BDE9BC6FB4BEF8F83BF565C8E710F05D9F2FE47E4266EB23875C54EF\ +63C5937A506B7BC3FF6ECA77D953EC905A2F3A84B36CAC6572BF8564D0D33C1F\ +F3BDC96F374AA75C7262F49338AFA81A6E6415FE60E4E61F3994CDD19589BF38\ +9CE4BA169B99FC:\ +BB5653A4C90F6BADB14DE8D41C55648BCFFD7017F8CE43CF7D78A4FEF9DE625B\ +0B9EDAA83C901C5079E7A3E2353E9679032A029CE34C5DCA41D917659E2D46AF\ +062728E7D170FD743C1E52851CB00AA95ADBC2216C109523B605041C1C220959\ +16EF8ABAB9C471:\ +B2414750A8AE2768688F7C82B6DB8C63:\ +04B8131DF59B53A0BA806FBD07EEF083 + +47621B4D2805AEE6DEF034678EEACB4D6C4395B39D8ADD4A60A9165E2CA7B388\ +0404B40AF1B1E9083AF8FA1D69CE83BC9530B67D2BCDFE9E36D1FF05D6FB6213\ +49FAF662C55F62727C447B35AB2336FE86ED7C4F3EA6880352EC6826B5E61BD7\ +2478941454973E3D:\ +95AE682E1A4A92FB00D8855C22E3763064BD8A771EB2AE675E0C676117AA425B\ +B885C63E7FFEE58402170FFEA5FAC4B5EAFB53AFF6998804C6F99AB09821F8D4\ +2F8B7EC788F0E10CDA6714788DF679976F928349FD8E8F14548C1FF4FE9025C3\ +547E486B0ABCC410:\ +BB7CF3E17CDE92291B4F5B97D5091ACF:\ +B5D12B6A1B4AC6904FC2C77DF2A76772 + +358B57B91E90956DD981B9AD2F570908502F1FBEF230A350B324316FC52E1BC6\ +E69A2CCF39990AAF1FCD59BC7B712CD1321F7F9915CE1A46D0A1CE9E3F500BB0\ +D0F1B9DB3E1EAA8CB532489AEF8FF6FA4F6970D7BC8045E0BC9F304E257145EA\ +7A5828902FFA9A6B89:\ +70607CBE0266AC893D82198992E0EB8687B6787350E8797A96B16FBD8444A092\ +058810420DD51854E87E532BD45402682C9FA77ED1499CE07D6DAFCD5C15D056\ +000052E3D9403FDEAFC91C479AD9DFA313DE0C9AA3700664D32190348B29F9FD\ +B5BFBAF249F10FF0B7:\ +2F5B82638FAB8E485826C4B65992577A:\ +5BD1063BED52DDA5D04D0F85486763EF + +B713EA5878BA973DB81463CBC2DCCEAB876AC10EF2BEF98F141428A933DC6968\ +BC657F53AB286B28FF6E141F6DEDA0D0E708B20F17BFBFCC0D994B443A853A29\ +2C94A254A8055B713122AA27D079CD6741BF813DBD9471A8981E433F824311C0\ +295225FB9553A4038254:\ +4A8D9EA5DF1462E152F8DE358A92B7283723D49565CDACB3DB050E4C93C152C1\ +4063265DDFB76D46FF2319309169C2086A31D521BAE0B9B3CA670E1C2C033F31\ +56BB9350B0BE208A7D41101A0B063F71771E2AE2A0A5984DB5341C76A5091CAA\ +A536AE7CE4695FD37B99:\ +8F4FCEC73EFFE3DB1DAA37494D1229E0:\ +82FB062F71C5984EE7A80643BDE0659D + +BD2C3B366C5480ABA112A5481AABC79A024ADD95F6FDED50B328EADC4109F669\ +103636F1C6DD7F1D57E307535F4FF3DC963C96A8DDCF51470FF02AB21FFE9100\ +08A8DF16EB2373DE599189DFF12CDC348D67A6F33357E86DFA5F813877FC1679\ +74AE1E835469497A682D68:\ +11CEE8C48CF3398082D0820F8FD1B200FF0D0BF29E8EA12F845EF999C1B4E9B0\ +938CE474755921C86DFF4658C29615F0A2D64179AF384FDEDB103B3B642D3FF7\ +99E24394BE70C9BBFFFC56194FE861B124C9A605629ECADA990CB736513C2843\ +5D1935E3145A3CC4BA754B:\ +7E3D876FBE4849C64A2E6FBD6935B8B3:\ +8699121F1CDCEEAFC4ADD47DD4822507 + +3E4A39011E58A44C9ABE3368A899426D034DB05E097060C01C63F0DE3149D0D1\ +69B9F185B7C38506AC7976E6E182DF704844F1DB5736821543E978B9299614D0\ +E3027B7D39B4FD4034E3562D71C685FBAFDDC16D0A6C4DD1A5B3DE255ADD980B\ +C2CA50B117CC6561CE792AD8:\ +D5445539FA5E9045304A7FB13ABFE5E535AA8BD830AE8FA0A8787FD0497A995A\ +9E42A622B2D9C00CBD66E48A74C4C32CB4862FBCB38BEA626DCF65408D7CFBC8\ +2527DD709AE68908D14A9F0AAE118A7A90A94BF970F6E4375E42C377609C04C9\ +D86F5F18109A8B21B22BEBF0:\ +4856224AF0495A558349E5A8A13EB199:\ +7E9E8FBF19BA323CB2B8060E79FB526D + +0178CC505660EE73D385D55A680C13F66811CADDACB97C303D90FB9AA735B91E\ +025A5871125B1F8F728A1A4CE1ABF2B68A1DD66F72E9CB6A28B7BF13190EE5C8\ +8D68FCDD44FFBE340935B0F32AE0E3071554B94F7CC069AE0C1E465B7FEFB643\ +04B84B4548A2B6BEB219CA9C03:\ +C43FEF0049C62915C5E7966A2D51AF66A61AC78A7E7725D007E41808C3BF0806\ +71EB8710CE36C78905B4EF0A2C4F294F702AE24D2DBBDBDA8FBB7E3DBC1EA0B9\ +7A884AE62B008770A08C909552D48F076268B9C14F94EC1BA17D504A63BB7B68\ +B7D2A7C0ED2AF76CCE495287BC:\ +1D8F327BF9485ECF42100325FCA85813:\ +28C5C1D3FAAF5703E95EE78096C53022 + +7A8B2BF9414A0648449541D609CE1DE8D3E8060BF09F449BE3F98FC4D6CA7B41\ +FB3DF2306B33BD700C767C99F934C78051BEFF6F21661F4C211A2AE7D8BC328C\ +57953B39E1B424994B0EF865ED752A5094A4DA28DB42F1D492435E7D4FB92B4F\ +E61D5034921D0371B0DA05E90A43:\ +28261AAFE01C7FEEC442ADE2C7E298C09F7BE36D8883A3A81C8266523B8CDF1F\ +A4C45B9C41E96FB53F8781EF4A91192342C473AE3E2B0D3C026803868D0978DA\ +488EBBE8282CC07AE95E8042C863EC66A73482481450B9715E8279D5D4FEF788\ +2F81913679FC022624BC9E800C9D:\ +D84FEF97E5FF1A5CB866B8965AE205C1:\ +56DD14E0C72D31557A35F16D93F36973 + +459F416851ACC54284A9E82CB878B82AA6C589A9EF96BDCF18F47663083F53A6\ +FB5596F976ECC5BB49078C07E7F31E68AFB84F6BE1C157E93A4D0D86505881DE\ +A2FCECFE477BA35FCDDA2CD2B9E85194A63FDB06DB8AB5CF6C25CA323C09D6F1\ +14BFEA93CE791FDB588A068D27BAEB:\ +D7E8EFCB3081AC49002FDC9B899FACD2326AA7D13ED97360AF2859F86ABA346C\ +C7A230E0889269DBAEE7E83BCDAAB0274CC84B4C3353EF0F75646C5ECED75AB7\ +BBFF646376155DB30EAA1CE5E0AFC3BA38D0EED7FC9EDEC2418FB6BD00E8DB24\ +8C07B2AC8C92D5696D1B26456F67DE:\ +E274D29F8D942F2DEA0F2EB56EA4A65D:\ +B060E8D64520B1F3FDD513421461DB88 + +2CC8CB49AF1488C956C3E065C6E4E14E40C0890BC5D0042E49F0B42E0FC54347\ +0D34C98A894FB31EBAEC18327888CDDDEBF3A6467DED49BDC7AB0EF1F3BE1DE7\ +B6A7C0B63D94F818E21823E9AD75D4416C55848FBB6BE2A9F06190089E455B4C\ +EC9B5E45AD86D93A31E4AA84508CF9B8:\ +16C084E323E61E22443BB67DD8BC82A4F42DDD86A187242802F4E6EBA7381D7C\ +9BAF5D439884B2B7231F93951AEF45E843EAE09AC7208D774B5F3798ADD4CE74\ +A41508E0AC7D7DB8A6C47AF8BBC49C41B96DF51867BF4C650EB39DCFFC6AC736\ +5952C585CFECA818C62BBBB2A653D426:\ +710DF4F3ED2C815B98B0D6100F79F9C6:\ +E79A134DBF61E5B7229C75C312F5C02D + +4CF8A7BD22E0EBEB7BA5D619A9964EDF83518B08A074597616385B8D48AF8A7C\ +1F779E728229B69FDC5A8624F95C9B891FD27153E5CA3BDD40C7BE56D2A5FFBA\ +E32CAF544B5BAE9A7A9669BBF1ECEFF913D037EF7DD016496C52199E3613314B\ +D78084518A5661F42DFA7E87ADCE83C5DB:\ +6051562B133B0AA03D3CAD98E8696FBFC45BC457D7888DCC302EF3A6CEC34295\ +FB6E96237B2168B8F7EC6566E49A28840D12A9B4A6429C57F2EF46A2B8F3EFBF\ +79252D86D7AF9C600AD4E01728791F349DFCF97E6B0C487CF14EA8D79FD72A54\ +88FCB6F728C5214BFA987B4A0521A22F22:\ +6B1E9BCAAC6D93564DBE4EA67AF7FE82:\ +EB899146B055647A2A32798D45EB8DC7 + +0C78FFF41C47BA8610D9EECE738A4451CA1AC3267D9F6268AF5E8EBE432E8252\ +FA8E378E0C4F0A7000C93B415249C66719BA3435593F216937E7F7DC64EC3E26\ +B38055822175D8D27979CF4AF86B3A61447E29BEE7EFFC249483FC29815B8A93\ +791DE7A8E3182AAEC0A3ECC4C5945A203D5A:\ +56562246286CFB3BA6BD411A3009CC25BFA6CCDFBBA44BC90C1EE7B4FB07A5B3\ +66183C2B230844108CCEED0FABD01B15168F82AA9B8315422A5175D86DB2EB6F\ +452837F2C9D4EA7956D6B254E4E4979F278518617A1985BE35B71F80B6CF5589\ +F076689E022EEE974F496147F29FE5810CAE:\ +641A4B7E4268220890E145488960C185:\ +59432C9E1519A223838B180634B51521 + +34B22337AC8C2D57B79208DF0CC4AD245FD02776876F0EBC5B3EF57A4E35BD52\ +2B8F8F3ED20F630F2C4C706845D1142FE636C69BBAF78E9A32C86F7ECECFF5BD\ +AB8ED1C72CECF59E7120D6C1A1C91BADF25F7E2E710FE6A8C97EEEEFBC2E45B1\ +49DF05FD33C1D8B7A37F7A31CDC43A56409961:\ +8D4133BAC7BC2644BCA4E525AB21D57036DFF7CF713C4A80B913E0E0DAAB1EDE\ +268B7D2629CD5DA5E69DEC179C64666AF7944482D051A43E3008DEF5E1871A1D\ +E6DEF3539AF563F42839F67AE0A36D1E18381C8D8A50E27E28998E3637BEF02B\ +409AE040DF719AADBE213EBA57B179FC5BB0A9:\ +D3BC0E0818C1D968378290A948DFAD06:\ +F9CFED1A6FD8B74DC354D25315A12869 + +6A70DF92C64A831F654DC3C347D12317441F012C3B34B62E3BFE9F4BC65F9EE7\ +7520B11A109D60CB5C97CC071504E900ACC32C85754CF17685C12178C40FF85A\ +453293404AFADFBC4369EE134AA1EA6E417BFD290B2FFFC5B244CBFF10008644\ +523D50962D7FA7779B818D20DF1032E0D08DBB36:\ +938BAC00576D4C6A3AA073F1AB7E06FF98F57838F17F7FFEE2BA079DF12DB2AE\ +79DB5225B274D943F90A1BBCF239755E2117AA9C7631AD60D93A03DC2D848E5B\ +BD3CBAA245621B4E124AA1772BA423DD3D6B86478C8DE0EEA53B43728A299305\ +E96A93FE337D06500DC4C19E96AD20DB495D2A01:\ +45931A0BC3F330A3390A1285121CBA69:\ +DFA9D41C68B05242052C49B3F9476722 + +1B46DC2A194A4EC1D6DECB3B4EEE8B9E815052293884070A0CE77818BDA476FF\ +820CE494A8A620358E560E978BE89F6753FF625E7B9FAA2183E173FBE7B8EC09\ +ED968733010412A31BE5155FFB5E1A31063CCE011425C2C0BFB6E7851BC6937F\ +324F8B6CD7409C14DABDDDE9D90054B97D01A9D030:\ +7C474EC6ADB6D2E9CC286690FDC89B3BBBB53DCCE2529FEE1E7385A73ED7812E\ +C1D0C07558218889872793A7ACE8AA08C2AF2DA5CC529E588A26896E96F257F9\ +5779B797353B3784870FD49706C9F53C0D3F7698264B92E437435431AC793ACC\ +740A68B2096FC4BC696AD35BC84BE379F08C2B75C1:\ +2BE723871AF751A8F29FE427EB4AFCF6:\ +9BD948CAEC0C63433EABC81058FC54D6 + +9B09EC9C26135DD7E328C616BACFC1166CB0A6DE265DE3930EE2F6C2A2F17A6B\ +9ECB4C695B1D6195903AAAE922EA99FA72F2FCDCB4A0CA4691904809E9835D2F\ +87ED4B8485F2B1378A8D14710E0CB21223BF4A031996FFD9BB053597B124FE42\ +D712369DF9E42662C4F353381B016FFB39117953231E:\ +93FFE4FA99138A95461489C915CFA41F0BD8E73DA1D02D6CD28B4516A1D151B1\ +CEB905E4F4282A586A41F567D324D6D90E1814CF86E463CCBBBC20C7F4A95174\ +4CB375A621FECCC418FBA8DAC781A8E89E003B34E1C3D95313543318517C02F0\ +2544854305DB91B05CED444B02956E1ABD7A464CA158:\ +3DC16EBE791AB24559F9B2F1F6C80D13:\ +EB15B43C7C1FA499E13972ABB38E5059 + +77D6EBCA61FC06C689515C26C8D13F7BAEF7539E63ECB3DED59B3A12A5277674\ +507A94EAB4F7333159929EE79BC000CD474AC416159E0CCDBD77C4218398C784\ +4A98B549BE8CBE06B7A3CFA269347DF9BBFF1C7E9346F6045548C922E1E5B961\ +84A0F5384242C404EF31CD0ECA6B5A0D3D1B825959F87D:\ +76AD0A59D48C62648DAA6AFE551A76D734EB420CAE0ED368EFB29ED715ECDF9B\ +A06BB58AC17986CF78307D12C8477F7FCBE77D47D14700F998561F8045C4CF53\ +C98B048E21C773AA68AA6DF4571C64084DE4D96CE838C103643C077E1CB35EFA\ +664820F478F4844312FACEB4FC014E4B8404B8BC8C3540:\ +62A399748E8768CFC4354749FE98E1AE:\ +9DE4950CA5BF39BA05EB3A5B867FCD59 + +8973F0C9A1AB4E76CC645D59DD60877081349151C5F39705D432C6AA3AC1AF56\ +5AF923F6CF1635919F59F28F18754462D0A63E909AF3901D0D4643CC627A3D75\ +0A737035A1C43E58BF43E90BF44F7B766CDAFC1001962DF30B54462DC1156A4B\ +A34FE80EC38AF8EE0715A01F2835907D2C2341FB624909E8:\ +D88924E63979C8990E1508D198C019573250A3FEF243ECF82B5C6F3D5977CE69\ +38A688C63F7D44890B1AFF1F0D82C78C21B2F2660E612093E161C5CFA9D02B0F\ +13C3689AFE54CB930370A24E8EC7AD90C3AABA0278CA36A14E938929117CBCE8\ +ABB102ABF2CA46E7413D4DC265AE42FE513954CE88C330C7:\ +00D7603484E89AA807CCDCCAA7FCEEFB:\ +B20E59D1782A9B2D156E82083F5F0AE9 + +6E617AFED34D6D72176C41071C562D462ABC10C698A3D30D7CCE1702669670C9\ +EF485FB7239DB3BF58B0CCEFF683BB57EA7C717B007D19358517E78DA5BB9B83\ +B336441F99367523E3824B842A6F58D8E4525D8A04BC011DBACF413F8B2FDE1B\ +2E69B59289ACCB6F67E8C74222FB8EAB8396DB82142C9C227C:\ +0D63C50EE0DF01B0D6757489B6124D16779A7756EF292C0D1527B9B12A9C1EDD\ +F14CF75B9AFE7AFFE082916D44FF3D7FD5950597A3D3507D9C25240DF0959439\ +1ABF42D4B9F126F9CE7C5022724196878C7FB7D845D28BFB7E2B8063D9BF1CDB\ +06632FAF53B05CEDF1BFBBF7FD9A900893C1A1BB80CBB13B80:\ +2BC487B3F0B5849461A34EC826530DDC:\ +A626101B94FB228B40D9BFE968B93283 + +8057464E6C7CA4832841C68AA8DAD0820D9B6F914B58152DF50D17DC0573EDB2\ +143EBECC208E15F85040624B1AC941A5739E36508964FB23DD6BBE4A869ACBA1\ +660E545794024D8CF79F2F7F47F7AD27132EBD9BD45DF4F0B4CB2E892F3B8F3A\ +5A6A4443825B19D2BBE1ABFF243050338A8E6A94E7299779C04B:\ +2152EBD90B8D0A132CB4A0FEAE79D17C415C64EF95C08D178B6D106860A1806A\ +BB36ABA214ABDD07EE9D188C6EC64281008739C5ABE99341BEAE5F3BE8947EAD\ +04CF713DBFC3E808EA1A25721298083736851F618541FD740F5037977157B751\ +C2C665AAB37B53EF2133416000861164309944FD2C7BAF01E0DA:\ +24EC777AD83D32FD0B3E273CBDC3D06C:\ +0A864DCAADFBCB0B21681045573805A6 + +9A1964D4FA2038D123902B51A09FA1A5EAA84B5F6A1F622E78F799D487EA90BF\ +44C6D591C5F1785628A98045DB7E5750C6782AF367186431B07C8782C1D5D5D6\ +E09455079DD6DD1F7B0AE3BD3634EFF698A19A6D86D91143179A7B350A956DE1\ +B44946BA9E111BD690DBB0277DBC2C79F5627E491C4BFBA09A7E91:\ +B13D67461B776D04C361BB32202C29F576A082BD63A58D4A059CCDA610546D32\ +87992D6D62B72DDE8FD2C828C8CF40D4C8E83FDC28457510F90C3379A394797C\ +D9375F139042116573728BD54F7A42B312813D656DDA88245318F957D4A560E4\ +5B395DECA5FAD456BBDD6EA37CD9AC21A87377D2FE18DDC19FC83F:\ +4C5C40C1DE409372518E3D2486181C44:\ +989F5547C5F79F05B04E40353DB89A76 + +70A6A74CC6C98DEA90BD6D18D8BBAFED2CB45F757184DACA942B1EB2728BAF94\ +A245CF5A3F27FC8CABB9564BF803EA75DE2B62DDF361454823ED68B691A1C4C8\ +6A0361543B950FA9D67FF767C1DC20E384B7FEB48518D0B251553520E39A05B9\ +50A7BB2B44B7B8737AEFEC2A875FDA8B901E130B3947B65CF9736103:\ +1254535BAE8A3CEEB81C5AA04851A3AD15CAEB906ADBAFC93F05436619C037C5\ +9ECC67B1B4419733B9D5BA4323225B4BE11CB0347BB750E1B40603E23FD06736\ +3C616ADBAE85C1526FE2C8F11AFED5CECAB321CF97EB314B999AB118F098E2AE\ +1F89E56F13FB501E77C02DA692E49C8BBEAA1AA9EE97E7551756C2F0:\ +F156CFAA28C87F157DC989170929E8A2:\ +94A82BC348B0AFACD194C3423AA8875D + +F5AD5AFB27665589C9F524176716C60BCFF9E3E41FC9F6C5E8B83C5485F956C9\ +BA7BFD0D8742F6F391D75178E6B560C0BB32AD3701998697C23EBDF74CE4876C\ +9B1C89E43736653D6A0AC442B143DEED7F2C5E84DD4874E1854E676CAC32F0FF\ +E5C0057F83DEA1BFF2044D5FBD4768D809A61FCFAF4A654AE21D233BF8:\ +FD66135ED18956B6F07BCE45BD57F0FD1DE39935B8CEEE781988DFEED303D189\ +CD49725F10BA59876F00569C1B7E941F3EEB21BA0E04D0B617C435D5638331E5\ +6EB7CE315C4FA4D875ACCD1C4B8660E15A3FDCDAA77398271E80DCB0B8B861B9\ +7A2E2B509234BD538FE0E8EAEC36BE2AD4CFC46591487297981769036A:\ +4E36103C8C67DE1AFBF8109D10BF10B1:\ +41EB43240037C71DD6D6B2CCA3261338 + +92233AAFE15359C0E59E8EF3595311AA370D18FBFAD06204346CA4F2F0BE6DE1\ +D3302819BE77F4898615C4D3D887F3F0209E66E77B002150CA32709C91099BE4\ +20E95B5E753D6F5C0C09F67B0DCB5DDAD0842F6CBD3CD16A187691E24A7B2F14\ +BC95EFC3359B80A2C3C93FDE2BEEBDB20020A3041F5D83EB5AE89FD09637:\ +7285EFB954C50E78998DFAD44F952F436CEB2C47D303DF1281CA8629145794BE\ +88B62AD6D8F35B00C308B321901C3EFB2AA32121276C64079EFA6FCD86F7812A\ +8AE11E99274DED703DA1DDCAD91ACDE50C3FB38900E07D4C1F6B74CD6010D6FD\ +6116B9BFD956BF0A3D391C39EA314236E14DDD9AEBDD03C1CC65C6337348:\ +11A8AF11A03B80A71452973CC6664AEB:\ +A46F37AB9C79CAE2C0067913BEAEFB52 + +9A94824C6C3551364320E09FD9586C515AABD15AFCDBBE31C2AF0E7188BBAFF9\ +BD249C3892FE6F4D16927C1B65D3106B3EA4977E1A1DBEB0F0BD88ACAC7492F6\ +D5834DCAAA12B9723DE2CB00D634DA187C15DC212542C7B0D495FAB7ECADF22A\ +F95C4CE4E762D18EBD4673F2A2AEA54F43D0048C80A907CB609EB3B3FC5F1A:\ +9F6DAE40324E5E369817F79A5B4D57474B75C5E9EED2A7450BAF7A5E94F1DFA1\ +194EC919030EC853A7B33BC1D3D5C0BAD403102C5BFD76383A8723C73E88B406\ +5267E075A5A42665384B1336E7435C36BCE4DD98B220D42770C6485175707427\ +8EE9654D9E9798F73BABA1CBD48C80178332EC159A5BBC7009D7D627FCD37C:\ +59AC380799FF7D4A6126A445ACE889D5:\ +18FFB0A05F2FF079D89E1D36082A4579 + +E71039961AC14FCF7212ACA932E1C6307696CF7D98A96048D888CACE6B95A32A\ +268EF802CD311EDAA92D96019938D7F6D1E12C70306A1A893341F610D387248F\ +00A113BE0BA43CE254B0958EE5DDCF10BDE3223EFF0BB7FB71C833A7A3AE52F7\ +8E00B7A294A23B76868A53B74737E23B93A7B89F6890791CBA7657715B9DA9BD:\ +E411BA4401573E11E51D6D7E318D6DDCF23E5927CA429DCA57C419BBC391CAC9\ +EAE01A2384F4705EAC94B06F151638BC7299DD8FF570404363430E9B06FFAABE\ +C5E1384485E7A085AAF6E2692742F7E9003B18A4B9FD5D772EB0A326655F38F3\ +9B2D49035C484AE4B4F12B14A7BC74A1F0ED2BEC9906E45C22C085C04679DB62:\ +F1E297E1C4E33229EA69EA943BDD5C41:\ +D43BE1D1871642996713B6400DA4B0A7 + [TEA/CTR-BE] 0779B5A4D94C4B572257340F8F86FBDC5AE955DB72E588CB3D8298FE27ADC668:\ 6D787EAE01A5D7946C8526B75BAAF2A8D1F13CE4AF93E469A21B7C53965A1CE1:\ diff --git a/checks/x509.cpp b/checks/x509.cpp index 0cd2b8045..3a48f57f9 100644 --- a/checks/x509.cpp +++ b/checks/x509.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/filters.h> diff --git a/configure.py b/configure.py index 97e591b5d..39120d22a 100755 --- a/configure.py +++ b/configure.py @@ -132,6 +132,11 @@ def process_command_line(args): formatter = IndentedHelpFormatter(max_help_position = 50), version = BuildConfigurationInformation.version_string) + parser.add_option('--verbose', action='store_true', default=False, + help='Show debug messages') + parser.add_option('--quiet', action='store_true', default=False, + help='Show only warnings and errors') + target_group = OptionGroup(parser, 'Target options') target_group.add_option('--cc', dest='compiler', @@ -311,6 +316,25 @@ def process_command_line(args): options.enable_isa_extns = parse_multiple_enable(options.enable_isa_extns) options.disable_isa_extns = parse_multiple_enable(options.disable_isa_extns) + def enabled_or_disabled_isa(isa): + if isa in options.enable_isa_extns: + return True + if isa in options.disable_isa_extns: + return True + return False + + isa_dependencies = { + 'ssse3': 'sse2', + 'aes_ni': 'sse2' + } + + if 'sse2' in options.disable_isa_extns: + sse2_deps = ['ssse3', 'aes_ni'] + + for isa in sse2_deps: + if not enabled_or_disabled_isa(isa): + options.disable_isa_extns.append(isa) + return options """ @@ -444,9 +468,6 @@ class ModuleInfo(object): self.header_internal = map(add_dir_name, self.header_internal) self.header_public = map(add_dir_name, self.header_public) - if len([f for f in self.source if f.endswith('h')]) > 0: - print self.lives_in - self.mp_bits = int(self.mp_bits) def sources(self): @@ -515,6 +536,7 @@ class ArchInfo(object): lex_me_harder(infofile, self, ['aliases', 'submodels', 'submodel_aliases', 'isa_extn'], { 'endian': None, + 'family': None, 'unaligned': 'no' }) @@ -577,6 +599,7 @@ class ArchInfo(object): if endian != None: macros.append('TARGET_CPU_IS_%s_ENDIAN' % (endian.upper())) + logging.info('Assuming CPU is %s endian' % (endian)) unaligned_ok = options.unaligned_mem if unaligned_ok is None: @@ -584,6 +607,9 @@ class ArchInfo(object): if unaligned_ok: logging.info('Assuming unaligned memory access works') + if self.family is not None: + macros.append('TARGET_CPU_IS_%s_FAMILY' % (self.family.upper())) + macros.append('TARGET_UNALIGNED_MEMORY_ACCESS_OK %d' % (unaligned_ok)) return macros @@ -989,17 +1015,18 @@ def choose_modules_to_use(modules, archinfo, options): to_load.append(modname) # trust the user elif not module.compatible_cpu(archinfo, options): - cannot_use_because(modname, 'CPU incompatible') + cannot_use_because(modname, 'incompatible CPU') elif not module.compatible_os(options.os): - cannot_use_because(modname, 'OS incompatible') - elif not module.compatible_compiler(options.compiler): - cannot_use_because(modname, 'compiler incompatible') + cannot_use_because(modname, 'incompatible OS') + elif not module.compatible_compiler(options.compiler, + options.with_tr1): + cannot_use_because(modname, 'incompatible compiler') else: if module.load_on == 'never': cannot_use_because(modname, 'disabled as buggy') elif module.load_on == 'request': - cannot_use_because(modname, 'loaded on request only') + cannot_use_because(modname, 'by request only') elif module.load_on == 'dep': maybe_dep.append(modname) @@ -1050,7 +1077,7 @@ def choose_modules_to_use(modules, archinfo, options): to_load.remove(modname) if modname in maybe_dep: maybe_dep.remove(modname) - cannot_use_because(modname, 'of dependency failure') + cannot_use_because(modname, 'dependency failure') for not_a_dep in maybe_dep: cannot_use_because(not_a_dep, 'loaded only if needed by dependency') @@ -1059,7 +1086,7 @@ def choose_modules_to_use(modules, archinfo, options): disabled_mods = sorted(set([mod for mod in not_using_because[reason]])) if disabled_mods != []: - logging.info('Skipping mod because %s - %s' % ( + logging.info('Skipping, %s - %s' % ( reason, ' '.join(disabled_mods))) logging.debug('Loading modules %s', ' '.join(sorted(to_load))) @@ -1198,17 +1225,18 @@ def setup_build(build_config, options, template_vars): finally: f.close() - logging.debug('Linking %d public header files in %s' % ( - len(build_config.public_headers), build_config.botan_include_dir)) + def link_headers(header_list, type, dir): + logging.debug('Linking %d %s header files in %s' % ( + len(header_list), type, dir)) - for header_file in build_config.public_headers: - portable_symlink(header_file, build_config.botan_include_dir) + for header_file in header_list: + portable_symlink(header_file, dir) - logging.debug('Linking %d internal header files in %s' % ( - len(build_config.internal_headers), build_config.internal_include_dir)) + link_headers(build_config.public_headers, 'public', + build_config.botan_include_dir) - for header_file in build_config.internal_headers: - portable_symlink(header_file, build_config.internal_include_dir) + link_headers(build_config.internal_headers, 'internal', + build_config.internal_include_dir) """ Generate Amalgamation @@ -1343,9 +1371,18 @@ def main(argv = None): if argv is None: argv = sys.argv + options = process_command_line(argv[1:]) + + def log_level(): + if options.verbose: + return logging.DEBUG + if options.quiet: + return logging.WARNING + return logging.INFO + logging.basicConfig(stream = sys.stdout, format = '%(levelname) 7s: %(message)s', - level = logging.INFO) + level = log_level()) logging.debug('%s invoked with options "%s"' % ( argv[0], ' '.join(argv[1:]))) @@ -1353,8 +1390,6 @@ def main(argv = None): logging.debug('Platform: OS="%s" machine="%s" proc="%s"' % ( platform.system(), platform.machine(), platform.processor())) - options = process_command_line(argv[1:]) - if options.os == "java": raise Exception("Jython detected: need --os and --cpu to set target") diff --git a/doc/examples/asn1.cpp b/doc/examples/asn1.cpp index 141d4d5b4..11e283a64 100644 --- a/doc/examples/asn1.cpp +++ b/doc/examples/asn1.cpp @@ -1,4 +1,10 @@ /* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +/* A simple ASN.1 parser, similiar to 'dumpasn1' or 'openssl asn1parse', though without some of the bells and whistles of those. Primarily used for testing the BER decoder. The output format is modeled loosely on 'asn1parse -i' @@ -14,12 +20,8 @@ - Nov 25: Much improved BIT STRING output Can deal with non-constructed taggings Can produce UTF-8 output - - This file is in the public domain. */ -/*******************************************************************/ - // Set this if your terminal understands UTF-8; otherwise output is in Latin-1 #define UTF8_TERMINAL 1 @@ -30,8 +32,6 @@ */ #define INITIAL_LEVEL 0 -/*******************************************************************/ - #include <botan/botan.h> #include <botan/bigint.h> #include <botan/der_enc.h> @@ -56,7 +56,7 @@ int main(int argc, char* argv[]) printf("Usage: %s <file>\n", argv[0]); return 1; } - + Botan::LibraryInitializer init; try { diff --git a/doc/examples/base.cpp b/doc/examples/base.cpp deleted file mode 100644 index eca0ccf24..000000000 --- a/doc/examples/base.cpp +++ /dev/null @@ -1,44 +0,0 @@ -/* - A simple template for Botan applications, showing startup, etc -*/ -#include <botan/botan.h> -using namespace Botan; - -/* This is how you can do compile-time version checking */ - -#if BOTAN_VERSION_CODE < BOTAN_VERSION_CODE_FOR(1,6,3) - #error Your Botan installation is too old; upgrade to 1.6.3 or later -#endif - -#include <iostream> - -int main(int argc, char* argv[]) - { - Botan::LibraryInitializer init; - - try - { - /* Put it inside the try block so exceptions at startup/shutdown will - get caught. - - It will be initialized with default options - */ - - if(argc > 2) - { - std::cout << "Usage: " << argv[0] << "[initializer args]\n"; - return 2; - } - - std::string args = (argc == 2) ? argv[1] : ""; - - LibraryInitializer init(args); - // your operations here - } - catch(std::exception& e) - { - std::cout << e.what() << std::endl; - return 1; - } - return 0; - } diff --git a/doc/examples/base64.cpp b/doc/examples/base64.cpp index d35aaf593..dbe8d19e3 100644 --- a/doc/examples/base64.cpp +++ b/doc/examples/base64.cpp @@ -1,12 +1,10 @@ /* -An Botan example application which emulates a poorly written version of -"uuencode -m" - -Written by Jack Lloyd ([email protected]), in maybe an hour scattered -over 2000/2001 - -This file is in the public domain +* Encode/decode base64 strings +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license */ + #include <fstream> #include <iostream> #include <string> diff --git a/doc/examples/bench.cpp b/doc/examples/bench.cpp index 7d53e0557..724c258e4 100644 --- a/doc/examples/bench.cpp +++ b/doc/examples/bench.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/benchmark.h> #include <botan/init.h> #include <botan/auto_rng.h> diff --git a/doc/examples/benchmark.cpp b/doc/examples/benchmark.cpp index fa91726e5..006450314 100644 --- a/doc/examples/benchmark.cpp +++ b/doc/examples/benchmark.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/botan.h> #include <botan/benchmark.h> diff --git a/doc/examples/bzip.cpp b/doc/examples/bzip.cpp index 02252fb94..c3509c4da 100644 --- a/doc/examples/bzip.cpp +++ b/doc/examples/bzip.cpp @@ -1,10 +1,10 @@ /* -An Botan example application which emulates a poorly written version of bzip2 - -Written by Jack Lloyd ([email protected]), Jun 9, 2001 - -This file is in the public domain +* Bzip2 Compression/Decompression +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license */ + #include <string> #include <cstring> #include <vector> @@ -12,6 +12,14 @@ This file is in the public domain #include <iostream> #include <botan/botan.h> +/* +* If Bzip2 isn't included, we know nothing works at compile time, but +* we wait to fail at runtime. Otherwise I would get 2-3 mails a month +* about how this was failing to compile (even with an informative +* #error message explaining the situation) because bzip2 wasn't +* included in the build. +*/ + #if defined(BOTAN_HAS_COMPRESSOR_BZIP2) #include <botan/bzip2.h> #endif diff --git a/doc/examples/ca.cpp b/doc/examples/ca.cpp index 8ca6228c2..25a3b5a03 100644 --- a/doc/examples/ca.cpp +++ b/doc/examples/ca.cpp @@ -1,4 +1,10 @@ /* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +/* Implement the functionality of a simple CA: read in a CA certificate, the associated private key, and a PKCS #10 certificate request. Sign the request and print out the new certificate. @@ -7,10 +13,6 @@ cacert.pem: The CA's certificate (perhaps created by self_sig) caprivate.pem: The CA's private key req.pem: The user's PKCS #10 certificate request - - Written by Jack Lloyd, May 19, 2003 - - This file is in the public domain. */ #include <botan/botan.h> diff --git a/doc/examples/checksum.cpp b/doc/examples/checksum.cpp index 232be057c..dba7a7d70 100644 --- a/doc/examples/checksum.cpp +++ b/doc/examples/checksum.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/botan.h> #include <botan/filters.h> diff --git a/doc/examples/cms_dec.cpp b/doc/examples/cms_dec.cpp index de4d732f0..6a9d99137 100644 --- a/doc/examples/cms_dec.cpp +++ b/doc/examples/cms_dec.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/botan.h> #include <botan/pkcs8.h> #include <botan/cms_dec.h> diff --git a/doc/examples/cms_enc.cpp b/doc/examples/cms_enc.cpp index de16bbaae..2cf813987 100644 --- a/doc/examples/cms_enc.cpp +++ b/doc/examples/cms_enc.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/botan.h> #include <botan/cms_enc.h> using namespace Botan; diff --git a/doc/examples/cpuid.cpp b/doc/examples/cpuid.cpp index 76438783f..8adc8be6c 100644 --- a/doc/examples/cpuid.cpp +++ b/doc/examples/cpuid.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <iostream> #include <botan/cpuid.h> @@ -22,7 +28,6 @@ int main() print_if_feature("SSE4.2", CPUID::has_sse42()); print_if_feature("AES-NI", CPUID::has_aes_intel()); - print_if_feature("AES-VIA", CPUID::has_aes_via()); print_if_feature("AltiVec", CPUID::has_altivec()); } diff --git a/doc/examples/cryptobox.cpp b/doc/examples/cryptobox.cpp index 0a769b0cd..f45f00ca1 100644 --- a/doc/examples/cryptobox.cpp +++ b/doc/examples/cryptobox.cpp @@ -1,6 +1,9 @@ /* -* Cryptobox example +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license */ + #include <botan/botan.h> #include <botan/cryptobox.h> #include <fstream> diff --git a/doc/examples/decrypt.cpp b/doc/examples/decrypt.cpp index 68d5f890b..ebab5d804 100644 --- a/doc/examples/decrypt.cpp +++ b/doc/examples/decrypt.cpp @@ -1,14 +1,17 @@ /* -Decrypt files encrypted with the 'encrypt' example application. - -I'm being lazy and writing the output to stdout rather than stripping off the -".enc" suffix and writing it there. So all diagnostics go to stderr so there is -no confusion. +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ -Written by Jack Lloyd ([email protected]) on August 5, 2002 +/* +Decrypt files encrypted with the 'encrypt' example application. -This file is in the public domain +I'm being lazy and writing the output to stdout rather than stripping +off the ".enc" suffix and writing it there. So all diagnostics go to +stderr so there is no confusion. */ + #include <fstream> #include <iostream> #include <string> diff --git a/doc/examples/dh.cpp b/doc/examples/dh.cpp index 7855aeae5..4c6961234 100644 --- a/doc/examples/dh.cpp +++ b/doc/examples/dh.cpp @@ -1,10 +1,9 @@ /* - A simple DH example - - Written by Jack Lloyd ([email protected]), on December 24, 2003 - - This file is in the public domain +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license */ + #include <botan/botan.h> #include <botan/dh.h> #include <botan/rng.h> diff --git a/doc/examples/dsa_kgen.cpp b/doc/examples/dsa_kgen.cpp index 4669cf705..e949ae54a 100644 --- a/doc/examples/dsa_kgen.cpp +++ b/doc/examples/dsa_kgen.cpp @@ -1,19 +1,23 @@ /* -Generate a 1024 bit DSA key and put it into a file. The public key format is -that specified by X.509, while the private key format is PKCS #8. +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ -The domain parameters are the ones specified as the Java default DSA -parameters. There is nothing special about these, it's just the only 1024-bit -DSA parameter set that's included in Botan at the time of this writing. The -application always reads/writes all of the domain parameters to/from the file, -so a new set could be used without any problems. We could generate a new set -for each key, or read a set of DSA params from a file and use those, but they -mostly seem like needless complications. -Written by Jack Lloyd ([email protected]), August 5, 2002 - Updated to use X.509 and PKCS #8 formats, October 21, 2002 +/** +Generate a 1024 bit DSA key and put it into a file. The public key +format is that specified by X.509, while the private key format is +PKCS #8. -This file is in the public domain +The domain parameters are the ones specified as the Java default DSA +parameters. There is nothing special about these, it's just the only +1024-bit DSA parameter set that's included in Botan at the time of +this writing. The application always reads/writes all of the domain +parameters to/from the file, so a new set could be used without any +problems. We could generate a new set for each key, or read a set of +DSA params from a file and use those, but they mostly seem like +needless complications. */ #include <iostream> diff --git a/doc/examples/dsa_sign.cpp b/doc/examples/dsa_sign.cpp index caf050313..abc22d0de 100644 --- a/doc/examples/dsa_sign.cpp +++ b/doc/examples/dsa_sign.cpp @@ -1,10 +1,8 @@ /* -Decrypt an encrypted DSA private key. Then use that key to sign a message. - -Written by Jack Lloyd ([email protected]), August 5, 2002 - Updated to use X.509 and PKCS #8 format keys, October 21, 2002 - -This file is in the public domain +* DSA signature generation example +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license */ #include <iostream> diff --git a/doc/examples/dsa_ver.cpp b/doc/examples/dsa_ver.cpp index 3b7ea0255..4a2f62ce4 100644 --- a/doc/examples/dsa_ver.cpp +++ b/doc/examples/dsa_ver.cpp @@ -1,14 +1,16 @@ /* -Grab an DSA public key from the file given as an argument, grab a signature -from another file, and verify the message (which, suprise, is also in a file). - -The signature format isn't particularly standard, but it's not bad. It's simply -the IEEE 1363 signature format, encoded into base64 with a trailing newline +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ -Written by Jack Lloyd ([email protected]), August 5, 2002 - Updated to use X.509 format keys, October 21, 2002 +/* +Grab an DSA public key from the file given as an argument, grab a +signature from another file, and verify the message (which, suprise, +is also in a file). -This file is in the public domain +The signature format isn't particularly standard: take the IEEE 1363 +signature format, encoded into base64 with a trailing newline. */ #include <iostream> diff --git a/doc/examples/eax_test.cpp b/doc/examples/eax_test.cpp index 283e33501..3f7dbcbc8 100644 --- a/doc/examples/eax_test.cpp +++ b/doc/examples/eax_test.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <fstream> #include <iostream> #include <sstream> diff --git a/doc/examples/ecdsa.cpp b/doc/examples/ecdsa.cpp index 065203a94..f55005544 100644 --- a/doc/examples/ecdsa.cpp +++ b/doc/examples/ecdsa.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/botan.h> #include <botan/ecdsa.h> #include <botan/pubkey.h> diff --git a/doc/examples/encrypt.cpp b/doc/examples/encrypt.cpp index 348ee8d39..f903c2f24 100644 --- a/doc/examples/encrypt.cpp +++ b/doc/examples/encrypt.cpp @@ -1,4 +1,10 @@ /* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +/* Encrypt a file using a block cipher in CBC mode. Compresses the plaintext with Zlib, MACs with HMAC(SHA-1). Stores the block cipher used in the file, so you don't have to specify it when decrypting. @@ -10,13 +16,8 @@ was compressed. Bonus points for supporting multiple compression schemes. Another flaw is that is stores the entire ciphertext in memory, so if the file you're encrypting is 1 Gb... you better have a lot of RAM. - -Based on the base64 example, of all things - -Written by Jack Lloyd ([email protected]) on August 5, 2002 - -This file is in the public domain */ + #include <fstream> #include <iostream> #include <string> diff --git a/doc/examples/encrypt2.cpp b/doc/examples/encrypt2.cpp index 4af0cf019..dac2f8314 100644 --- a/doc/examples/encrypt2.cpp +++ b/doc/examples/encrypt2.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/botan.h> #include <botan/pbkdf2.h> #include <botan/hmac.h> diff --git a/doc/examples/factor.cpp b/doc/examples/factor.cpp index ff3c23c5d..7700d9b2d 100644 --- a/doc/examples/factor.cpp +++ b/doc/examples/factor.cpp @@ -1,4 +1,10 @@ /* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +/* Factor integers using a combination of trial division by small primes, and Pollard's Rho algorithm */ diff --git a/doc/examples/fpe.cpp b/doc/examples/fpe.cpp index 7108b3ece..73773994b 100644 --- a/doc/examples/fpe.cpp +++ b/doc/examples/fpe.cpp @@ -1,4 +1,10 @@ /* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +/* * Encrypt credit cards numbers with valid checksums into other credit * card numbers with valid checksums using format preserving encryption. */ diff --git a/doc/examples/gen_certs.cpp b/doc/examples/gen_certs.cpp index 5f943ff3a..b267d8791 100644 --- a/doc/examples/gen_certs.cpp +++ b/doc/examples/gen_certs.cpp @@ -1,4 +1,10 @@ /* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +/* * Generate a root CA plus httpd, dovecot, and postfix certs/keys * */ diff --git a/doc/examples/gtk/gtk_ui.h b/doc/examples/gtk/gtk_ui.h index 9ced83a81..065a4f76b 100644 --- a/doc/examples/gtk/gtk_ui.h +++ b/doc/examples/gtk/gtk_ui.h @@ -1,6 +1,8 @@ -/************************************************* -* GTK+ User Interface Header File * -*************************************************/ +/* +* (C) 2006 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ #ifndef BOTAN_EXT_GTK_UI__ #define BOTAN_EXT_GTK_UI__ @@ -8,9 +10,9 @@ #include <botan/ui.h> #include <gtk/gtk.h> -/************************************************* -* GTK+ Passphrase Callback Object * -*************************************************/ +/* +* GTK+ Passphrase Callback Object +*/ class GTK_UI : public Botan::User_Interface { public: diff --git a/doc/examples/hash.cpp b/doc/examples/hash.cpp index a97cd6082..feaa2e9b3 100644 --- a/doc/examples/hash.cpp +++ b/doc/examples/hash.cpp @@ -1,13 +1,7 @@ /* -Prints the message digest of files, using an arbitrary hash function -chosen by the user. This is less flexible that I might like, for example: - ./hash sha1 some_file [or md5 or sha-1 or ripemd160 or ...] -will not work, cause the name lookup is case-sensitive. Oh well... - -Written by Jack Lloyd ([email protected]), on August 4, 2002 - - December 16, 2003: "Fixed" to accept "sha1" or "md5" as a hash name - -This file is in the public domain +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license */ #include <iostream> diff --git a/doc/examples/hash_fd.cpp b/doc/examples/hash_fd.cpp index 82ca2c3b4..32acdbec3 100644 --- a/doc/examples/hash_fd.cpp +++ b/doc/examples/hash_fd.cpp @@ -1,18 +1,17 @@ /* -Written by Jack Lloyd ([email protected]), on Prickle-Prickle, -the 10th of Bureaucracy, 3167. - -This file is in the public domain - -This is just like the normal hash application, but uses the Unix I/O system -calls instead of C++ iostreams. Previously, this version was much faster and -smaller, but GCC 3.1's libstdc++ seems to have been improved enough that the -difference is now fairly minimal. +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ -Nicely enough, doing the change required changing only about 3 lines of code. +/* +This is just like the normal hash application, but uses the Unix I/O +system calls instead of C++ iostreams. Previously, this version was +much faster and smaller, but GCC 3.1's libstdc++ seems to have been +improved enough that the difference is now fairly minimal. -Note that this requires you to be on a machine running some sort of Unix. Well, -I guess any POSIX.1 compliant OS (in theory). +Nicely enough, doing the change required changing only about 3 lines +of code. */ #include <iostream> diff --git a/doc/examples/hash_quickly.cpp b/doc/examples/hash_quickly.cpp index c8c8ca5fb..a5236b381 100644 --- a/doc/examples/hash_quickly.cpp +++ b/doc/examples/hash_quickly.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/botan.h> #include <botan/benchmark.h> #include <botan/filters.h> diff --git a/doc/examples/hasher.cpp b/doc/examples/hasher.cpp index 5ba982fc0..f3f2ab874 100644 --- a/doc/examples/hasher.cpp +++ b/doc/examples/hasher.cpp @@ -1,12 +1,9 @@ /* -A Botan example application which emulates a -poorly written version of "gpg --print-md" - -Written by Jack Lloyd ([email protected]), quite a while ago (as of June -2001) - -This file is in the public domain +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license */ + #include <fstream> #include <iostream> #include <string> diff --git a/doc/examples/hasher2.cpp b/doc/examples/hasher2.cpp index 12d3c853d..abbe11622 100644 --- a/doc/examples/hasher2.cpp +++ b/doc/examples/hasher2.cpp @@ -1,15 +1,18 @@ /* -Identical to hasher.cpp, but uses Pipe in a different way. - -Note this tends to be much less efficient than hasher.cpp, because it does -three passes over the file. For a small file, it doesn't really matter. But for -a large file, or for something you can't re-read easily (socket, stdin, ...) -this is a bad idea. +* (C) 2001 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ -Written by Jack Lloyd ([email protected]), Feb 8 2001 +/* +Identical to hasher.cpp, but uses Pipe in a different way. -This file is in the public domain +Note this tends to be much less efficient than hasher.cpp, because it +does three passes over the file. For a small file, it doesn't really +matter. But for a large file, or for something you can't re-read +easily (socket, stdin, ...) this is a bad idea. */ + #include <fstream> #include <iostream> #include <string> diff --git a/doc/examples/make_prime.cpp b/doc/examples/make_prime.cpp index eaff1867f..acaaac698 100644 --- a/doc/examples/make_prime.cpp +++ b/doc/examples/make_prime.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/numthry.h> #include <botan/auto_rng.h> #include <botan/botan.h> diff --git a/doc/examples/package.cpp b/doc/examples/package.cpp index 866dd7e96..14d215f73 100644 --- a/doc/examples/package.cpp +++ b/doc/examples/package.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/botan.h> #include <botan/serpent.h> diff --git a/doc/examples/passhash.cpp b/doc/examples/passhash.cpp index 7f5bbc2bb..24f7ff674 100644 --- a/doc/examples/passhash.cpp +++ b/doc/examples/passhash.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/botan.h> #include <botan/pbkdf2.h> #include <botan/hmac.h> diff --git a/doc/examples/pkcs10.cpp b/doc/examples/pkcs10.cpp index d9fa9accb..3f5ec8e05 100644 --- a/doc/examples/pkcs10.cpp +++ b/doc/examples/pkcs10.cpp @@ -1,12 +1,9 @@ /* -Generate a 1024 bit RSA key, and then create a PKCS #10 certificate request for -that key. The private key will be stored as an encrypted PKCS #8 object, and -stored in another file. - -Written by Jack Lloyd ([email protected]), April 7, 2003 - -This file is in the public domain +* (C) 2003 Jack Lloyd +* +* Distributed under the terms of the Botan license */ + #include <botan/init.h> #include <botan/auto_rng.h> #include <botan/x509self.h> diff --git a/doc/examples/pqg_gen.cpp b/doc/examples/pqg_gen.cpp index e4b959883..e797233f9 100644 --- a/doc/examples/pqg_gen.cpp +++ b/doc/examples/pqg_gen.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <iostream> #include <fstream> #include <string> @@ -25,7 +31,7 @@ int main() std::ifstream in("PQGGen.rsp"); if(!in) - throw Exception("Can't open response file"); + throw std::runtime_error("Can't open response file"); std::map<std::string, std::string> inputs; @@ -40,7 +46,7 @@ int main() std::vector<std::string> name_and_val = split_on(line, '='); if(name_and_val.size() != 2) - throw Decoding_Error("Unexpected input: " + line); + throw std::runtime_error("Unexpected input: " + line); name_and_val[0].erase(name_and_val[0].size()-1); name_and_val[1].erase(0, 1); diff --git a/doc/examples/read_ssh.cpp b/doc/examples/read_ssh.cpp index a88306caa..52c758ceb 100644 --- a/doc/examples/read_ssh.cpp +++ b/doc/examples/read_ssh.cpp @@ -1,4 +1,10 @@ /* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +/* * Example of reading SSH2 format public keys (see RFC 4716) */ diff --git a/doc/examples/ressol.cpp b/doc/examples/ressol.cpp index 43bb68d37..286377fc6 100644 --- a/doc/examples/ressol.cpp +++ b/doc/examples/ressol.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/numthry.h> #include <botan/auto_rng.h> #include <botan/botan.h> diff --git a/doc/examples/rng_test.cpp b/doc/examples/rng_test.cpp index 8d4253a6e..05f2c28a4 100644 --- a/doc/examples/rng_test.cpp +++ b/doc/examples/rng_test.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/botan.h> #include <botan/x931_rng.h> #include <botan/filters.h> diff --git a/doc/examples/row_encryptor.cpp b/doc/examples/row_encryptor.cpp index 162e962e0..17f44ce7b 100644 --- a/doc/examples/row_encryptor.cpp +++ b/doc/examples/row_encryptor.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <string> #include <memory> #include <sstream> @@ -99,8 +105,8 @@ std::string Row_Encryptor::decrypt(const std::string& input, return dec_pipe.read_all_as_string(Pipe::LAST_MESSAGE); } -/************************* - Test code follows: +/* +* Test code follows: */ int main() diff --git a/doc/examples/rsa_dec.cpp b/doc/examples/rsa_dec.cpp index 25ce33f47..1e789d748 100644 --- a/doc/examples/rsa_dec.cpp +++ b/doc/examples/rsa_dec.cpp @@ -1,11 +1,13 @@ /* +* (C) 2002 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +/* Decrypt an encrypted RSA private key. Then use that key to decrypt a message. This program can decrypt messages generated by rsa_enc, and uses the same key format as that generated by rsa_kgen. - -Written by Jack Lloyd ([email protected]), June 3-5, 2002 - -This file is in the public domain */ #include <iostream> diff --git a/doc/examples/rsa_enc.cpp b/doc/examples/rsa_enc.cpp index f9b8c5561..904b1e379 100644 --- a/doc/examples/rsa_enc.cpp +++ b/doc/examples/rsa_enc.cpp @@ -1,4 +1,10 @@ /* +* (C) 2002 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +/* Grab an RSA public key from the file given as an argument, grab a message from another file, and encrypt the message. @@ -18,12 +24,6 @@ the _plaintext_ 3) Following lines are base64 encoded ciphertext (CAST-128 as described), each broken after ~72 characters. - -Written by Jack Lloyd ([email protected]), June 3, 2002 - Updated to use KDF2, September 8, 2002 - Updated to read X.509 keys, October 21, 2002 - -This file is in the public domain */ #include <iostream> diff --git a/doc/examples/rsa_kgen.cpp b/doc/examples/rsa_kgen.cpp index b7e90ef8a..1108b46db 100644 --- a/doc/examples/rsa_kgen.cpp +++ b/doc/examples/rsa_kgen.cpp @@ -1,12 +1,13 @@ /* +* (C) 2002 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +/* Generate an RSA key of a specified bitlength, and put it into a pair of key files. One is the public key in X.509 format (PEM encoded), the private key is in PKCS #8 format (also PEM encoded). - -Written by Jack Lloyd ([email protected]), June 2-3, 2002 - Updated to use X.509 and PKCS #8 on October 21, 2002 - -This file is in the public domain */ #include <iostream> diff --git a/doc/examples/rsa_manykey.cpp b/doc/examples/rsa_manykey.cpp index cf810749a..c282e7882 100644 --- a/doc/examples/rsa_manykey.cpp +++ b/doc/examples/rsa_manykey.cpp @@ -1,4 +1,10 @@ /* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +/* Generate a whole sequence of keys (for benchmarking) */ diff --git a/doc/examples/self_sig.cpp b/doc/examples/self_sig.cpp index 93161f7d2..6710cfb51 100644 --- a/doc/examples/self_sig.cpp +++ b/doc/examples/self_sig.cpp @@ -1,14 +1,17 @@ /* -Generate a 1024 bit RSA key, and then create a self-signed X.509v3 certificate -with that key. If the do_CA variable is set to true, then it will be marked for -CA use, otherwise it will get extensions appropriate for use with a client -certificate. The private key is stored as an encrypted PKCS #8 object in -another file. - -Written by Jack Lloyd ([email protected]), April 7, 2003 +* (C) 2003 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ -This file is in the public domain +/* +Generate a 1024 bit RSA key, and then create a self-signed X.509v3 +certificate with that key. If the do_CA variable is set to true, then +it will be marked for CA use, otherwise it will get extensions +appropriate for use with a client certificate. The private key is +stored as an encrypted PKCS #8 object in another file. */ + #include <botan/botan.h> #include <botan/x509self.h> #include <botan/rsa.h> diff --git a/doc/examples/sig_gen.cpp b/doc/examples/sig_gen.cpp index 6dd749097..fca069862 100644 --- a/doc/examples/sig_gen.cpp +++ b/doc/examples/sig_gen.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <iostream> #include <fstream> #include <string> diff --git a/doc/examples/stack.cpp b/doc/examples/stack.cpp index 1522b05f5..f569004fc 100644 --- a/doc/examples/stack.cpp +++ b/doc/examples/stack.cpp @@ -1,11 +1,13 @@ /* -An Botan example application showing how to use the pop and prepend functions -of Pipe. Based on the md5 example. It's output should always be identical to -such. - -Written by Jack Lloyd ([email protected]), Feb 3, 2002 +* (C) 2002 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ -This file is in the public domain +/* +An Botan example application showing how to use the pop and prepend +functions of Pipe. Based on the md5 example. It's output should always +be identical to such. */ #include <iostream> diff --git a/doc/examples/test_es.cpp b/doc/examples/test_es.cpp deleted file mode 100644 index b5510ab75..000000000 --- a/doc/examples/test_es.cpp +++ /dev/null @@ -1,115 +0,0 @@ -#include <botan/botan.h> -#include <stdio.h> - -#if defined(BOTAN_HAS_ENTROPY_SRC_DEV_RANDOM) - #include <botan/internal/dev_random.h> -#endif - -#if defined(BOTAN_HAS_ENTROPY_SRC_EGD) - #include <botan/internal/es_egd.h> -#endif - -#if defined(BOTAN_HAS_ENTROPY_SRC_UNIX) - #include <botan/internal/es_unix.h> -#endif - -#if defined(BOTAN_HAS_ENTROPY_SRC_BEOS) - #include <botan/internal/es_beos.h> -#endif - -#if defined(BOTAN_HAS_ENTROPY_SRC_CAPI) - #include <botan/internal/es_capi.h> -#endif - -#if defined(BOTAN_HAS_ENTROPY_SRC_WIN32) - #include <botan/internal/es_win32.h> -#endif - -#if defined(BOTAN_HAS_ENTROPY_SRC_FTW) - #include <botan/internal/es_ftw.h> -#endif - - -using namespace Botan; - -class Saver_Of_Bytes : public Entropy_Accumulator - { - public: - Saver_Of_Bytes(u32bit bits) : - Entropy_Accumulator(bits), outbuf(64), written(0) {} - - void add_bytes(const byte in[], u32bit length) - { - for(size_t i = 0; i != length; ++i) - outbuf[i % outbuf.size()] ^= in[i]; - - written += length; - } - - void trunc() { if(written < 64) outbuf.resize(written); } - - std::vector<byte> outbuf; - u32bit written; - }; - -void test_entropy_source(EntropySource* es) - { - // sometimes iostreams really is just a pain - - printf("Polling '%s':\n", es->name().c_str()); - - Saver_Of_Bytes accum(128); - - es->poll(accum); - - accum.trunc(); - - printf("Got %d bytes\n", accum.written); - for(size_t i = 0; i != accum.outbuf.size(); ++i) - printf("%02X", accum.outbuf[i]); - printf("\n"); - - delete es; - } - -int main() - { - Botan::LibraryInitializer init; - -#if defined(BOTAN_HAS_ENTROPY_SRC_DEV_RANDOM) - test_entropy_source( - new Device_EntropySource( - split_on("/dev/random:/dev/srandom:/dev/urandom", ':') - ) - ); -#endif - -#if defined(BOTAN_HAS_ENTROPY_SRC_EGD) - test_entropy_source( - new EGD_EntropySource(split_on("/var/run/egd-pool:/dev/egd-pool", ':')) - ); -#endif - -#if defined(BOTAN_HAS_ENTROPY_SRC_CAPI) - test_entropy_source(new Win32_CAPI_EntropySource); -#endif - -#if defined(BOTAN_HAS_ENTROPY_SRC_FTW) - test_entropy_source(new FTW_EntropySource("/proc")); -#endif - - -#if defined(BOTAN_HAS_ENTROPY_SRC_WIN32) - test_entropy_source(new Win32_EntropySource); -#endif - -#if defined(BOTAN_HAS_ENTROPY_SRC_BEOS) - test_entropy_source(new BeOS_EntropySource); -#endif - -#if defined(BOTAN_HAS_ENTROPY_SRC_UNIX) - test_entropy_source( - new Unix_EntropySource(split_on("/bin:/sbin:/usr/bin:/usr/sbin", ':')) - ); -#endif - } diff --git a/doc/examples/toolbox.cpp b/doc/examples/toolbox.cpp new file mode 100644 index 000000000..622a1f56f --- /dev/null +++ b/doc/examples/toolbox.cpp @@ -0,0 +1,235 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/botan.h> + +#if defined(BOTAN_HAS_COMPRESSOR_BZIP2) + #include <botan/bzip2.h> +#endif + +#if defined(BOTAN_HAS_COMPRESSOR_ZLIB) + #include <botan/zlib.h> +#endif + +#include <iostream> +#include <fstream> + +using namespace Botan; + +#include "../../checks/getopt.h" + +class Encoder_Decoder + { + public: + Encoder_Decoder(const std::string& command, + bool decode, + const std::vector<std::string>& args) : + type(command), + args(args), + decode(decode) + { } + + void run(std::istream& in, std::ostream& out) + { + Filter* filt = decode ? decoder(type) : encoder(type); + + DataSource_Stream src(in); + Pipe pipe(filt, new DataSink_Stream(out)); + pipe.process_msg(src); + } + + Filter* encoder(const std::string& type) const + { + if(type == "hex") return new Hex_Encoder; + if(type == "base64") return new Base64_Encoder; + +#if defined(BOTAN_HAS_COMPRESSOR_BZIP2) + if(type == "bzip2") return new Bzip_Compression; +#endif + +#if defined(BOTAN_HAS_COMPRESSOR_ZLIB) + if(type == "zlib") return new Zlib_Compression; +#endif + return 0; + } + + Filter* decoder(const std::string& type) const + { + if(type == "hex") return new Hex_Decoder; + if(type == "base64") return new Base64_Decoder; + +#if defined(BOTAN_HAS_COMPRESSOR_BZIP2) + if(type == "bzip2") return new Bzip_Decompression; +#endif + +#if defined(BOTAN_HAS_COMPRESSOR_ZLIB) + if(type == "zlib") return new Zlib_Decompression; +#endif + + return 0; + } + + private: + std::string type; + std::vector<std::string> args; + bool decode; + }; + +void run_command(const std::string& command, + const std::vector<std::string>& arguments, + const OptionParser& opts) + { + if(command == "hex" || + command == "base64" || + command == "bzip2" || + command == "zlib") + { + bool decode = opts.is_set("decode"); + + std::string output = opts.value_or_else("output", "-"); + std::string input = opts.value_or_else("input", "-"); + + Encoder_Decoder enc_dec(command, decode, arguments); + + try + { + if(output == "-") + { + if(input == "-") + enc_dec.run(std::cin, std::cout); + else + { + std::ifstream in(input.c_str()); + enc_dec.run(in, std::cout); + } + } + else // output != "-" + { + std::ofstream out(output.c_str()); + + if(input == "-") + enc_dec.run(std::cin, out); + else + { + std::ifstream in(input.c_str()); + enc_dec.run(in, out); + } + } + } + catch(Botan::Stream_IO_Error& e) + { + std::cout << "I/O failure - " << e.what() << '\n'; + } + } + else if(command == "hash" || + command == "sha1" || + command == "md5") + { + std::string hash; + + if(command == "md5") + hash = "MD5"; + if(command == "sha1") + hash = "SHA-160"; + else + hash = opts.value_or_else("hash", "SHA-160"); // sha1 is default + + Pipe pipe(new Hash_Filter(get_hash(hash)), + new Hex_Encoder(false, 0, Hex_Encoder::Lowercase)); + + for(size_t i = 0; i != arguments.size(); ++i) + { + std::string file_name = arguments[i]; + + u32bit previously = pipe.message_count(); + + if(file_name == "-") + { + pipe.start_msg(); + std::cin >> pipe; + pipe.end_msg(); + } + else + { + std::ifstream in(file_name.c_str()); + if(in) + { + pipe.start_msg(); + in >> pipe; + pipe.end_msg(); + } + else + std::cerr << "Could not read " << file_name << '\n'; + } + + if(pipe.message_count() > previously) + std::cout << pipe.read_all_as_string(Pipe::LAST_MESSAGE) << " " + << file_name << '\n'; + } + + } + else + { + std::cerr << "Command " << command << " not known\n"; + } + } + +int main(int argc, char* argv[]) + { + LibraryInitializer init; + + OptionParser opts("help|version|seconds=|" + "input=|output=|decode|" + "hash=|key="); + + try + { + opts.parse(argv); + } + catch(std::runtime_error& e) + { + std::cout << "Command line problem: " << e.what() << '\n'; + return 2; + } + + if(opts.is_set("version") || argc <= 1) + { + std::cerr << "Botan Toolbox v" << version_string() << '\n'; + std::cerr << "Commands: hash hex base64 "; +#if defined(BOTAN_HAS_COMPRESSOR_BZIP2) + std::cerr << "bzip2 "; +#endif + +#if defined(BOTAN_HAS_COMPRESSOR_ZLIB) + std::cerr << "zlib "; +#endif + + std::cerr << "\n"; + + return 0; + } + + if(opts.is_set("help")) + { + std::vector<std::string> what = opts.leftovers(); + + for(size_t i = 0; i != what.size(); ++i) + std::cerr << what[i] << "? Never heard of it\n"; + return 0; + } + + std::vector<std::string> args = opts.leftovers(); + + if(args.size() == 0) + return 0; + + std::string command = args[0]; + args.erase(args.begin()); + + run_command(command, args, opts); + + return 0; + } diff --git a/doc/examples/tss.cpp b/doc/examples/tss.cpp index 1881ffe24..03d7699bf 100644 --- a/doc/examples/tss.cpp +++ b/doc/examples/tss.cpp @@ -1,3 +1,9 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + #include <botan/botan.h> #include <botan/tss.h> #include <iostream> diff --git a/doc/examples/x509info.cpp b/doc/examples/x509info.cpp index 0e34f2fab..8f4d83c45 100644 --- a/doc/examples/x509info.cpp +++ b/doc/examples/x509info.cpp @@ -1,12 +1,10 @@ /* - Read an X.509 certificate, and print various things about it - - Written by Jack Lloyd, March 23 2003 - - October 31, 2003: Prints the public key - - November 1, 2003: Removed the -d flag; it can tell automatically now - - This file is in the public domain +* Read an X.509 certificate, and print various things about it +* (C) 2003 Jack Lloyd +* +* Distributed under the terms of the Botan license */ + #include <botan/botan.h> #include <botan/x509cert.h> #include <botan/oids.h> diff --git a/doc/examples/xor_ciph.cpp b/doc/examples/xor_ciph.cpp index 6a914b150..3174e103e 100644 --- a/doc/examples/xor_ciph.cpp +++ b/doc/examples/xor_ciph.cpp @@ -1,11 +1,11 @@ /* - An implementation of the highly secure (not) XOR cipher. AKA, how to write - and use your own cipher object. DO NOT make up your own ciphers. Please. - - Written by Jack Lloyd ([email protected]) on Feb 17, 2004 - Update November 21 2008 for new algorithm factory in 1.8 +* (C) 2004,2008 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ - This file is in the public domain +/* + Adding a simple XOR cipher to the internal tables */ #include <botan/stream_cipher.h> diff --git a/doc/license.txt b/doc/license.txt index 9d1067cc1..61615c3af 100644 --- a/doc/license.txt +++ b/doc/license.txt @@ -1,6 +1,6 @@ Botan (http://botan.randombit.net/) is distributed under these terms: -Copyright (C) 1999-2009 Jack Lloyd +Copyright (C) 1999-2010 Jack Lloyd 2001 Peter J Jones 2004-2007 Justin Karneges 2005 Matthew Gregan diff --git a/doc/log.txt b/doc/log.txt index c150e6f66..bb84922d2 100644 --- a/doc/log.txt +++ b/doc/log.txt @@ -1,8 +1,13 @@ * 1.9.4-dev, ????-??-?? + - Add SIMD implementation of Noekeon - Add SSE2 implementation of IDEA + - Perform XTS encryption and decryption in parallel where possible + - Perform CBC decryption in parallel where possible + - Add a block cipher cascade construction - Add support for Win32 high resolution system timers - Remove Timer class entirely + - Switch default PKCS #8 encryption algorithm from 3DES to AES-256 - New option --gen-amalgamation for creating a SQLite-style amalgamation - Many headers are now explicitly internal-use-only and are not installed - Greatly improve the Win32 installer diff --git a/src/algo_factory/algo_factory.h b/src/algo_factory/algo_factory.h index 1f4b577ee..8c1c47060 100644 --- a/src/algo_factory/algo_factory.h +++ b/src/algo_factory/algo_factory.h @@ -44,61 +44,110 @@ class BOTAN_DLL Algorithm_Factory */ ~Algorithm_Factory(); - /* - * Provider management + /** + * @param algo_spec the algorithm we are querying + * @returns list of providers of this algorithm */ std::vector<std::string> providers_of(const std::string& algo_spec); + /** + * @param algo_spec the algorithm we are setting a provider for + * @param provider the provider we would like to use + */ void set_preferred_provider(const std::string& algo_spec, const std::string& provider); - /* - * Block cipher operations + /** + * @param algo_spec the algorithm we want + * @param provider the provider we would like to use + * @returns pointer to const prototype object, readiny for clone(), or NULL */ const BlockCipher* prototype_block_cipher(const std::string& algo_spec, const std::string& provider = ""); + /** + * @param algo_spec the algorithm we want + * @param provider the provider we would like to use + * @returns pointer to freshly created instance of the request algorithm + */ BlockCipher* make_block_cipher(const std::string& algo_spec, const std::string& provider = ""); - void add_block_cipher(BlockCipher* hash, const std::string& provider); + /** + * @param algo the algorithm to add + * @param provider the provider of this algorithm + */ + void add_block_cipher(BlockCipher* algo, const std::string& provider); - /* - * Stream cipher operations + /** + * @param algo_spec the algorithm we want + * @param provider the provider we would like to use + * @returns pointer to const prototype object, readiny for clone(), or NULL */ const StreamCipher* prototype_stream_cipher(const std::string& algo_spec, const std::string& provider = ""); + /** + * @param algo_spec the algorithm we want + * @param provider the provider we would like to use + * @returns pointer to freshly created instance of the request algorithm + */ StreamCipher* make_stream_cipher(const std::string& algo_spec, const std::string& provider = ""); - void add_stream_cipher(StreamCipher* hash, const std::string& provider); + /** + * @param algo the algorithm to add + * @param provider the provider of this algorithm + */ + void add_stream_cipher(StreamCipher* algo, const std::string& provider); - /* - * Hash function operations + /** + * @param algo_spec the algorithm we want + * @param provider the provider we would like to use + * @returns pointer to const prototype object, readiny for clone(), or NULL */ const HashFunction* prototype_hash_function(const std::string& algo_spec, const std::string& provider = ""); + /** + * @param algo_spec the algorithm we want + * @param provider the provider we would like to use + * @returns pointer to freshly created instance of the request algorithm + */ HashFunction* make_hash_function(const std::string& algo_spec, const std::string& provider = ""); - void add_hash_function(HashFunction* hash, const std::string& provider); + /** + * @param algo the algorithm to add + * @param provider the provider of this algorithm + */ + void add_hash_function(HashFunction* algo, const std::string& provider); - /* - * MAC operations + /** + * @param algo_spec the algorithm we want + * @param provider the provider we would like to use + * @returns pointer to const prototype object, readiny for clone(), or NULL */ const MessageAuthenticationCode* prototype_mac(const std::string& algo_spec, const std::string& provider = ""); + /** + * @param algo_spec the algorithm we want + * @param provider the provider we would like to use + * @returns pointer to freshly created instance of the request algorithm + */ MessageAuthenticationCode* make_mac(const std::string& algo_spec, const std::string& provider = ""); - void add_mac(MessageAuthenticationCode* mac, + /** + * @param algo the algorithm to add + * @param provider the provider of this algorithm + */ + void add_mac(MessageAuthenticationCode* algo, const std::string& provider); /* diff --git a/src/algo_factory/prov_weight.cpp b/src/algo_factory/prov_weight.cpp index c7c2d8d8d..17284d024 100644 --- a/src/algo_factory/prov_weight.cpp +++ b/src/algo_factory/prov_weight.cpp @@ -19,15 +19,17 @@ u32bit static_provider_weight(const std::string& prov_name) * them, set the provider explicitly for the algorithms you want */ - if(prov_name == "core") return 5; - if(prov_name == "ia32") return 6; - if(prov_name == "amd64") return 7; + if(prov_name == "aes_isa") return 9; if(prov_name == "simd") return 8; + if(prov_name == "amd64") return 7; + if(prov_name == "ia32") return 6; + + if(prov_name == "core") return 5; if(prov_name == "openssl") return 2; if(prov_name == "gmp") return 1; - return 0; // other + return 0; // other/unknown } } diff --git a/src/alloc/mem_pool/mem_pool.cpp b/src/alloc/mem_pool/mem_pool.cpp index 031cc2656..ba82fefdc 100644 --- a/src/alloc/mem_pool/mem_pool.cpp +++ b/src/alloc/mem_pool/mem_pool.cpp @@ -15,19 +15,6 @@ namespace Botan { -namespace { - -/* -* Memory Allocation Exception -*/ -struct Memory_Exhaustion : public std::bad_alloc - { - const char* what() const throw() - { return "Ran out of memory, allocation failed"; } - }; - -} - /* * Memory_Block Constructor */ diff --git a/src/alloc/system_alloc/defalloc.cpp b/src/alloc/system_alloc/defalloc.cpp index faaeb3c58..311057462 100644 --- a/src/alloc/system_alloc/defalloc.cpp +++ b/src/alloc/system_alloc/defalloc.cpp @@ -94,7 +94,7 @@ Allocator* Allocator::get(bool locking) if(alloc) return alloc; - throw Exception("Couldn't find an allocator to use in get_allocator"); + throw Internal_Error("Couldn't find an allocator to use in get_allocator"); } } diff --git a/src/block/block_cipher.h b/src/block/block_cipher.h index e97eebf0f..06e8c5cea 100644 --- a/src/block/block_cipher.h +++ b/src/block/block_cipher.h @@ -59,8 +59,21 @@ class BOTAN_DLL BlockCipher : public SymmetricAlgorithm */ void decrypt(byte block[]) const { decrypt_n(block, block, 1); } + /** + * Encrypt one or more blocks + * @param in the input buffer (multiple of BLOCK_SIZE) + * @param out the output buffer (same size as in) + * @param blocks the number of blocks to process + */ virtual void encrypt_n(const byte in[], byte out[], u32bit blocks) const = 0; + + /** + * Decrypt one or more blocks + * @param in the input buffer (multiple of BLOCK_SIZE) + * @param out the output buffer (same size as in) + * @param blocks the number of blocks to process + */ virtual void decrypt_n(const byte in[], byte out[], u32bit blocks) const = 0; diff --git a/src/block/cascade/cascade.cpp b/src/block/cascade/cascade.cpp new file mode 100644 index 000000000..f72ef7b76 --- /dev/null +++ b/src/block/cascade/cascade.cpp @@ -0,0 +1,98 @@ +/* +* Block Cipher Cascade +* (C) 2010 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/cascade.h> + +namespace Botan { + +void Cascade_Cipher::encrypt_n(const byte in[], byte out[], + u32bit blocks) const + { + u32bit c1_blocks = blocks * (BLOCK_SIZE / cipher1->BLOCK_SIZE); + u32bit c2_blocks = blocks * (BLOCK_SIZE / cipher2->BLOCK_SIZE); + + cipher1->encrypt_n(in, out, c1_blocks); + cipher2->encrypt_n(out, out, c2_blocks); + } + +void Cascade_Cipher::decrypt_n(const byte in[], byte out[], + u32bit blocks) const + { + u32bit c1_blocks = blocks * (BLOCK_SIZE / cipher1->BLOCK_SIZE); + u32bit c2_blocks = blocks * (BLOCK_SIZE / cipher2->BLOCK_SIZE); + + cipher2->decrypt_n(in, out, c2_blocks); + cipher1->decrypt_n(out, out, c1_blocks); + } + +void Cascade_Cipher::key_schedule(const byte key[], u32bit) + { + const byte* key2 = key + cipher1->MAXIMUM_KEYLENGTH; + + cipher1->set_key(key , cipher1->MAXIMUM_KEYLENGTH); + cipher2->set_key(key2, cipher2->MAXIMUM_KEYLENGTH); + } + +void Cascade_Cipher::clear() + { + cipher1->clear(); + cipher2->clear(); + } + +std::string Cascade_Cipher::name() const + { + return "Cascade(" + cipher1->name() + "," + cipher2->name() + ")"; + } + +BlockCipher* Cascade_Cipher::clone() const + { + return new Cascade_Cipher(cipher1->clone(), + cipher2->clone()); + } + +namespace { + +u32bit euclids_algorithm(u32bit a, u32bit b) + { + while(b != 0) // gcd + { + u32bit t = b; + b = a % b; + a = t; + } + + return a; + } + +u32bit block_size_for_cascade(u32bit bs, u32bit bs2) + { + if(bs == bs2) + return bs; + + u32bit gcd = euclids_algorithm(bs, bs2); + + return (bs * bs2) / gcd; + } + +} + +Cascade_Cipher::Cascade_Cipher(BlockCipher* c1, BlockCipher* c2) : + BlockCipher(block_size_for_cascade(c1->BLOCK_SIZE, c2->BLOCK_SIZE), + c1->MAXIMUM_KEYLENGTH + c2->MAXIMUM_KEYLENGTH), + cipher1(c1), cipher2(c2) + { + if(BLOCK_SIZE % c1->BLOCK_SIZE || BLOCK_SIZE % c2->BLOCK_SIZE) + throw Internal_Error("Failure in " + name() + " constructor"); + } + +Cascade_Cipher::~Cascade_Cipher() + { + delete cipher1; + delete cipher2; + } + +} diff --git a/src/block/cascade/cascade.h b/src/block/cascade/cascade.h new file mode 100644 index 000000000..98c64fb3e --- /dev/null +++ b/src/block/cascade/cascade.h @@ -0,0 +1,41 @@ +/* +* Block Cipher Cascade +* (C) 2010 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#ifndef BOTAN_CASCADE_H__ +#define BOTAN_CASCADE_H__ + +#include <botan/block_cipher.h> + +namespace Botan { + +/* +* Block Cipher Cascade +*/ +class BOTAN_DLL Cascade_Cipher : public BlockCipher + { + public: + void encrypt_n(const byte in[], byte out[], u32bit blocks) const; + void decrypt_n(const byte in[], byte out[], u32bit blocks) const; + + void clear(); + std::string name() const; + BlockCipher* clone() const; + + Cascade_Cipher(BlockCipher* cipher1, BlockCipher* cipher2); + + ~Cascade_Cipher(); + private: + void key_schedule(const byte[], u32bit); + + BlockCipher* cipher1; + BlockCipher* cipher2; + }; + + +} + +#endif diff --git a/src/block/cascade/info.txt b/src/block/cascade/info.txt new file mode 100644 index 000000000..0e6f4acdd --- /dev/null +++ b/src/block/cascade/info.txt @@ -0,0 +1,9 @@ +define CASCADE + +<header:public> +cascade.h +</header:public> + +<source> +cascade.cpp +</source> diff --git a/src/block/idea_sse2/idea_sse2.cpp b/src/block/idea_sse2/idea_sse2.cpp index c00d13ee9..0fe35112d 100644 --- a/src/block/idea_sse2/idea_sse2.cpp +++ b/src/block/idea_sse2/idea_sse2.cpp @@ -6,7 +6,6 @@ */ #include <botan/idea_sse2.h> -#include <botan/loadstor.h> #include <emmintrin.h> namespace Botan { diff --git a/src/block/lion/lion.cpp b/src/block/lion/lion.cpp index 51567d304..cfb1406d7 100644 --- a/src/block/lion/lion.cpp +++ b/src/block/lion/lion.cpp @@ -116,8 +116,9 @@ Lion::Lion(HashFunction* hash_in, StreamCipher* sc_in, u32bit block_len) : { if(2*LEFT_SIZE + 1 > BLOCK_SIZE) throw Invalid_Argument(name() + ": Chosen block size is too small"); + if(!cipher->valid_keylength(LEFT_SIZE)) - throw Exception(name() + ": This stream/hash combination is invalid"); + throw Invalid_Argument(name() + ": This stream/hash combo is invalid"); key1.resize(LEFT_SIZE); key2.resize(LEFT_SIZE); diff --git a/src/block/noekeon/noekeon.h b/src/block/noekeon/noekeon.h index 4532c1be2..22ef65342 100644 --- a/src/block/noekeon/noekeon.h +++ b/src/block/noekeon/noekeon.h @@ -26,7 +26,7 @@ class BOTAN_DLL Noekeon : public BlockCipher BlockCipher* clone() const { return new Noekeon; } Noekeon() : BlockCipher(16, 16) {} - private: + protected: void key_schedule(const byte[], u32bit); static const byte RC[17]; diff --git a/src/block/noekeon_simd/info.txt b/src/block/noekeon_simd/info.txt new file mode 100644 index 000000000..b73954cff --- /dev/null +++ b/src/block/noekeon_simd/info.txt @@ -0,0 +1,7 @@ +define NOEKEON_SIMD + +<requires> +noekeon +simd_32 +simd_engine +</requires> diff --git a/src/block/noekeon_simd/noekeon_simd.cpp b/src/block/noekeon_simd/noekeon_simd.cpp new file mode 100644 index 000000000..f44104901 --- /dev/null +++ b/src/block/noekeon_simd/noekeon_simd.cpp @@ -0,0 +1,161 @@ +/* +* Noekeon in SIMD +* (C) 2010 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/noekeon_simd.h> +#include <botan/internal/simd_32.h> + +namespace Botan { + +/* +* Noekeon's Theta Operation +*/ +#define NOK_SIMD_THETA(A0, A1, A2, A3, K0, K1, K2, K3) \ + do { \ + SIMD_32 T = A0 ^ A2; \ + T ^= rotate_left(T, 8) ^ rotate_right(T, 8); \ + A1 ^= T; \ + A3 ^= T; \ + \ + A0 ^= K0; \ + A1 ^= K1; \ + A2 ^= K2; \ + A3 ^= K3; \ + \ + T = A1 ^ A3; \ + T ^= rotate_left(T, 8) ^ rotate_right(T, 8); \ + A0 ^= T; \ + A2 ^= T; \ + } while(0) + +/* +* Noekeon's Gamma S-Box Layer +*/ +#define NOK_SIMD_GAMMA(A0, A1, A2, A3) \ + do \ + { \ + A1 ^= A3.andc(~A2); \ + A0 ^= A2 & A1; \ + \ + SIMD_32 T = A3; \ + A3 = A0; \ + A0 = T; \ + \ + A2 ^= A0 ^ A1 ^ A3; \ + \ + A1 ^= A3.andc(~A2); \ + A0 ^= A2 & A1; \ + } while(0) + +/* +* Noekeon Encryption +*/ +void Noekeon_SIMD::encrypt_n(const byte in[], byte out[], u32bit blocks) const + { + SIMD_32 K0 = SIMD_32(EK[0]); + SIMD_32 K1 = SIMD_32(EK[1]); + SIMD_32 K2 = SIMD_32(EK[2]); + SIMD_32 K3 = SIMD_32(EK[3]); + + while(blocks >= 4) + { + SIMD_32 A0 = SIMD_32::load_be(in ); + SIMD_32 A1 = SIMD_32::load_be(in + 16); + SIMD_32 A2 = SIMD_32::load_be(in + 32); + SIMD_32 A3 = SIMD_32::load_be(in + 48); + + SIMD_32::transpose(A0, A1, A2, A3); + + for(u32bit i = 0; i != 16; ++i) + { + A0 ^= SIMD_32(RC[i]); + + NOK_SIMD_THETA(A0, A1, A2, A3, K0, K1, K2, K3); + + A1.rotate_left(1); + A2.rotate_left(5); + A3.rotate_left(2); + + NOK_SIMD_GAMMA(A0, A1, A2, A3); + + A1.rotate_right(1); + A2.rotate_right(5); + A3.rotate_right(2); + } + + A0 ^= SIMD_32(RC[16]); + NOK_SIMD_THETA(A0, A1, A2, A3, K0, K1, K2, K3); + + SIMD_32::transpose(A0, A1, A2, A3); + + A0.store_be(out); + A1.store_be(out + 16); + A2.store_be(out + 32); + A3.store_be(out + 48); + + in += 64; + out += 64; + blocks -= 4; + } + + Noekeon::encrypt_n(in, out, blocks); + } + +/* +* Noekeon Encryption +*/ +void Noekeon_SIMD::decrypt_n(const byte in[], byte out[], u32bit blocks) const + { + SIMD_32 K0 = SIMD_32(DK[0]); + SIMD_32 K1 = SIMD_32(DK[1]); + SIMD_32 K2 = SIMD_32(DK[2]); + SIMD_32 K3 = SIMD_32(DK[3]); + + while(blocks >= 4) + { + SIMD_32 A0 = SIMD_32::load_be(in ); + SIMD_32 A1 = SIMD_32::load_be(in + 16); + SIMD_32 A2 = SIMD_32::load_be(in + 32); + SIMD_32 A3 = SIMD_32::load_be(in + 48); + + SIMD_32::transpose(A0, A1, A2, A3); + + for(u32bit i = 0; i != 16; ++i) + { + NOK_SIMD_THETA(A0, A1, A2, A3, K0, K1, K2, K3); + + A0 ^= SIMD_32(RC[16-i]); + + A1.rotate_left(1); + A2.rotate_left(5); + A3.rotate_left(2); + + NOK_SIMD_GAMMA(A0, A1, A2, A3); + + A1.rotate_right(1); + A2.rotate_right(5); + A3.rotate_right(2); + } + + NOK_SIMD_THETA(A0, A1, A2, A3, K0, K1, K2, K3); + A0 ^= SIMD_32(RC[0]); + + SIMD_32::transpose(A0, A1, A2, A3); + + A0.store_be(out); + A1.store_be(out + 16); + A2.store_be(out + 32); + A3.store_be(out + 48); + + in += 64; + out += 64; + blocks -= 4; + } + + Noekeon::decrypt_n(in, out, blocks); + } + +} diff --git a/src/block/noekeon_simd/noekeon_simd.h b/src/block/noekeon_simd/noekeon_simd.h new file mode 100644 index 000000000..466c4b741 --- /dev/null +++ b/src/block/noekeon_simd/noekeon_simd.h @@ -0,0 +1,29 @@ +/* +* Noekeon in SIMD +* (C) 2010 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#ifndef BOTAN_NOEKEON_SIMD_H__ +#define BOTAN_NOEKEON_SIMD_H__ + +#include <botan/noekeon.h> + +namespace Botan { + +/* +* Noekeon +*/ +class BOTAN_DLL Noekeon_SIMD : public Noekeon + { + public: + void encrypt_n(const byte in[], byte out[], u32bit blocks) const; + void decrypt_n(const byte in[], byte out[], u32bit blocks) const; + + BlockCipher* clone() const { return new Noekeon_SIMD; } + }; + +} + +#endif diff --git a/src/build-data/arch/amd64.txt b/src/build-data/arch/amd64.txt index 58d1d3fa6..b0cf546d7 100644 --- a/src/build-data/arch/amd64.txt +++ b/src/build-data/arch/amd64.txt @@ -1,6 +1,8 @@ endian little unaligned ok +family x86 + <aliases> x86-64 x86_64 # for RPM diff --git a/src/build-data/arch/ia32.txt b/src/build-data/arch/ia32.txt index 40066851d..d9b09746d 100644 --- a/src/build-data/arch/ia32.txt +++ b/src/build-data/arch/ia32.txt @@ -1,6 +1,8 @@ endian little unaligned ok +family x86 + <aliases> x86 ix86 diff --git a/src/build-data/arch/ppc.txt b/src/build-data/arch/ppc.txt index 811eb53e7..dc3ea7829 100644 --- a/src/build-data/arch/ppc.txt +++ b/src/build-data/arch/ppc.txt @@ -1,6 +1,8 @@ endian big unaligned ok +family ppc + <aliases> powerpc </aliases> diff --git a/src/build-data/arch/ppc64.txt b/src/build-data/arch/ppc64.txt index b99aa9b8b..7a2e6b6b3 100644 --- a/src/build-data/arch/ppc64.txt +++ b/src/build-data/arch/ppc64.txt @@ -1,5 +1,7 @@ endian big +family ppc + <aliases> powerpc64 </aliases> diff --git a/src/build-data/arch/sparc32.txt b/src/build-data/arch/sparc32.txt index ae75a2a4b..fc015e520 100644 --- a/src/build-data/arch/sparc32.txt +++ b/src/build-data/arch/sparc32.txt @@ -1,5 +1,7 @@ endian big +family sparc + <aliases> sparc </aliases> diff --git a/src/build-data/arch/sparc64.txt b/src/build-data/arch/sparc64.txt index a1ed16549..e20d0fde6 100644 --- a/src/build-data/arch/sparc64.txt +++ b/src/build-data/arch/sparc64.txt @@ -1,3 +1,6 @@ + +family sparc + <submodels> ultrasparc ultrasparc3 diff --git a/src/build-data/buildh.in b/src/build-data/buildh.in index 7588dc99b..231a7aeeb 100644 --- a/src/build-data/buildh.in +++ b/src/build-data/buildh.in @@ -27,11 +27,11 @@ * * CBC and CFB can only use parallel processing in decryption mode */ -#define BOTAN_PARALLEL_BLOCKS_ECB 8 -#define BOTAN_PARALLEL_BLOCKS_CBC 8 -#define BOTAN_PARALLEL_BLOCKS_CFB 8 +#define BOTAN_PARALLEL_BLOCKS_ECB 16 +#define BOTAN_PARALLEL_BLOCKS_CBC 16 +#define BOTAN_PARALLEL_BLOCKS_CFB 16 #define BOTAN_PARALLEL_BLOCKS_CTR 16 -#define BOTAN_PARALLEL_BLOCKS_XTS 8 +#define BOTAN_PARALLEL_BLOCKS_XTS 16 /* PK key consistency checking toggles */ #define BOTAN_PUBLIC_KEY_STRONG_CHECKS_ON_LOAD 1 diff --git a/src/build-data/makefile/unix.in b/src/build-data/makefile/unix.in index 22ff919cc..a39a10907 100644 --- a/src/build-data/makefile/unix.in +++ b/src/build-data/makefile/unix.in @@ -76,7 +76,7 @@ $(STATIC_LIB): $(LIBOBJS) static: $(STATIC_LIB) doxygen: - doxygen %{doc_src_dir}/botan.doxy + doxygen %{build_dir}/botan.doxy clean: $(RM_R) %{build_dir}/lib/* %{build_dir}/checks/* diff --git a/src/build-data/makefile/unix_shr.in b/src/build-data/makefile/unix_shr.in index 499b7eb92..db445163e 100644 --- a/src/build-data/makefile/unix_shr.in +++ b/src/build-data/makefile/unix_shr.in @@ -90,7 +90,7 @@ static: $(STATIC_LIB) shared: $(SHARED_LIB) doxygen: - doxygen %{doc_src_dir}/botan.doxy + doxygen %{build_dir}/botan.doxy clean: $(RM_R) %{build_dir}/lib/* %{build_dir}/checks/* diff --git a/src/cert/cvc/asn1_eac_tm.cpp b/src/cert/cvc/asn1_eac_tm.cpp index 1335e8afa..5a464ba3c 100644 --- a/src/cert/cvc/asn1_eac_tm.cpp +++ b/src/cert/cvc/asn1_eac_tm.cpp @@ -177,9 +177,9 @@ bool EAC_Time::passes_sanity_check() const return true; } -/****************************************** +/* * modification functions -******************************************/ +*/ void EAC_Time::add_years(u32bit years) { year += years; diff --git a/src/cert/cvc/cvc_self.cpp b/src/cert/cvc/cvc_self.cpp index ae10838ac..0052651c9 100644 --- a/src/cert/cvc/cvc_self.cpp +++ b/src/cert/cvc/cvc_self.cpp @@ -21,9 +21,9 @@ namespace Botan { namespace { -/******************************* +/* * cvc CHAT values -*******************************/ +*/ enum CHAT_values{ CVCA = 0xC0, DVCA_domestic = 0x80, diff --git a/src/cert/x509/x509_ext.cpp b/src/cert/x509/x509_ext.cpp index 9a03c9d23..69b21d8b3 100644 --- a/src/cert/x509/x509_ext.cpp +++ b/src/cert/x509/x509_ext.cpp @@ -473,7 +473,7 @@ MemoryVector<byte> Certificate_Policies::encode_inner() const { // FIXME #if 1 - throw Exception("Certificate_Policies::encode_inner: Bugged"); + throw Internal_Error("Certificate_Policies::encode_inner: Bugged"); #else std::vector<Policy_Information> policies; diff --git a/src/cms/cms_dalg.cpp b/src/cms/cms_dalg.cpp index 3e8bdb4fa..8d559f9a9 100644 --- a/src/cms/cms_dalg.cpp +++ b/src/cms/cms_dalg.cpp @@ -196,7 +196,7 @@ void CMS_Decoder::decode_layer() else if(type == OIDS::lookup("CMS.SignedData")) { #if 1 - throw Exception("FIXME: not implemented"); + throw Internal_Error("FIXME: not implemented"); #else u32bit version; @@ -259,11 +259,11 @@ void CMS_Decoder::decode_layer() } else if(type == OIDS::lookup("CMS.EnvelopedData")) { - throw Exception("FIXME: not implemented"); + throw Internal_Error("FIXME: not implemented"); } else if(type == OIDS::lookup("CMS.AuthenticatedData")) { - throw Exception("FIXME: not implemented"); + throw Internal_Error("FIXME: not implemented"); } else throw Decoding_Error("CMS: Unknown content ID " + type.as_string()); diff --git a/src/cms/cms_ealg.cpp b/src/cms/cms_ealg.cpp index 2970e8e79..5efa33254 100644 --- a/src/cms/cms_ealg.cpp +++ b/src/cms/cms_ealg.cpp @@ -168,7 +168,7 @@ void CMS_Encoder::encrypt_kari(RandomNumberGenerator&, X509_PublicKey*, const std::string&) { - throw Exception("FIXME: unimplemented"); + throw Internal_Error("FIXME: unimplemented"); #if 0 SymmetricKey cek = setup_key(rng, cipher); @@ -198,7 +198,7 @@ void CMS_Encoder::encrypt(RandomNumberGenerator& rng, const SymmetricKey& kek, const std::string& user_cipher) { - throw Exception("FIXME: untested"); + throw Internal_Error("FIXME: untested"); const std::string cipher = choose_algo(user_cipher, "TripleDES"); SymmetricKey cek = setup_key(rng, cipher); @@ -232,7 +232,7 @@ void CMS_Encoder::encrypt(RandomNumberGenerator&, const std::string& user_cipher) { const std::string cipher = choose_algo(user_cipher, "TripleDES"); - throw Exception("FIXME: unimplemented"); + throw Internal_Error("FIXME: unimplemented"); /* SymmetricKey cek = setup_key(key); @@ -375,7 +375,7 @@ void CMS_Encoder::authenticate(const X509_Certificate&, const std::string& mac_algo) { const std::string mac = choose_algo(mac_algo, "HMAC(SHA-1)"); - throw Exception("FIXME: unimplemented"); + throw Internal_Error("FIXME: unimplemented"); } /* @@ -385,7 +385,7 @@ void CMS_Encoder::authenticate(const SymmetricKey&, const std::string& mac_algo) { const std::string mac = choose_algo(mac_algo, "HMAC(SHA-1)"); - throw Exception("FIXME: unimplemented"); + throw Internal_Error("FIXME: unimplemented"); } /* @@ -395,7 +395,7 @@ void CMS_Encoder::authenticate(const std::string&, const std::string& mac_algo) { const std::string mac = choose_algo(mac_algo, "HMAC(SHA-1)"); - throw Exception("FIXME: unimplemented"); + throw Internal_Error("FIXME: unimplemented"); } } diff --git a/src/constructs/cryptobox/cryptobox.cpp b/src/constructs/cryptobox/cryptobox.cpp index ba7553c55..20435fa59 100644 --- a/src/constructs/cryptobox/cryptobox.cpp +++ b/src/constructs/cryptobox/cryptobox.cpp @@ -135,7 +135,7 @@ std::string decrypt(const byte input[], u32bit input_len, if(!same_mem(computed_mac, ciphertext + VERSION_CODE_LEN + PBKDF_SALT_LEN, MAC_OUTPUT_LEN)) - throw Integrity_Failure("CryptoBox integrity failure"); + throw Decoding_Error("CryptoBox integrity failure"); return pipe.read_all_as_string(0); } diff --git a/src/engine/aes_isa_eng/aes_isa_engine.cpp b/src/engine/aes_isa_eng/aes_isa_engine.cpp index e57e4278d..682dfe6b1 100644 --- a/src/engine/aes_isa_eng/aes_isa_engine.cpp +++ b/src/engine/aes_isa_eng/aes_isa_engine.cpp @@ -5,17 +5,13 @@ * Distributed under the terms of the Botan license */ -#include <botan/aes_isa_engine.h> +#include <botan/internal/aes_isa_engine.h> #include <botan/cpuid.h> #if defined(BOTAN_HAS_AES_INTEL) #include <botan/aes_intel.h> #endif -#if defined(BOTAN_HAS_AES_VIA) - #include <botan/aes_via.h> -#endif - namespace Botan { BlockCipher* @@ -34,18 +30,6 @@ AES_ISA_Engine::find_block_cipher(const SCAN_Name& request, } #endif -#if defined(BOTAN_HAS_AES_VIA) - if(CPUID::has_aes_via()) - { - if(request.algo_name() == "AES-128") - return new AES_128_VIA; - if(request.algo_name() == "AES-192") - return new AES_192_VIA; - if(request.algo_name() == "AES-256") - return new AES_256_VIA; - } -#endif - return 0; } diff --git a/src/engine/def_engine/lookup_block.cpp b/src/engine/def_engine/lookup_block.cpp index cdad76c46..097a471b7 100644 --- a/src/engine/def_engine/lookup_block.cpp +++ b/src/engine/def_engine/lookup_block.cpp @@ -22,6 +22,10 @@ #include <botan/cast256.h> #endif +#if defined(BOTAN_HAS_CASCADE) + #include <botan/cascade.h> +#endif + #if defined(BOTAN_HAS_DES) #include <botan/des.h> #include <botan/desx.h> @@ -240,6 +244,17 @@ Default_Engine::find_block_cipher(const SCAN_Name& request, } #endif +#if defined(BOTAN_HAS_CASCADE) + if(request.algo_name() == "Cascade" && request.arg_count() == 2) + { + const BlockCipher* c1 = af.prototype_block_cipher(request.arg(0)); + const BlockCipher* c2 = af.prototype_block_cipher(request.arg(1)); + + if(c1 && c2) + return new Cascade_Cipher(c1->clone(), c2->clone()); + } +#endif + #if defined(BOTAN_HAS_LION) if(request.algo_name() == "Lion" && request.arg_count_between(2, 3)) { diff --git a/src/engine/simd_engine/simd_engine.cpp b/src/engine/simd_engine/simd_engine.cpp index b8ebd6a80..e889ca161 100644 --- a/src/engine/simd_engine/simd_engine.cpp +++ b/src/engine/simd_engine/simd_engine.cpp @@ -13,6 +13,10 @@ #include <botan/serp_simd.h> #endif +#if defined(BOTAN_HAS_NOEKEON_SIMD) + #include <botan/noekeon_simd.h> +#endif + #if defined(BOTAN_HAS_XTEA_SIMD) #include <botan/xtea_simd.h> #endif @@ -36,6 +40,11 @@ SIMD_Engine::find_block_cipher(const SCAN_Name& request, return new IDEA_SSE2; #endif +#if defined(BOTAN_HAS_NOEKEON_SIMD) + if(request.algo_name() == "Noekeon" && SIMD_32::enabled()) + return new Noekeon_SIMD; +#endif + #if defined(BOTAN_HAS_SERPENT_SIMD) if(request.algo_name() == "Serpent" && SIMD_32::enabled()) return new Serpent_SIMD; diff --git a/src/entropy/hres_timer/hres_timer.cpp b/src/entropy/hres_timer/hres_timer.cpp index 9f0a25c9b..5725cb154 100644 --- a/src/entropy/hres_timer/hres_timer.cpp +++ b/src/entropy/hres_timer/hres_timer.cpp @@ -29,7 +29,7 @@ void High_Resolution_Timestamp::poll(Entropy_Accumulator& accum) u64bit rtc = 0; -#if defined(BOTAN_TARGET_ARCH_IS_IA32) || defined(BOTAN_TARGET_ARCH_IS_AMD64) +#if defined(BOTAN_TARGET_CPU_IS_X86_FAMILY) if(CPUID::has_rdtsc()) // not availble on all x86 CPUs { u32bit rtc_low = 0, rtc_high = 0; @@ -37,7 +37,7 @@ void High_Resolution_Timestamp::poll(Entropy_Accumulator& accum) rtc = (static_cast<u64bit>(rtc_high) << 32) | rtc_low; } -#elif defined(BOTAN_TARGET_ARCH_IS_PPC) || defined(BOTAN_TARGET_ARCH_IS_PPC64) +#elif defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY) u32bit rtc_low = 0, rtc_high = 0; asm volatile("mftbu %0; mftb %1" : "=r" (rtc_high), "=r" (rtc_low)); rtc = (static_cast<u64bit>(rtc_high) << 32) | rtc_low; diff --git a/src/filters/buf_filt.cpp b/src/filters/buf_filt.cpp index 0509e76e2..97dd1b890 100644 --- a/src/filters/buf_filt.cpp +++ b/src/filters/buf_filt.cpp @@ -1,71 +1,110 @@ /* -* Buffering Filter +* Buffered Filter * (C) 1999-2007 Jack Lloyd * * Distributed under the terms of the Botan license */ #include <botan/buf_filt.h> -#include <botan/exceptn.h> -#include <algorithm> +#include <botan/mem_ops.h> +#include <botan/internal/rounding.h> +#include <stdexcept> namespace Botan { +namespace { + +const size_t BUFFER_MULTIPLE = 2; + +//static_assert(BUFFER_MULTIPLE >= 2, "BUFFER_MULTIPLE must be >= 2"); + +} + /* -* Buffering_Filter Constructor +* Buffered_Filter Constructor */ -Buffering_Filter::Buffering_Filter(u32bit b, u32bit i) : INITIAL_BLOCK_SIZE(i), - BLOCK_SIZE(b) +Buffered_Filter::Buffered_Filter(u32bit b, u32bit f) : + main_block_mod(b), final_minimum(f) { - initial_block_pos = block_pos = 0; - initial.resize(INITIAL_BLOCK_SIZE); - block.resize(BLOCK_SIZE); + if(main_block_mod == 0) + throw std::invalid_argument("main_block_mod == 0"); + + if(final_minimum > main_block_mod) + throw std::invalid_argument("final_minimum > main_block_mod"); + + buffer.resize(BUFFER_MULTIPLE * main_block_mod); + buffer_pos = 0; } /* -* Reset the Buffering Filter +* Buffer input into blocks, trying to minimize copying */ -void Buffering_Filter::end_msg() +void Buffered_Filter::write(const byte input[], u32bit input_size) { - if(initial_block_pos != INITIAL_BLOCK_SIZE) - throw Exception("Buffering_Filter: Not enough data for first block"); - final_block(block, block_pos); - initial_block_pos = block_pos = 0; - initial.clear(); - block.clear(); + if(!input_size) + return; + + if(buffer_pos + input_size >= main_block_mod + final_minimum) + { + u32bit to_copy = std::min<u32bit>(buffer.size() - buffer_pos, input_size); + + copy_mem(&buffer[buffer_pos], input, to_copy); + buffer_pos += to_copy; + + input += to_copy; + input_size -= to_copy; + + if(input_size >= final_minimum) + { + u32bit to_proc_blocks = buffer_pos / main_block_mod; + u32bit to_proc_bytes = to_proc_blocks * main_block_mod; + + buffered_block(&buffer[0], to_proc_bytes); + + buffer_pos -= to_proc_bytes; + + copy_mem(&buffer[0], &buffer[to_proc_bytes], buffer_pos); + } + } + + if(input_size >= final_minimum) + { + u32bit full_blocks = (input_size - final_minimum) / buffer.size(); + u32bit to_copy = full_blocks * buffer.size(); + + if(to_copy) + { + buffered_block(input, to_copy); + + input += to_copy; + input_size -= to_copy; + } + } + + copy_mem(&buffer[buffer_pos], input, input_size); + buffer_pos += input_size; } /* -* Buffer input into blocks +* Finish/flush operation */ -void Buffering_Filter::write(const byte input[], u32bit length) +void Buffered_Filter::end_msg() { - if(initial_block_pos != INITIAL_BLOCK_SIZE) + if(buffer_pos < final_minimum) + throw std::runtime_error("Buffered_Operation::final - not enough input"); + + u32bit spare_blocks = (buffer_pos - final_minimum) / main_block_mod; + + if(spare_blocks) { - u32bit copied = std::min(INITIAL_BLOCK_SIZE - initial_block_pos, length); - initial.copy(initial_block_pos, input, copied); - input += copied; - length -= copied; - initial_block_pos += copied; - if(initial_block_pos == INITIAL_BLOCK_SIZE) - initial_block(initial); + u32bit spare_bytes = main_block_mod * spare_blocks; + buffered_block(&buffer[0], spare_bytes); + buffered_final(&buffer[spare_bytes], buffer_pos - spare_bytes); } - block.copy(block_pos, input, length); - if(block_pos + length >= BLOCK_SIZE) + else { - main_block(block); - input += (BLOCK_SIZE - block_pos); - length -= (BLOCK_SIZE - block_pos); - while(length >= BLOCK_SIZE) - { - main_block(input); - input += BLOCK_SIZE; - length -= BLOCK_SIZE; - } - block.copy(input, length); - block_pos = 0; + buffered_final(&buffer[0], buffer_pos); } - block_pos += length; } } diff --git a/src/filters/buf_filt.h b/src/filters/buf_filt.h index ce3dbc926..de4102844 100644 --- a/src/filters/buf_filt.h +++ b/src/filters/buf_filt.h @@ -1,37 +1,39 @@ /* -* Buffering Filter +* Buffered Filter * (C) 1999-2007 Jack Lloyd * * Distributed under the terms of the Botan license */ -#ifndef BOTAN_BUFFERING_FILTER_H__ -#define BOTAN_BUFFERING_FILTER_H__ +#ifndef BOTAN_BUFFERED_FILTER_H__ +#define BOTAN_BUFFERED_FILTER_H__ -#include <botan/filter.h> +#include <botan/secmem.h> namespace Botan { -/** -* Buffering_Filter: This class represents filters for operations that -* maintain an internal state. -*/ - -class BOTAN_DLL Buffering_Filter : public Filter +class BOTAN_DLL Buffered_Filter { public: void write(const byte[], u32bit); - virtual void end_msg(); - Buffering_Filter(u32bit, u32bit = 0); - virtual ~Buffering_Filter() {} + void end_msg(); + + Buffered_Filter(u32bit block_size, u32bit final_minimum); + + virtual ~Buffered_Filter() {} protected: - virtual void initial_block(const byte[]) {} - virtual void main_block(const byte[]) = 0; - virtual void final_block(const byte[], u32bit) = 0; + virtual std::string name() const = 0; + + virtual void buffered_block(const byte input[], u32bit length) = 0; + virtual void buffered_final(const byte input[], u32bit length) = 0; + + u32bit current_position() const { return buffer_pos; } + void buffer_reset() { buffer_pos = 0; } private: - const u32bit INITIAL_BLOCK_SIZE, BLOCK_SIZE; - SecureVector<byte> initial, block; - u32bit initial_block_pos, block_pos; + u32bit main_block_mod, final_minimum; + + SecureVector<byte> buffer; + u32bit buffer_pos; }; } diff --git a/src/filters/bzip2/bzip2.cpp b/src/filters/bzip2/bzip2.cpp index 4cdca5355..9dcee8fdf 100644 --- a/src/filters/bzip2/bzip2.cpp +++ b/src/filters/bzip2/bzip2.cpp @@ -96,7 +96,7 @@ void Bzip_Compression::start_msg() clear(); bz = new Bzip_Stream; if(BZ2_bzCompressInit(&(bz->stream), level, 0, 0) != BZ_OK) - throw Exception("Bzip_Compression: Memory allocation error"); + throw Memory_Exhaustion(); } /* @@ -196,13 +196,15 @@ void Bzip_Decompression::write(const byte input_arr[], u32bit length) if(rc != BZ_OK && rc != BZ_STREAM_END) { clear(); + if(rc == BZ_DATA_ERROR) throw Decoding_Error("Bzip_Decompression: Data integrity error"); - if(rc == BZ_DATA_ERROR_MAGIC) + else if(rc == BZ_DATA_ERROR_MAGIC) throw Decoding_Error("Bzip_Decompression: Invalid input"); - if(rc == BZ_MEM_ERROR) - throw Exception("Bzip_Decompression: Memory allocation error"); - throw Exception("Bzip_Decompression: Unknown decompress error"); + else if(rc == BZ_MEM_ERROR) + throw Memory_Exhaustion(); + else + throw std::runtime_error("Bzip2 decompression: Unknown error"); } send(buffer, buffer.size() - bz->stream.avail_out); @@ -228,7 +230,7 @@ void Bzip_Decompression::start_msg() bz = new Bzip_Stream; if(BZ2_bzDecompressInit(&(bz->stream), 0, small_mem) != BZ_OK) - throw Exception("Bzip_Decompression: Memory allocation error"); + throw Memory_Exhaustion(); no_writes = true; } @@ -252,7 +254,7 @@ void Bzip_Decompression::end_msg() if(rc != BZ_OK && rc != BZ_STREAM_END) { clear(); - throw Exception("Bzip_Decompression: Error finalizing decompression"); + throw Decoding_Error("Bzip_Decompression: Error finalizing"); } send(buffer, buffer.size() - bz->stream.avail_out); diff --git a/src/filters/modes/cbc/cbc.cpp b/src/filters/modes/cbc/cbc.cpp index 48ecdf509..7722fad2f 100644 --- a/src/filters/modes/cbc/cbc.cpp +++ b/src/filters/modes/cbc/cbc.cpp @@ -16,14 +16,13 @@ namespace Botan { */ CBC_Encryption::CBC_Encryption(BlockCipher* ciph, BlockCipherModePaddingMethod* pad) : + Buffered_Filter(ciph->BLOCK_SIZE, 0), cipher(ciph), padder(pad) { if(!padder->valid_blocksize(cipher->BLOCK_SIZE)) throw Invalid_Block_Size(name(), padder->name()); - buffer.resize(cipher->BLOCK_SIZE); state.resize(cipher->BLOCK_SIZE); - position = 0; } /* @@ -33,14 +32,13 @@ CBC_Encryption::CBC_Encryption(BlockCipher* ciph, BlockCipherModePaddingMethod* pad, const SymmetricKey& key, const InitializationVector& iv) : + Buffered_Filter(ciph->BLOCK_SIZE, 0), cipher(ciph), padder(pad) { if(!padder->valid_blocksize(cipher->BLOCK_SIZE)) throw Invalid_Block_Size(name(), padder->name()); - buffer.resize(cipher->BLOCK_SIZE); state.resize(cipher->BLOCK_SIZE); - position = 0; set_key(key); set_iv(iv); @@ -55,41 +53,52 @@ void CBC_Encryption::set_iv(const InitializationVector& iv) throw Invalid_IV_Length(name(), iv.length()); state = iv.bits_of(); - buffer.clear(); - position = 0; + buffer_reset(); } /* * Encrypt in CBC mode */ -void CBC_Encryption::write(const byte input[], u32bit length) +void CBC_Encryption::buffered_block(const byte input[], u32bit length) { - while(length) + u32bit blocks = length / state.size(); + + for(u32bit i = 0; i != blocks; ++i) { - u32bit xored = std::min(cipher->BLOCK_SIZE - position, length); - xor_buf(state + position, input, xored); - input += xored; - length -= xored; - position += xored; - if(position == cipher->BLOCK_SIZE) - { - cipher->encrypt(state); - send(state, cipher->BLOCK_SIZE); - position = 0; - } + xor_buf(state, input + i * cipher->BLOCK_SIZE, state.size()); + cipher->encrypt(state); + send(state, state.size()); } } /* * Finish encrypting in CBC mode */ +void CBC_Encryption::buffered_final(const byte input[], u32bit length) + { + if(length % cipher->BLOCK_SIZE == 0) + buffered_block(input, length); + else if(length != 0) + throw Encoding_Error(name() + ": Did not pad to full blocksize"); + } + +void CBC_Encryption::write(const byte input[], u32bit input_length) + { + Buffered_Filter::write(input, input_length); + } + void CBC_Encryption::end_msg() { + u32bit last_block = current_position() % cipher->BLOCK_SIZE; + SecureVector<byte> padding(cipher->BLOCK_SIZE); - padder->pad(padding, padding.size(), position); - write(padding, padder->pad_bytes(cipher->BLOCK_SIZE, position)); - if(position != 0) - throw Exception(name() + ": Did not pad to full blocksize"); + padder->pad(padding, padding.size(), last_block); + + u32bit pad_bytes = padder->pad_bytes(cipher->BLOCK_SIZE, last_block); + + if(pad_bytes) + Buffered_Filter::write(padding, pad_bytes); + Buffered_Filter::end_msg(); } /* @@ -105,15 +114,15 @@ std::string CBC_Encryption::name() const */ CBC_Decryption::CBC_Decryption(BlockCipher* ciph, BlockCipherModePaddingMethod* pad) : + Buffered_Filter(BOTAN_PARALLEL_BLOCKS_CBC * ciph->BLOCK_SIZE, + ciph->BLOCK_SIZE), cipher(ciph), padder(pad) { if(!padder->valid_blocksize(cipher->BLOCK_SIZE)) throw Invalid_Block_Size(name(), padder->name()); - buffer.resize(cipher->BLOCK_SIZE); state.resize(cipher->BLOCK_SIZE); - temp.resize(cipher->BLOCK_SIZE); - position = 0; + temp.resize(BOTAN_PARALLEL_BLOCKS_CBC * cipher->BLOCK_SIZE); } /* @@ -123,15 +132,15 @@ CBC_Decryption::CBC_Decryption(BlockCipher* ciph, BlockCipherModePaddingMethod* pad, const SymmetricKey& key, const InitializationVector& iv) : + Buffered_Filter(BOTAN_PARALLEL_BLOCKS_CBC * ciph->BLOCK_SIZE, + ciph->BLOCK_SIZE), cipher(ciph), padder(pad) { if(!padder->valid_blocksize(cipher->BLOCK_SIZE)) throw Invalid_Block_Size(name(), padder->name()); - buffer.resize(cipher->BLOCK_SIZE); state.resize(cipher->BLOCK_SIZE); - temp.resize(cipher->BLOCK_SIZE); - position = 0; + temp.resize(BOTAN_PARALLEL_BLOCKS_CBC * cipher->BLOCK_SIZE); set_key(key); set_iv(iv); @@ -146,46 +155,74 @@ void CBC_Decryption::set_iv(const InitializationVector& iv) throw Invalid_IV_Length(name(), iv.length()); state = iv.bits_of(); - buffer.clear(); - position = 0; + buffer_reset(); } /* * Decrypt in CBC mode */ -void CBC_Decryption::write(const byte input[], u32bit length) +void CBC_Decryption::buffered_block(const byte input[], u32bit length) { - while(length) + const u32bit blocks_in_temp = temp.size() / cipher->BLOCK_SIZE; + u32bit blocks = length / cipher->BLOCK_SIZE; + + while(blocks) { - if(position == cipher->BLOCK_SIZE) - { - cipher->decrypt(buffer, temp); - xor_buf(temp, state, cipher->BLOCK_SIZE); - send(temp, cipher->BLOCK_SIZE); - state = buffer; - position = 0; - } - - u32bit added = std::min(cipher->BLOCK_SIZE - position, length); - buffer.copy(position, input, added); - input += added; - length -= added; - position += added; + u32bit to_proc = std::min<u32bit>(blocks, blocks_in_temp); + + cipher->decrypt_n(input, &temp[0], to_proc); + + xor_buf(temp, state, cipher->BLOCK_SIZE); + + for(u32bit i = 1; i < to_proc; ++i) + xor_buf(temp + i * cipher->BLOCK_SIZE, + input + (i-1) * cipher->BLOCK_SIZE, + cipher->BLOCK_SIZE); + + state.set(input + (to_proc - 1) * cipher->BLOCK_SIZE, cipher->BLOCK_SIZE); + + send(temp, to_proc * cipher->BLOCK_SIZE); + + input += to_proc * cipher->BLOCK_SIZE; + blocks -= to_proc; } } /* -* Finish decrypting in CBC mode +* Finish encrypting in CBC mode */ -void CBC_Decryption::end_msg() +void CBC_Decryption::buffered_final(const byte input[], u32bit length) { - if(position != cipher->BLOCK_SIZE) - throw Decoding_Error(name()); - cipher->decrypt(buffer, temp); + if(length == 0 || length % cipher->BLOCK_SIZE != 0) + throw Decoding_Error(name() + ": Ciphertext not multiple of block size"); + + size_t extra_blocks = (length - 1) / cipher->BLOCK_SIZE; + + buffered_block(input, extra_blocks * cipher->BLOCK_SIZE); + + input += extra_blocks * cipher->BLOCK_SIZE; + + cipher->decrypt(input, temp); xor_buf(temp, state, cipher->BLOCK_SIZE); send(temp, padder->unpad(temp, cipher->BLOCK_SIZE)); - state = buffer; - position = 0; + + state.set(input, state.size()); + } + +/* +* Decrypt in CBC mode +*/ +void CBC_Decryption::write(const byte input[], u32bit length) + { + Buffered_Filter::write(input, length); + } + +/* +* Finish decrypting in CBC mode +*/ +void CBC_Decryption::end_msg() + { + Buffered_Filter::end_msg(); } /* diff --git a/src/filters/modes/cbc/cbc.h b/src/filters/modes/cbc/cbc.h index 91ab21ab6..b303a841f 100644 --- a/src/filters/modes/cbc/cbc.h +++ b/src/filters/modes/cbc/cbc.h @@ -11,13 +11,15 @@ #include <botan/block_cipher.h> #include <botan/key_filt.h> #include <botan/mode_pad.h> +#include <botan/buf_filt.h> namespace Botan { /* * CBC Encryption */ -class BOTAN_DLL CBC_Encryption : public Keyed_Filter +class BOTAN_DLL CBC_Encryption : public Keyed_Filter, + private Buffered_Filter { public: std::string name() const; @@ -39,19 +41,22 @@ class BOTAN_DLL CBC_Encryption : public Keyed_Filter ~CBC_Encryption() { delete padder; } private: - void write(const byte[], u32bit); + void buffered_block(const byte input[], u32bit input_length); + void buffered_final(const byte input[], u32bit input_length); + + void write(const byte input[], u32bit input_length); void end_msg(); BlockCipher* cipher; const BlockCipherModePaddingMethod* padder; - SecureVector<byte> buffer, state; - u32bit position; + SecureVector<byte> state; }; /* * CBC Decryption */ -class BOTAN_DLL CBC_Decryption : public Keyed_Filter +class BOTAN_DLL CBC_Decryption : public Keyed_Filter, + private Buffered_Filter { public: std::string name() const; @@ -73,13 +78,15 @@ class BOTAN_DLL CBC_Decryption : public Keyed_Filter ~CBC_Decryption() { delete padder; } private: + void buffered_block(const byte input[], u32bit input_length); + void buffered_final(const byte input[], u32bit input_length); + void write(const byte[], u32bit); void end_msg(); BlockCipher* cipher; const BlockCipherModePaddingMethod* padder; - SecureVector<byte> buffer, state, temp; - u32bit position; + SecureVector<byte> state, temp; }; } diff --git a/src/filters/modes/cts/cts.cpp b/src/filters/modes/cts/cts.cpp index 3a15a1d68..b27b9b3c5 100644 --- a/src/filters/modes/cts/cts.cpp +++ b/src/filters/modes/cts/cts.cpp @@ -101,7 +101,8 @@ void CTS_Encryption::write(const byte input[], u32bit length) void CTS_Encryption::end_msg() { if(position < cipher->BLOCK_SIZE + 1) - throw Exception("CTS_Encryption: insufficient data to encrypt"); + throw Encoding_Error(name() + ": insufficient data to encrypt"); + xor_buf(state, buffer, cipher->BLOCK_SIZE); cipher->encrypt(state); SecureVector<byte> cn = state; diff --git a/src/filters/modes/eax/eax_dec.cpp b/src/filters/modes/eax/eax_dec.cpp index f41327ffc..998773697 100644 --- a/src/filters/modes/eax/eax_dec.cpp +++ b/src/filters/modes/eax/eax_dec.cpp @@ -98,13 +98,13 @@ void EAX_Decryption::do_write(const byte input[], u32bit length) void EAX_Decryption::end_msg() { if((queue_end - queue_start) != TAG_SIZE) - throw Integrity_Failure(name() + ": Message authentication failure"); + throw Decoding_Error(name() + ": Message authentication failure"); SecureVector<byte> data_mac = cmac->final(); for(u32bit j = 0; j != TAG_SIZE; ++j) if(queue[queue_start+j] != (data_mac[j] ^ nonce_mac[j] ^ header_mac[j])) - throw Integrity_Failure(name() + ": Message authentication failure"); + throw Decoding_Error(name() + ": Message authentication failure"); queue_start = queue_end = 0; } diff --git a/src/filters/modes/ecb/ecb.cpp b/src/filters/modes/ecb/ecb.cpp index bff6d70f4..2ce6576e3 100644 --- a/src/filters/modes/ecb/ecb.cpp +++ b/src/filters/modes/ecb/ecb.cpp @@ -1,6 +1,6 @@ /* * ECB Mode -* (C) 1999-2007 Jack Lloyd +* (C) 1999-2009 Jack Lloyd * * Distributed under the terms of the Botan license */ @@ -9,25 +9,17 @@ namespace Botan { -namespace { - -const u32bit PARALLEL_BLOCKS = BOTAN_PARALLEL_BLOCKS_ECB; - -} - /* * ECB_Encryption Constructor */ ECB_Encryption::ECB_Encryption(BlockCipher* ciph, - BlockCipherModePaddingMethod* pad) + BlockCipherModePaddingMethod* pad) : + Buffered_Filter(ciph->BLOCK_SIZE * BOTAN_PARALLEL_BLOCKS_ECB, 0) { cipher = ciph; padder = pad; - plaintext.resize(cipher->BLOCK_SIZE); - ciphertext.resize(cipher->BLOCK_SIZE * PARALLEL_BLOCKS); - - position = 0; + temp.resize(cipher->BLOCK_SIZE * BOTAN_PARALLEL_BLOCKS_ECB); } /* @@ -35,15 +27,13 @@ ECB_Encryption::ECB_Encryption(BlockCipher* ciph, */ ECB_Encryption::ECB_Encryption(BlockCipher* ciph, BlockCipherModePaddingMethod* pad, - const SymmetricKey& key) + const SymmetricKey& key) : + Buffered_Filter(ciph->BLOCK_SIZE * BOTAN_PARALLEL_BLOCKS_ECB, 0) { cipher = ciph; padder = pad; - plaintext.resize(cipher->BLOCK_SIZE); - ciphertext.resize(cipher->BLOCK_SIZE * PARALLEL_BLOCKS); - - position = 0; + temp.resize(cipher->BLOCK_SIZE * BOTAN_PARALLEL_BLOCKS_ECB); cipher->set_key(key); } @@ -70,35 +60,7 @@ std::string ECB_Encryption::name() const */ void ECB_Encryption::write(const byte input[], u32bit length) { - const u32bit BLOCK_SIZE = cipher->BLOCK_SIZE; - - if(position) - { - plaintext.copy(position, input, length); - - if(position + length >= BLOCK_SIZE) - { - cipher->encrypt(plaintext, ciphertext); - send(ciphertext, BLOCK_SIZE); - input += (BLOCK_SIZE - position); - length -= (BLOCK_SIZE - position); - position = 0; - } - } - - while(length >= BLOCK_SIZE) - { - const u32bit to_proc = - std::min<u32bit>(length, ciphertext.size()) / BLOCK_SIZE; - - cipher->encrypt_n(input, ciphertext, to_proc); - send(ciphertext, to_proc * BLOCK_SIZE); - input += to_proc * BLOCK_SIZE; - length -= to_proc * BLOCK_SIZE; - } - - plaintext.copy(position, input, length); - position += length; + Buffered_Filter::write(input, length); } /* @@ -106,12 +68,41 @@ void ECB_Encryption::write(const byte input[], u32bit length) */ void ECB_Encryption::end_msg() { - const u32bit BLOCK_SIZE = cipher->BLOCK_SIZE; + u32bit last_block = current_position() % cipher->BLOCK_SIZE; + + SecureVector<byte> padding(cipher->BLOCK_SIZE); + padder->pad(padding, padding.size(), last_block); + + u32bit pad_bytes = padder->pad_bytes(cipher->BLOCK_SIZE, last_block); + + if(pad_bytes) + Buffered_Filter::write(padding, pad_bytes); + Buffered_Filter::end_msg(); + } + +void ECB_Encryption::buffered_block(const byte input[], u32bit input_length) + { + const u32bit blocks_in_temp = temp.size() / cipher->BLOCK_SIZE; + u32bit blocks = input_length / cipher->BLOCK_SIZE; + + while(blocks) + { + u32bit to_proc = std::min<u32bit>(blocks, blocks_in_temp); + + cipher->encrypt_n(input, &temp[0], to_proc); + + send(temp, to_proc * cipher->BLOCK_SIZE); + + input += to_proc * cipher->BLOCK_SIZE; + blocks -= to_proc; + } + } - SecureVector<byte> padding(BLOCK_SIZE); - padder->pad(padding, padding.size(), position); - write(padding, padder->pad_bytes(BLOCK_SIZE, position)); - if(position != 0) +void ECB_Encryption::buffered_final(const byte input[], u32bit input_length) + { + if(input_length % cipher->BLOCK_SIZE == 0) + buffered_block(input, input_length); + else if(input_length != 0) throw Encoding_Error(name() + ": Did not pad to full blocksize"); } @@ -119,15 +110,13 @@ void ECB_Encryption::end_msg() * ECB_Decryption Constructor */ ECB_Decryption::ECB_Decryption(BlockCipher* ciph, - BlockCipherModePaddingMethod* pad) + BlockCipherModePaddingMethod* pad) : + Buffered_Filter(ciph->BLOCK_SIZE * BOTAN_PARALLEL_BLOCKS_ECB, 1) { cipher = ciph; padder = pad; - ciphertext.resize(cipher->BLOCK_SIZE); - plaintext.resize(cipher->BLOCK_SIZE * PARALLEL_BLOCKS); - - position = 0; + temp.resize(cipher->BLOCK_SIZE * BOTAN_PARALLEL_BLOCKS_ECB); } /* @@ -135,15 +124,13 @@ ECB_Decryption::ECB_Decryption(BlockCipher* ciph, */ ECB_Decryption::ECB_Decryption(BlockCipher* ciph, BlockCipherModePaddingMethod* pad, - const SymmetricKey& key) + const SymmetricKey& key) : + Buffered_Filter(ciph->BLOCK_SIZE * BOTAN_PARALLEL_BLOCKS_ECB, 1) { cipher = ciph; padder = pad; - ciphertext.resize(cipher->BLOCK_SIZE); - plaintext.resize(cipher->BLOCK_SIZE * PARALLEL_BLOCKS); - - position = 0; + temp.resize(cipher->BLOCK_SIZE * BOTAN_PARALLEL_BLOCKS_ECB); cipher->set_key(key); } @@ -170,53 +157,54 @@ std::string ECB_Decryption::name() const */ void ECB_Decryption::write(const byte input[], u32bit length) { - const u32bit BLOCK_SIZE = cipher->BLOCK_SIZE; + Buffered_Filter::write(input, length); + } - if(position) - { - ciphertext.copy(position, input, length); - - if(position + length > BLOCK_SIZE) - { - cipher->decrypt(ciphertext, plaintext); - send(plaintext, BLOCK_SIZE); - input += (BLOCK_SIZE - position); - length -= (BLOCK_SIZE - position); - position = 0; - } - } +/* +* Finish decrypting in ECB mode +*/ +void ECB_Decryption::end_msg() + { + Buffered_Filter::end_msg(); + } - while(length > BLOCK_SIZE) +/* +* Decrypt in ECB mode +*/ +void ECB_Decryption::buffered_block(const byte input[], u32bit length) + { + const u32bit blocks_in_temp = temp.size() / cipher->BLOCK_SIZE; + u32bit blocks = length / cipher->BLOCK_SIZE; + + while(blocks) { - /* Always leave at least 1 byte left over, to ensure that (as long - as the input message actually is a multiple of the block size) - we will have the full final block left over in end_msg so as - to remove the padding - */ - const u32bit to_proc = - std::min<u32bit>(length - 1, plaintext.size()) / BLOCK_SIZE; - - cipher->decrypt_n(input, plaintext, to_proc); - send(plaintext, to_proc * BLOCK_SIZE); - input += to_proc * BLOCK_SIZE; - length -= to_proc * BLOCK_SIZE; - } + u32bit to_proc = std::min<u32bit>(blocks, blocks_in_temp); - ciphertext.copy(position, input, length); - position += length; + cipher->decrypt_n(input, &temp[0], to_proc); + + send(temp, to_proc * cipher->BLOCK_SIZE); + + input += to_proc * cipher->BLOCK_SIZE; + blocks -= to_proc; + } } /* -* Finish decrypting in ECB mode +* Finish encrypting in ECB mode */ -void ECB_Decryption::end_msg() +void ECB_Decryption::buffered_final(const byte input[], u32bit length) { - if(position != cipher->BLOCK_SIZE) - throw Decoding_Error(name()); + if(length == 0 || length % cipher->BLOCK_SIZE != 0) + throw Decoding_Error(name() + ": Ciphertext not multiple of block size"); + + size_t extra_blocks = (length - 1) / cipher->BLOCK_SIZE; + + buffered_block(input, extra_blocks * cipher->BLOCK_SIZE); + + input += extra_blocks * cipher->BLOCK_SIZE; - cipher->decrypt(ciphertext); - send(ciphertext, padder->unpad(ciphertext, cipher->BLOCK_SIZE)); - position = 0; + cipher->decrypt(input, temp); + send(temp, padder->unpad(temp, cipher->BLOCK_SIZE)); } } diff --git a/src/filters/modes/ecb/ecb.h b/src/filters/modes/ecb/ecb.h index 2b3b3fe83..2b88191c7 100644 --- a/src/filters/modes/ecb/ecb.h +++ b/src/filters/modes/ecb/ecb.h @@ -11,13 +11,15 @@ #include <botan/block_cipher.h> #include <botan/mode_pad.h> #include <botan/key_filt.h> +#include <botan/buf_filt.h> namespace Botan { /* * ECB Encryption */ -class BOTAN_DLL ECB_Encryption : public Keyed_Filter +class BOTAN_DLL ECB_Encryption : public Keyed_Filter, + private Buffered_Filter { public: std::string name() const; @@ -36,19 +38,22 @@ class BOTAN_DLL ECB_Encryption : public Keyed_Filter ~ECB_Encryption(); private: - void write(const byte[], u32bit); + void buffered_block(const byte input[], u32bit input_length); + void buffered_final(const byte input[], u32bit input_length); + + void write(const byte input[], u32bit input_length); void end_msg(); BlockCipher* cipher; BlockCipherModePaddingMethod* padder; - SecureVector<byte> plaintext, ciphertext; - u32bit position; + SecureVector<byte> temp; }; /* * ECB Decryption */ -class BOTAN_DLL ECB_Decryption : public Keyed_Filter +class BOTAN_DLL ECB_Decryption : public Keyed_Filter, + public Buffered_Filter { public: std::string name() const; @@ -67,13 +72,15 @@ class BOTAN_DLL ECB_Decryption : public Keyed_Filter ~ECB_Decryption(); private: - void write(const byte[], u32bit); + void buffered_block(const byte input[], u32bit input_length); + void buffered_final(const byte input[], u32bit input_length); + + void write(const byte input[], u32bit input_length); void end_msg(); BlockCipher* cipher; BlockCipherModePaddingMethod* padder; - SecureVector<byte> plaintext, ciphertext; - u32bit position; + SecureVector<byte> temp; }; } diff --git a/src/filters/modes/xts/xts.cpp b/src/filters/modes/xts/xts.cpp index c9b77e1eb..cfea0b34b 100644 --- a/src/filters/modes/xts/xts.cpp +++ b/src/filters/modes/xts/xts.cpp @@ -16,7 +16,7 @@ namespace { void poly_double(byte tweak[], u32bit size) { - const byte polynomial = 0x87; // for 128 bit ciphers + const byte polynomial = (size == 16) ? 0x87 : 0x1B; byte carry = 0; for(u32bit i = 0; i != size; ++i) @@ -35,15 +35,16 @@ void poly_double(byte tweak[], u32bit size) /* * XTS_Encryption constructor */ -XTS_Encryption::XTS_Encryption(BlockCipher* ciph) : cipher(ciph) +XTS_Encryption::XTS_Encryption(BlockCipher* ciph) : + Buffered_Filter(BOTAN_PARALLEL_BLOCKS_XTS * ciph->BLOCK_SIZE, + ciph->BLOCK_SIZE + 1), + cipher(ciph) { - if(cipher->BLOCK_SIZE != 16) + if(cipher->BLOCK_SIZE != 8 && cipher->BLOCK_SIZE != 16) throw std::invalid_argument("Bad cipher for XTS: " + cipher->name()); cipher2 = cipher->clone(); - tweak.resize(cipher->BLOCK_SIZE); - buffer.resize(2 * cipher->BLOCK_SIZE); - position = 0; + tweak.resize(BOTAN_PARALLEL_BLOCKS_XTS * cipher->BLOCK_SIZE); } /* @@ -51,15 +52,16 @@ XTS_Encryption::XTS_Encryption(BlockCipher* ciph) : cipher(ciph) */ XTS_Encryption::XTS_Encryption(BlockCipher* ciph, const SymmetricKey& key, - const InitializationVector& iv) : cipher(ciph) + const InitializationVector& iv) : + Buffered_Filter(BOTAN_PARALLEL_BLOCKS_XTS * ciph->BLOCK_SIZE, + ciph->BLOCK_SIZE + 1), + cipher(ciph) { - if(cipher->BLOCK_SIZE != 16) - throw std::invalid_argument("Bad cipher for XTS: " + cipher->name()); + if(cipher->BLOCK_SIZE != 8 && cipher->BLOCK_SIZE != 16) + throw std::invalid_argument("Bad cipher for XTS: " + cipher->name()); cipher2 = cipher->clone(); - tweak.resize(cipher->BLOCK_SIZE); - buffer.resize(2 * cipher->BLOCK_SIZE); - position = 0; + tweak.resize(BOTAN_PARALLEL_BLOCKS_XTS * cipher->BLOCK_SIZE); set_key(key); set_iv(iv); @@ -78,11 +80,22 @@ std::string XTS_Encryption::name() const */ void XTS_Encryption::set_iv(const InitializationVector& iv) { - if(iv.length() != tweak.size()) + if(iv.length() != cipher->BLOCK_SIZE) throw Invalid_IV_Length(name(), iv.length()); - tweak = iv.bits_of(); + const u32bit blocks_in_tweak = tweak.size() / cipher->BLOCK_SIZE; + + tweak.copy(iv.begin(), iv.length()); cipher2->encrypt(tweak); + + for(u32bit i = 1; i < blocks_in_tweak; ++i) + { + tweak.copy(i*cipher->BLOCK_SIZE, + tweak.begin() + (i-1)*cipher->BLOCK_SIZE, + cipher->BLOCK_SIZE); + + poly_double(&tweak[i*cipher->BLOCK_SIZE], cipher->BLOCK_SIZE); + } } void XTS_Encryption::set_key(const SymmetricKey& key) @@ -96,110 +109,103 @@ void XTS_Encryption::set_key(const SymmetricKey& key) cipher2->set_key(key.begin() + key_half, key_half); } -void XTS_Encryption::encrypt(const byte block[]) - { - /* - * We can always use the first 16 bytes of buffer as temp space, - * since either the input block is buffer (in which case this is - * just buffer ^= tweak) or it not, in which case we already read - * and used the data there and are processing new input. Kind of - * subtle/nasty, but saves allocating a distinct temp buf. - */ - - xor_buf(buffer, block, tweak, cipher->BLOCK_SIZE); - cipher->encrypt(buffer); - xor_buf(buffer, tweak, cipher->BLOCK_SIZE); - - poly_double(tweak, cipher->BLOCK_SIZE); - - send(buffer, cipher->BLOCK_SIZE); - } - /* * Encrypt in XTS mode */ void XTS_Encryption::write(const byte input[], u32bit length) { - const u32bit BLOCK_SIZE = cipher->BLOCK_SIZE; + Buffered_Filter::write(input, length); + } +/* +* Finish encrypting in XTS mode +*/ +void XTS_Encryption::end_msg() + { + Buffered_Filter::end_msg(); + } - u32bit copied = std::min(buffer.size() - position, length); - buffer.copy(position, input, copied); - length -= copied; - input += copied; - position += copied; +void XTS_Encryption::buffered_block(const byte input[], u32bit length) + { + const u32bit blocks_in_tweak = tweak.size() / cipher->BLOCK_SIZE; + u32bit blocks = length / cipher->BLOCK_SIZE; - if(length == 0) return; + SecureVector<byte> temp(tweak.size()); - encrypt(buffer); - if(length > BLOCK_SIZE) + while(blocks) { - encrypt(buffer + BLOCK_SIZE); - while(length > buffer.size()) + u32bit to_proc = std::min(blocks, blocks_in_tweak); + u32bit to_proc_bytes = to_proc * cipher->BLOCK_SIZE; + + xor_buf(temp, input, tweak, to_proc_bytes); + + cipher->encrypt_n(&temp[0], &temp[0], to_proc); + + xor_buf(temp, tweak, to_proc_bytes); + + send(temp, to_proc_bytes); + + tweak.copy(&tweak[(to_proc-1)*cipher->BLOCK_SIZE], + cipher->BLOCK_SIZE); + poly_double(&tweak[0], cipher->BLOCK_SIZE); + + for(u32bit i = 1; i < blocks_in_tweak; ++i) { - encrypt(input); - length -= BLOCK_SIZE; - input += BLOCK_SIZE; + tweak.copy(i*cipher->BLOCK_SIZE, + tweak.begin() + (i-1)*cipher->BLOCK_SIZE, + cipher->BLOCK_SIZE); + + poly_double(&tweak[i*cipher->BLOCK_SIZE], cipher->BLOCK_SIZE); } - position = 0; - } - else - { - copy_mem(buffer.begin(), buffer + BLOCK_SIZE, BLOCK_SIZE); - position = BLOCK_SIZE; + + input += to_proc * cipher->BLOCK_SIZE; + blocks -= to_proc; } - buffer.copy(position, input, length); - position += length; } /* * Finish encrypting in XTS mode */ -void XTS_Encryption::end_msg() +void XTS_Encryption::buffered_final(const byte input[], u32bit length) { - const u32bit BLOCK_SIZE = cipher->BLOCK_SIZE; + if(length <= cipher->BLOCK_SIZE) + throw Encoding_Error("XTS_Encryption: insufficient data to encrypt"); - if(position < BLOCK_SIZE) - throw Exception("XTS_Encryption: insufficient data to encrypt"); - else if(position == BLOCK_SIZE) - { - encrypt(buffer); - } - else if(position == 2*BLOCK_SIZE) + if(length % cipher->BLOCK_SIZE == 0) { - encrypt(buffer); - encrypt(buffer + BLOCK_SIZE); + buffered_block(input, length); } else { // steal ciphertext - xor_buf(buffer, tweak, cipher->BLOCK_SIZE); - cipher->encrypt(buffer); - xor_buf(buffer, tweak, cipher->BLOCK_SIZE); + SecureVector<byte> temp(input, length); + + xor_buf(temp, tweak, cipher->BLOCK_SIZE); + cipher->encrypt(temp); + xor_buf(temp, tweak, cipher->BLOCK_SIZE); poly_double(tweak, cipher->BLOCK_SIZE); - for(u32bit i = 0; i != position - cipher->BLOCK_SIZE; ++i) - std::swap(buffer[i], buffer[i + cipher->BLOCK_SIZE]); + for(u32bit i = 0; i != length - cipher->BLOCK_SIZE; ++i) + std::swap(temp[i], temp[i + cipher->BLOCK_SIZE]); - xor_buf(buffer, tweak, cipher->BLOCK_SIZE); - cipher->encrypt(buffer); - xor_buf(buffer, tweak, cipher->BLOCK_SIZE); + xor_buf(temp, tweak, cipher->BLOCK_SIZE); + cipher->encrypt(temp); + xor_buf(temp, tweak, cipher->BLOCK_SIZE); - send(buffer, position); + send(temp, temp.size()); } - position = 0; + buffer_reset(); } /* * XTS_Decryption constructor */ -XTS_Decryption::XTS_Decryption(BlockCipher* ciph) +XTS_Decryption::XTS_Decryption(BlockCipher* ciph) : + Buffered_Filter(BOTAN_PARALLEL_BLOCKS_XTS * ciph->BLOCK_SIZE, 1) { cipher = ciph; cipher2 = ciph->clone(); - tweak.resize(cipher->BLOCK_SIZE); - buffer.resize(2 * cipher->BLOCK_SIZE); - position = 0; + tweak.resize(BOTAN_PARALLEL_BLOCKS_XTS * cipher->BLOCK_SIZE); } /* @@ -207,13 +213,12 @@ XTS_Decryption::XTS_Decryption(BlockCipher* ciph) */ XTS_Decryption::XTS_Decryption(BlockCipher* ciph, const SymmetricKey& key, - const InitializationVector& iv) + const InitializationVector& iv) : + Buffered_Filter(BOTAN_PARALLEL_BLOCKS_XTS * ciph->BLOCK_SIZE, 1) { cipher = ciph; cipher2 = ciph->clone(); - tweak.resize(cipher->BLOCK_SIZE); - buffer.resize(2 * cipher->BLOCK_SIZE); - position = 0; + tweak.resize(BOTAN_PARALLEL_BLOCKS_XTS * cipher->BLOCK_SIZE); set_key(key); set_iv(iv); @@ -232,11 +237,22 @@ std::string XTS_Decryption::name() const */ void XTS_Decryption::set_iv(const InitializationVector& iv) { - if(iv.length() != tweak.size()) + if(iv.length() != cipher->BLOCK_SIZE) throw Invalid_IV_Length(name(), iv.length()); - tweak = iv.bits_of(); + const u32bit blocks_in_tweak = tweak.size() / cipher->BLOCK_SIZE; + + tweak.copy(iv.begin(), iv.length()); cipher2->encrypt(tweak); + + for(u32bit i = 1; i < blocks_in_tweak; ++i) + { + tweak.copy(i*cipher->BLOCK_SIZE, + tweak.begin() + (i-1)*cipher->BLOCK_SIZE, + cipher->BLOCK_SIZE); + + poly_double(&tweak[i*cipher->BLOCK_SIZE], cipher->BLOCK_SIZE); + } } void XTS_Decryption::set_key(const SymmetricKey& key) @@ -251,94 +267,90 @@ void XTS_Decryption::set_key(const SymmetricKey& key) } /* -* Decrypt a block +* Decrypt in XTS mode */ -void XTS_Decryption::decrypt(const byte block[]) +void XTS_Decryption::write(const byte input[], u32bit length) { - xor_buf(buffer, block, tweak, cipher->BLOCK_SIZE); - cipher->decrypt(buffer); - xor_buf(buffer, tweak, cipher->BLOCK_SIZE); - - poly_double(tweak, cipher->BLOCK_SIZE); - - send(buffer, cipher->BLOCK_SIZE); + Buffered_Filter::write(input, length); } /* -* Decrypt in XTS mode +* Finish decrypting in XTS mode */ -void XTS_Decryption::write(const byte input[], u32bit length) +void XTS_Decryption::end_msg() { - const u32bit BLOCK_SIZE = cipher->BLOCK_SIZE; + Buffered_Filter::end_msg(); + } - u32bit copied = std::min(buffer.size() - position, length); - buffer.copy(position, input, copied); - length -= copied; - input += copied; - position += copied; +void XTS_Decryption::buffered_block(const byte input[], u32bit input_length) + { + const u32bit blocks_in_tweak = tweak.size() / cipher->BLOCK_SIZE; + u32bit blocks = input_length / cipher->BLOCK_SIZE; - if(length == 0) return; + SecureVector<byte> temp(tweak.size()); - decrypt(buffer); - if(length > BLOCK_SIZE) + while(blocks) { - decrypt(buffer + BLOCK_SIZE); - while(length > 2*BLOCK_SIZE) + u32bit to_proc = std::min(blocks, blocks_in_tweak); + u32bit to_proc_bytes = to_proc * cipher->BLOCK_SIZE; + + xor_buf(temp, input, tweak, to_proc_bytes); + + cipher->decrypt_n(&temp[0], &temp[0], to_proc); + + xor_buf(temp, tweak, to_proc_bytes); + + send(temp, to_proc_bytes); + + tweak.copy(&tweak[(to_proc-1)*cipher->BLOCK_SIZE], + cipher->BLOCK_SIZE); + poly_double(&tweak[0], cipher->BLOCK_SIZE); + + for(u32bit i = 1; i < blocks_in_tweak; ++i) { - decrypt(input); - length -= BLOCK_SIZE; - input += BLOCK_SIZE; + tweak.copy(i*cipher->BLOCK_SIZE, + tweak.begin() + (i-1)*cipher->BLOCK_SIZE, + cipher->BLOCK_SIZE); + + poly_double(&tweak[i*cipher->BLOCK_SIZE], cipher->BLOCK_SIZE); } - position = 0; - } - else - { - copy_mem(buffer.begin(), buffer + BLOCK_SIZE, BLOCK_SIZE); - position = BLOCK_SIZE; + + input += to_proc * cipher->BLOCK_SIZE; + blocks -= to_proc; } - buffer.copy(position, input, length); - position += length; } -/* -* Finish decrypting in XTS mode -*/ -void XTS_Decryption::end_msg() +void XTS_Decryption::buffered_final(const byte input[], u32bit input_length) { - const u32bit BLOCK_SIZE = cipher->BLOCK_SIZE; + if(input_length <= cipher->BLOCK_SIZE) + throw Decoding_Error("XTS_Decryption: insufficient data to decrypt"); - if(position < BLOCK_SIZE) - throw Exception("XTS_Decryption: insufficient data to decrypt"); - else if(position == BLOCK_SIZE) - { - decrypt(buffer); - } - else if(position == 2*BLOCK_SIZE) + if(input_length % cipher->BLOCK_SIZE == 0) { - decrypt(buffer); - decrypt(buffer + BLOCK_SIZE); + buffered_block(input, input_length); } else { - SecureVector<byte> tweak2 = tweak; + SecureVector<byte> temp(input, input_length); + SecureVector<byte> tweak_copy(&tweak[0], cipher->BLOCK_SIZE); - poly_double(tweak2, cipher->BLOCK_SIZE); + poly_double(tweak_copy, cipher->BLOCK_SIZE); - xor_buf(buffer, tweak2, cipher->BLOCK_SIZE); - cipher->decrypt(buffer); - xor_buf(buffer, tweak2, cipher->BLOCK_SIZE); + xor_buf(temp, tweak_copy, cipher->BLOCK_SIZE); + cipher->decrypt(temp); + xor_buf(temp, tweak_copy, cipher->BLOCK_SIZE); - for(u32bit i = 0; i != position - cipher->BLOCK_SIZE; ++i) - std::swap(buffer[i], buffer[i + cipher->BLOCK_SIZE]); + for(u32bit i = 0; i != input_length - cipher->BLOCK_SIZE; ++i) + std::swap(temp[i], temp[i + cipher->BLOCK_SIZE]); - xor_buf(buffer, tweak, cipher->BLOCK_SIZE); - cipher->decrypt(buffer); - xor_buf(buffer, tweak, cipher->BLOCK_SIZE); + xor_buf(temp, tweak, cipher->BLOCK_SIZE); + cipher->decrypt(temp); + xor_buf(temp, tweak, cipher->BLOCK_SIZE); - send(buffer, position); + send(temp, input_length); } - position = 0; + buffer_reset(); } } diff --git a/src/filters/modes/xts/xts.h b/src/filters/modes/xts/xts.h index 9badd3666..724085d9d 100644 --- a/src/filters/modes/xts/xts.h +++ b/src/filters/modes/xts/xts.h @@ -8,15 +8,17 @@ #ifndef BOTAN_XTS_H__ #define BOTAN_XTS_H__ -#include <botan/key_filt.h> #include <botan/block_cipher.h> +#include <botan/key_filt.h> +#include <botan/buf_filt.h> namespace Botan { /* * XTS Encryption */ -class BOTAN_DLL XTS_Encryption : public Keyed_Filter +class BOTAN_DLL XTS_Encryption : public Keyed_Filter, + private Buffered_Filter { public: void set_key(const SymmetricKey& key); @@ -37,19 +39,20 @@ class BOTAN_DLL XTS_Encryption : public Keyed_Filter private: void write(const byte[], u32bit); void end_msg(); - void encrypt(const byte block[]); + + void buffered_block(const byte input[], u32bit input_length); + void buffered_final(const byte input[], u32bit input_length); BlockCipher* cipher; BlockCipher* cipher2; SecureVector<byte> tweak; - SecureVector<byte> buffer; - u32bit position; }; /* * XTS Decryption */ -class BOTAN_DLL XTS_Decryption : public Keyed_Filter +class BOTAN_DLL XTS_Decryption : public Keyed_Filter, + private Buffered_Filter { public: void set_key(const SymmetricKey& key); @@ -68,13 +71,13 @@ class BOTAN_DLL XTS_Decryption : public Keyed_Filter private: void write(const byte[], u32bit); void end_msg(); - void decrypt(const byte[]); + + void buffered_block(const byte input[], u32bit input_length); + void buffered_final(const byte input[], u32bit input_length); BlockCipher* cipher; BlockCipher* cipher2; SecureVector<byte> tweak; - SecureVector<byte> buffer; - u32bit position; }; } diff --git a/src/filters/pipe.cpp b/src/filters/pipe.cpp index 169205e5f..e86b9a964 100644 --- a/src/filters/pipe.cpp +++ b/src/filters/pipe.cpp @@ -12,16 +12,6 @@ namespace Botan { -/* -* Constructor for Invalid_Message_Number -*/ -Pipe::Invalid_Message_Number::Invalid_Message_Number(const std::string& where, - message_id msg) - { - set_msg("Pipe::" + where + ": Invalid message number " + - std::to_string(msg)); - } - namespace { /* diff --git a/src/filters/pipe.h b/src/filters/pipe.h index 5961b665a..19cdd3229 100644 --- a/src/filters/pipe.h +++ b/src/filters/pipe.h @@ -29,10 +29,12 @@ class BOTAN_DLL Pipe : public DataSource public: typedef u32bit message_id; - class BOTAN_DLL Invalid_Message_Number : public Invalid_Argument + struct BOTAN_DLL Invalid_Message_Number : public Invalid_Argument { - public: - Invalid_Message_Number(const std::string&, message_id); + Invalid_Message_Number(const std::string& where, message_id msg) : + Invalid_Argument("Pipe::" + where + ": Invalid message number " + + to_string(msg)) + {} }; static const message_id LAST_MESSAGE; diff --git a/src/filters/pipe_rw.cpp b/src/filters/pipe_rw.cpp index 756a1cf09..de77c6b43 100644 --- a/src/filters/pipe_rw.cpp +++ b/src/filters/pipe_rw.cpp @@ -34,7 +34,7 @@ Pipe::message_id Pipe::get_message_no(const std::string& func_name, void Pipe::write(const byte input[], u32bit length) { if(!inside_msg) - throw Exception("Cannot write to a Pipe while it is not processing"); + throw Invalid_State("Cannot write to a Pipe while it is not processing"); pipe->write(input, length); } diff --git a/src/filters/pk_filts/pk_filts.cpp b/src/filters/pk_filts/pk_filts.cpp index d604436e0..05b45227f 100644 --- a/src/filters/pk_filts/pk_filts.cpp +++ b/src/filters/pk_filts/pk_filts.cpp @@ -73,7 +73,7 @@ void PK_Verifier_Filter::write(const byte input[], u32bit length) void PK_Verifier_Filter::end_msg() { if(signature.empty()) - throw Exception("PK_Verifier_Filter: No signature to check against"); + throw Invalid_State("PK_Verifier_Filter: No signature to check against"); bool is_valid = verifier->check_signature(signature, signature.size()); send((is_valid ? 1 : 0)); } diff --git a/src/filters/zlib/zlib.cpp b/src/filters/zlib/zlib.cpp index 246e32924..171caa73f 100644 --- a/src/filters/zlib/zlib.cpp +++ b/src/filters/zlib/zlib.cpp @@ -95,7 +95,7 @@ void Zlib_Compression::start_msg() clear(); zlib = new Zlib_Stream; if(deflateInit(&(zlib->stream), level) != Z_OK) - throw Exception("Zlib_Compression: Memory allocation error"); + throw Memory_Exhaustion(); } /* @@ -187,7 +187,7 @@ void Zlib_Decompression::start_msg() clear(); zlib = new Zlib_Stream; if(inflateInit(&(zlib->stream)) != Z_OK) - throw Exception("Zlib_Decompression: Memory allocation error"); + throw Memory_Exhaustion(); } /* @@ -215,11 +215,12 @@ void Zlib_Decompression::write(const byte input_arr[], u32bit length) clear(); if(rc == Z_DATA_ERROR) throw Decoding_Error("Zlib_Decompression: Data integrity error"); - if(rc == Z_NEED_DICT) + else if(rc == Z_NEED_DICT) throw Decoding_Error("Zlib_Decompression: Need preset dictionary"); - if(rc == Z_MEM_ERROR) - throw Exception("Zlib_Decompression: Memory allocation error"); - throw Exception("Zlib_Decompression: Unknown decompress error"); + else if(rc == Z_MEM_ERROR) + throw Memory_Exhaustion(); + else + throw std::runtime_error("Zlib decompression: Unknown error"); } send(buffer.begin(), buffer.size() - zlib->stream.avail_out); @@ -258,7 +259,7 @@ void Zlib_Decompression::end_msg() if(rc != Z_OK && rc != Z_STREAM_END) { clear(); - throw Exception("Zlib_Decompression: Error finalizing decompression"); + throw Decoding_Error("Zlib_Decompression: Error finalizing"); } send(buffer.begin(), buffer.size() - zlib->stream.avail_out); diff --git a/src/hash/tiger/tiger.cpp b/src/hash/tiger/tiger.cpp index 2d56aa1b3..42df69eae 100644 --- a/src/hash/tiger/tiger.cpp +++ b/src/hash/tiger/tiger.cpp @@ -12,6 +12,23 @@ namespace Botan { +namespace { + +/* +* Tiger Mixing Function +*/ +inline void mix(u64bit X[8]) + { + X[0] -= X[7] ^ 0xA5A5A5A5A5A5A5A5; X[1] ^= X[0]; + X[2] += X[1]; X[3] -= X[2] ^ ((~X[1]) << 19); X[4] ^= X[3]; + X[5] += X[4]; X[6] -= X[5] ^ ((~X[4]) >> 23); X[7] ^= X[6]; + X[0] += X[7]; X[1] -= X[0] ^ ((~X[7]) << 19); X[2] ^= X[1]; + X[3] += X[2]; X[4] -= X[3] ^ ((~X[2]) >> 23); X[5] ^= X[4]; + X[6] += X[5]; X[7] -= X[6] ^ 0x0123456789ABCDEF; + } + +} + /* * Tiger Compression Function */ @@ -114,19 +131,6 @@ void Tiger::pass(u64bit& A, u64bit& B, u64bit& C, u64bit X[8], byte mul) } /* -* Tiger Mixing Function -*/ -void Tiger::mix(u64bit X[8]) - { - X[0] -= X[7] ^ 0xA5A5A5A5A5A5A5A5; X[1] ^= X[0]; - X[2] += X[1]; X[3] -= X[2] ^ ((~X[1]) << 19); X[4] ^= X[3]; - X[5] += X[4]; X[6] -= X[5] ^ ((~X[4]) >> 23); X[7] ^= X[6]; - X[0] += X[7]; X[1] -= X[0] ^ ((~X[7]) << 19); X[2] ^= X[1]; - X[3] += X[2]; X[4] -= X[3] ^ ((~X[2]) >> 23); X[5] ^= X[4]; - X[6] += X[5]; X[7] -= X[6] ^ 0x0123456789ABCDEF; - } - -/* * Clear memory of sensitive data */ void Tiger::clear() diff --git a/src/hash/tiger/tiger.h b/src/hash/tiger/tiger.h index 86ddcd270..20dcf99ff 100644 --- a/src/hash/tiger/tiger.h +++ b/src/hash/tiger/tiger.h @@ -27,7 +27,6 @@ class BOTAN_DLL Tiger : public MDx_HashFunction void copy_out(byte[]); static void pass(u64bit&, u64bit&, u64bit&, u64bit[8], byte); - static void mix(u64bit[8]); static const u64bit SBOX1[256]; static const u64bit SBOX2[256]; diff --git a/src/libstate/libstate.cpp b/src/libstate/libstate.cpp index 4dc78ade2..fccedacdf 100644 --- a/src/libstate/libstate.cpp +++ b/src/libstate/libstate.cpp @@ -276,8 +276,7 @@ void Library_State::initialize() m_algorithm_factory = new Algorithm_Factory(engines); #if defined(BOTAN_HAS_SELFTESTS) - if(!passes_self_tests(algorithm_factory())) - throw Self_Test_Failure("Startup self tests failed"); + confirm_startup_self_tests(algorithm_factory()); #endif } diff --git a/src/libstate/libstate.h b/src/libstate/libstate.h index e9a08b74b..5a84f9cb1 100644 --- a/src/libstate/libstate.h +++ b/src/libstate/libstate.h @@ -33,11 +33,28 @@ class BOTAN_DLL Library_State void initialize(); + /** + * @return the global Algorithm_Factory + */ Algorithm_Factory& algorithm_factory(); - Allocator* get_allocator(const std::string& = ""); - void add_allocator(Allocator*); - void set_default_allocator(const std::string&); + /** + * @param name the name of the allocator + * @return allocator matching this name, or NULL + */ + Allocator* get_allocator(const std::string& name = ""); + + /** + * Add a new allocator to the list of available ones + * @param alloc the allocator to add + */ + void add_allocator(Allocator* alloc); + + /** + * Set the default allocator + * @param name the name of the allocator to use as the default + */ + void set_default_allocator(const std::string& name); /** * Get a parameter value as std::string. @@ -56,7 +73,8 @@ class BOTAN_DLL Library_State * @result true if the parameters value is set, * false otherwise */ - bool is_set(const std::string& section, const std::string& key); + bool is_set(const std::string& section, + const std::string& key); /** * Set a configuration parameter. @@ -66,8 +84,10 @@ class BOTAN_DLL Library_State * will be overwritten even if it is already set, otherwise * no existing values will be overwritten. */ - void set(const std::string& section, const std::string& key, - const std::string& value, bool overwrite = true); + void set(const std::string& section, + const std::string& key, + const std::string& value, + bool overwrite = true); /** * Get a parameters value out of the "conf" section ( @@ -81,14 +101,16 @@ class BOTAN_DLL Library_State * @param key the key of the option to set * @param value the value to set */ - void set_option(const std::string& key, const std::string& value); + void set_option(const std::string& key, + const std::string& value); /** * Add a parameter value to the "alias" section. * @param key the name of the parameter which shall have a new alias * @param value the new alias */ - void add_alias(const std::string&, const std::string&); + void add_alias(const std::string& key, + const std::string& value); /** * Resolve an alias. diff --git a/src/libstate/lookup.cpp b/src/libstate/lookup.cpp index 9016dbe6e..01f4a3d42 100644 --- a/src/libstate/lookup.cpp +++ b/src/libstate/lookup.cpp @@ -12,138 +12,34 @@ namespace Botan { /** -* Acquire a block cipher -*/ -const BlockCipher* retrieve_block_cipher(const std::string& algo_spec) - { - Algorithm_Factory& af = global_state().algorithm_factory(); - return af.prototype_block_cipher(algo_spec); - } - -/** -* Get a block cipher by name -*/ -BlockCipher* get_block_cipher(const std::string& algo_spec) - { - Algorithm_Factory& af = global_state().algorithm_factory(); - return af.make_block_cipher(algo_spec); - } - -/** -* Acquire a stream cipher -*/ -const StreamCipher* retrieve_stream_cipher(const std::string& algo_spec) - { - Algorithm_Factory& af = global_state().algorithm_factory(); - return af.prototype_stream_cipher(algo_spec); - } - -/** -* Get a stream cipher by name -*/ -StreamCipher* get_stream_cipher(const std::string& algo_spec) - { - Algorithm_Factory& af = global_state().algorithm_factory(); - return af.make_stream_cipher(algo_spec); - } - -/** -* Acquire a hash function -*/ -const HashFunction* retrieve_hash(const std::string& algo_spec) - { - Algorithm_Factory& af = global_state().algorithm_factory(); - return af.prototype_hash_function(algo_spec); - } - -/** -* Get a hash function by name -*/ -HashFunction* get_hash(const std::string& algo_spec) - { - Algorithm_Factory& af = global_state().algorithm_factory(); - return af.make_hash_function(algo_spec); - } - -/** -* Query if Botan has the named hash function -*/ -bool have_hash(const std::string& algo_spec) - { - Algorithm_Factory& af = global_state().algorithm_factory(); - return (af.prototype_hash_function(algo_spec) != 0); - } - -/** -* Acquire an authentication code -*/ -const MessageAuthenticationCode* retrieve_mac(const std::string& algo_spec) - { - Algorithm_Factory& af = global_state().algorithm_factory(); - return af.prototype_mac(algo_spec); - } - -/** -* Get a MAC by name -*/ -MessageAuthenticationCode* get_mac(const std::string& algo_spec) - { - Algorithm_Factory& af = global_state().algorithm_factory(); - return af.make_mac(algo_spec); - } - -/** -* Query if Botan has the named MAC -*/ -bool have_mac(const std::string& algo_spec) - { - Algorithm_Factory& af = global_state().algorithm_factory(); - return (af.prototype_mac(algo_spec) != 0); - } - -/** * Query if an algorithm exists */ bool have_algorithm(const std::string& name) { - if(retrieve_block_cipher(name)) + Algorithm_Factory& af = global_state().algorithm_factory(); + + if(af.prototype_block_cipher(name)) return true; - if(retrieve_stream_cipher(name)) + if(af.prototype_stream_cipher(name)) return true; - if(retrieve_hash(name)) + if(af.prototype_hash_function(name)) return true; - if(retrieve_mac(name)) + if(af.prototype_mac(name)) return true; return false; } /** -* Query if Botan has the named block cipher -*/ -bool have_block_cipher(const std::string& name) - { - return (retrieve_block_cipher(name) != 0); - } - -/** -* Query if Botan has the named stream cipher -*/ -bool have_stream_cipher(const std::string& name) - { - return (retrieve_stream_cipher(name) != 0); - } - -/** * Query the block size of a cipher or hash */ u32bit block_size_of(const std::string& name) { - const BlockCipher* cipher = retrieve_block_cipher(name); - if(cipher) + Algorithm_Factory& af = global_state().algorithm_factory(); + + if(const BlockCipher* cipher = af.prototype_block_cipher(name)) return cipher->BLOCK_SIZE; - const HashFunction* hash = retrieve_hash(name); - if(hash) + if(const HashFunction* hash = af.prototype_hash_function(name)) return hash->HASH_BLOCK_SIZE; throw Algorithm_Not_Found(name); @@ -154,12 +50,12 @@ u32bit block_size_of(const std::string& name) */ u32bit output_length_of(const std::string& name) { - const HashFunction* hash = retrieve_hash(name); - if(hash) + Algorithm_Factory& af = global_state().algorithm_factory(); + + if(const HashFunction* hash = af.prototype_hash_function(name)) return hash->OUTPUT_LENGTH; - const MessageAuthenticationCode* mac = retrieve_mac(name); - if(mac) + if(const MessageAuthenticationCode* mac = af.prototype_mac(name)) return mac->OUTPUT_LENGTH; throw Algorithm_Not_Found(name); @@ -170,16 +66,15 @@ u32bit output_length_of(const std::string& name) */ bool valid_keylength_for(u32bit key_len, const std::string& name) { - const BlockCipher* bc = retrieve_block_cipher(name); - if(bc) + Algorithm_Factory& af = global_state().algorithm_factory(); + + if(const BlockCipher* bc = af.prototype_block_cipher(name)) return bc->valid_keylength(key_len); - const StreamCipher* sc = retrieve_stream_cipher(name); - if(sc) + if(const StreamCipher* sc = af.prototype_stream_cipher(name)) return sc->valid_keylength(key_len); - const MessageAuthenticationCode* mac = retrieve_mac(name); - if(mac) + if(const MessageAuthenticationCode* mac = af.prototype_mac(name)) return mac->valid_keylength(key_len); throw Algorithm_Not_Found(name); @@ -190,16 +85,15 @@ bool valid_keylength_for(u32bit key_len, const std::string& name) */ u32bit min_keylength_of(const std::string& name) { - const BlockCipher* bc = retrieve_block_cipher(name); - if(bc) + Algorithm_Factory& af = global_state().algorithm_factory(); + + if(const BlockCipher* bc = af.prototype_block_cipher(name)) return bc->MINIMUM_KEYLENGTH; - const StreamCipher* sc = retrieve_stream_cipher(name); - if(sc) + if(const StreamCipher* sc = af.prototype_stream_cipher(name)) return sc->MINIMUM_KEYLENGTH; - const MessageAuthenticationCode* mac = retrieve_mac(name); - if(mac) + if(const MessageAuthenticationCode* mac = af.prototype_mac(name)) return mac->MINIMUM_KEYLENGTH; throw Algorithm_Not_Found(name); @@ -210,16 +104,15 @@ u32bit min_keylength_of(const std::string& name) */ u32bit max_keylength_of(const std::string& name) { - const BlockCipher* bc = retrieve_block_cipher(name); - if(bc) + Algorithm_Factory& af = global_state().algorithm_factory(); + + if(const BlockCipher* bc = af.prototype_block_cipher(name)) return bc->MAXIMUM_KEYLENGTH; - const StreamCipher* sc = retrieve_stream_cipher(name); - if(sc) + if(const StreamCipher* sc = af.prototype_stream_cipher(name)) return sc->MAXIMUM_KEYLENGTH; - const MessageAuthenticationCode* mac = retrieve_mac(name); - if(mac) + if(const MessageAuthenticationCode* mac = af.prototype_mac(name)) return mac->MAXIMUM_KEYLENGTH; throw Algorithm_Not_Found(name); @@ -230,16 +123,15 @@ u32bit max_keylength_of(const std::string& name) */ u32bit keylength_multiple_of(const std::string& name) { - const BlockCipher* bc = retrieve_block_cipher(name); - if(bc) + Algorithm_Factory& af = global_state().algorithm_factory(); + + if(const BlockCipher* bc = af.prototype_block_cipher(name)) return bc->KEYLENGTH_MULTIPLE; - const StreamCipher* sc = retrieve_stream_cipher(name); - if(sc) + if(const StreamCipher* sc = af.prototype_stream_cipher(name)) return sc->KEYLENGTH_MULTIPLE; - const MessageAuthenticationCode* mac = retrieve_mac(name); - if(mac) + if(const MessageAuthenticationCode* mac = af.prototype_mac(name)) return mac->KEYLENGTH_MULTIPLE; throw Algorithm_Not_Found(name); @@ -257,8 +149,7 @@ Keyed_Filter* get_cipher(const std::string& algo_spec, while(Engine* engine = i.next()) { - Keyed_Filter* algo = engine->get_cipher(algo_spec, direction, af); - if(algo) + if(Keyed_Filter* algo = engine->get_cipher(algo_spec, direction, af)) return algo; } diff --git a/src/libstate/lookup.h b/src/libstate/lookup.h index 0f48dddfb..5f10bb3f8 100644 --- a/src/libstate/lookup.h +++ b/src/libstate/lookup.h @@ -8,17 +8,14 @@ #ifndef BOTAN_LOOKUP_H__ #define BOTAN_LOOKUP_H__ -#include <botan/block_cipher.h> -#include <botan/stream_cipher.h> -#include <botan/hash.h> -#include <botan/mac.h> -#include <botan/s2k.h> - +#include <botan/libstate.h> +#include <botan/engine.h> #include <botan/filters.h> #include <botan/mode_pad.h> #include <botan/kdf.h> #include <botan/eme.h> #include <botan/emsa.h> +#include <botan/s2k.h> namespace Botan { @@ -28,59 +25,90 @@ namespace Botan { // NOTE: these functions return internally stored objects, library // retains ownership -BOTAN_DLL const BlockCipher* -retrieve_block_cipher(const std::string&); - -BOTAN_DLL const StreamCipher* -retrieve_stream_cipher(const std::string&); - -BOTAN_DLL const HashFunction* -retrieve_hash(const std::string&); - -BOTAN_DLL const MessageAuthenticationCode* -retrieve_mac(const std::string&); +inline const BlockCipher* +retrieve_block_cipher(const std::string& algo_spec) + { + Algorithm_Factory& af = global_state().algorithm_factory(); + return af.prototype_block_cipher(algo_spec); + } + +inline const StreamCipher* +retrieve_stream_cipher(const std::string& algo_spec) + { + Algorithm_Factory& af = global_state().algorithm_factory(); + return af.prototype_stream_cipher(algo_spec); + } + +inline const HashFunction* +retrieve_hash(const std::string& algo_spec) + { + Algorithm_Factory& af = global_state().algorithm_factory(); + return af.prototype_hash_function(algo_spec); + } + +inline const MessageAuthenticationCode* +retrieve_mac(const std::string& algo_spec) + { + Algorithm_Factory& af = global_state().algorithm_factory(); + return af.prototype_mac(algo_spec); + } /* * Get an algorithm object +* NOTE: these functions create and return new objects, letting the +* caller assume ownership of them */ -// NOTE: these functions create and return new objects, letting the -// caller assume ownership of them /** * Block cipher factory method. * @param algo_spec the name of the desired block cipher * @return a pointer to the block cipher object */ -BOTAN_DLL BlockCipher* get_block_cipher(const std::string& name); - +inline BlockCipher* get_block_cipher(const std::string& algo_spec) + { + Algorithm_Factory& af = global_state().algorithm_factory(); + return af.make_block_cipher(algo_spec); + } /** * Stream cipher factory method. * @param algo_spec the name of the desired stream cipher * @return a pointer to the stream cipher object */ -BOTAN_DLL StreamCipher* get_stream_cipher(const std::string& name); +inline StreamCipher* get_stream_cipher(const std::string& algo_spec) + { + Algorithm_Factory& af = global_state().algorithm_factory(); + return af.make_stream_cipher(algo_spec); + } /** * Hash function factory method. * @param algo_spec the name of the desired hash function * @return a pointer to the hash function object */ -BOTAN_DLL HashFunction* get_hash(const std::string& name); +inline HashFunction* get_hash(const std::string& algo_spec) + { + Algorithm_Factory& af = global_state().algorithm_factory(); + return af.make_hash_function(algo_spec); + } /** * MAC factory method. * @param algo_spec the name of the desired MAC * @return a pointer to the MAC object */ -BOTAN_DLL MessageAuthenticationCode* get_mac(const std::string& name); +inline MessageAuthenticationCode* get_mac(const std::string& algo_spec) + { + Algorithm_Factory& af = global_state().algorithm_factory(); + return af.make_mac(algo_spec); + } /** * String to key algorithm factory method. * @param name the name of the desired string to key (S2K) algorithm * @return a pointer to the string to key algorithm object */ -BOTAN_DLL S2K* get_s2k(const std::string& name); +BOTAN_DLL S2K* get_s2k(const std::string& algo_spec); /* * Get an EMSA/EME/KDF/MGF function @@ -93,7 +121,7 @@ BOTAN_DLL S2K* get_s2k(const std::string& name); * @param name the name of the EME to create * @return a pointer to the desired EME object */ -BOTAN_DLL EME* get_eme(const std::string& name); +BOTAN_DLL EME* get_eme(const std::string& algo_spec); /** * Factory method for EMSA (message-encoding methods for signatures @@ -101,14 +129,14 @@ BOTAN_DLL EME* get_eme(const std::string& name); * @param name the name of the EME to create * @return a pointer to the desired EME object */ -BOTAN_DLL EMSA* get_emsa(const std::string& name); +BOTAN_DLL EMSA* get_emsa(const std::string& algo_spec); /** * Factory method for KDF (key derivation function) * @param name the name of the KDF to create * @return a pointer to the desired KDF object */ -BOTAN_DLL KDF* get_kdf(const std::string& name); +BOTAN_DLL KDF* get_kdf(const std::string& algo_spec); /* * Get a cipher object @@ -120,8 +148,8 @@ BOTAN_DLL KDF* get_kdf(const std::string& name); * @param key the key to be used for encryption/decryption performed by * the filter * @param iv the initialization vector to be used -* @param direction determines whether the filter will be an encrypting or decrypting -* filter +* @param direction determines whether the filter will be an encrypting +* or decrypting filter * @return a pointer to the encryption or decryption filter */ BOTAN_DLL Keyed_Filter* get_cipher(const std::string& name, @@ -133,8 +161,8 @@ BOTAN_DLL Keyed_Filter* get_cipher(const std::string& name, * @param algo_spec the name of the desired cipher * @param key the key to be used for encryption/decryption performed by * the filter -* @param direction determines whether the filter will be an encrypting or decrypting -* filter +* @param direction determines whether the filter will be an encrypting +* or decrypting filter * @return a pointer to the encryption or decryption filter */ BOTAN_DLL Keyed_Filter* get_cipher(const std::string& name, @@ -156,35 +184,51 @@ BOTAN_DLL Keyed_Filter* get_cipher(const std::string& name, Cipher_Dir dir); * @param name the name of the algorithm to check for * @return true if the algorithm exists, false otherwise */ -BOTAN_DLL bool have_algorithm(const std::string& name); +BOTAN_DLL bool have_algorithm(const std::string& algo_spec); /** * Check if a block cipher algorithm exists. * @param name the name of the algorithm to check for * @return true if the algorithm exists, false otherwise */ -BOTAN_DLL bool have_block_cipher(const std::string& name); +inline bool have_block_cipher(const std::string& algo_spec) + { + Algorithm_Factory& af = global_state().algorithm_factory(); + return (af.prototype_block_cipher(algo_spec) != 0); + } /** * Check if a stream cipher algorithm exists. * @param name the name of the algorithm to check for * @return true if the algorithm exists, false otherwise */ -BOTAN_DLL bool have_stream_cipher(const std::string& name); +inline bool have_stream_cipher(const std::string& algo_spec) + { + Algorithm_Factory& af = global_state().algorithm_factory(); + return (af.prototype_stream_cipher(algo_spec) != 0); + } /** * Check if a hash algorithm exists. * @param algo_spec the name of the algorithm to check for * @return true if the algorithm exists, false otherwise */ -BOTAN_DLL bool have_hash(const std::string& name); +inline bool have_hash(const std::string& algo_spec) + { + Algorithm_Factory& af = global_state().algorithm_factory(); + return (af.prototype_hash_function(algo_spec) != 0); + } /** * Check if a MAC algorithm exists. * @param algo_spec the name of the algorithm to check for * @return true if the algorithm exists, false otherwise */ -BOTAN_DLL bool have_mac(const std::string& name); +inline bool have_mac(const std::string& algo_spec) + { + Algorithm_Factory& af = global_state().algorithm_factory(); + return (af.prototype_mac(algo_spec) != 0); + } /* * Query information about an algorithm @@ -195,14 +239,14 @@ BOTAN_DLL bool have_mac(const std::string& name); * @param name the name of the algorithm * @return the block size of the specified algorithm */ -BOTAN_DLL u32bit block_size_of(const std::string& name); +BOTAN_DLL u32bit block_size_of(const std::string& algo_spec); /** * Find out the output length of a certain symmetric algorithm. * @param name the name of the algorithm * @return the output length of the specified algorithm */ -BOTAN_DLL u32bit output_length_of(const std::string& name); +BOTAN_DLL u32bit output_length_of(const std::string& algo_spec); /** * Find out the whether a certain key length is allowd for a given @@ -211,28 +255,29 @@ BOTAN_DLL u32bit output_length_of(const std::string& name); * @param name the name of the algorithm * @return true if the key length is valid for that algorithm, false otherwise */ -BOTAN_DLL bool valid_keylength_for(u32bit keylen, const std::string& name); +BOTAN_DLL bool valid_keylength_for(u32bit keylen, + const std::string& algo_spec); /** * Find out the minimum key size of a certain symmetric algorithm. * @param name the name of the algorithm * @return the minimum key length of the specified algorithm */ -BOTAN_DLL u32bit min_keylength_of(const std::string& name); +BOTAN_DLL u32bit min_keylength_of(const std::string& algo_spec); /** * Find out the maximum key size of a certain symmetric algorithm. * @param name the name of the algorithm * @return the maximum key length of the specified algorithm */ -BOTAN_DLL u32bit max_keylength_of(const std::string& name); +BOTAN_DLL u32bit max_keylength_of(const std::string& algo_spec); /** * Find out the size any valid key is a multiple of for a certain algorithm. * @param name the name of the algorithm * @return the size any valid key is a multiple of */ -BOTAN_DLL u32bit keylength_multiple_of(const std::string& name); +BOTAN_DLL u32bit keylength_multiple_of(const std::string& algo_spec); } diff --git a/src/libstate/policy.cpp b/src/libstate/policy.cpp index dfc1dfc7a..c11fc28ce 100644 --- a/src/libstate/policy.cpp +++ b/src/libstate/policy.cpp @@ -47,6 +47,8 @@ void set_default_oids(Library_State& config) add_oid(config, "2.16.840.1.101.3.4.1.2", "AES-128/CBC"); add_oid(config, "2.16.840.1.101.3.4.1.22", "AES-192/CBC"); add_oid(config, "2.16.840.1.101.3.4.1.42", "AES-256/CBC"); + add_oid(config, "1.2.410.200004.1.4", "SEED/CBC"); // RFC 4010 + add_oid(config, "1.3.6.1.4.1.25258.3.1", "Serpent/CBC"); /* Hash Functions */ add_oid(config, "1.2.840.113549.2.5", "MD5"); @@ -58,6 +60,13 @@ void set_default_oids(Library_State& config) add_oid(config, "2.16.840.1.101.3.4.2.2", "SHA-384"); add_oid(config, "2.16.840.1.101.3.4.2.3", "SHA-512"); + /* MACs */ + add_oid(config, "1.2.840.113549.2.7", "HMAC(SHA-1)"); + add_oid(config, "1.2.840.113549.2.8", "HMAC(SHA-224)"); + add_oid(config, "1.2.840.113549.2.9", "HMAC(SHA-256)"); + add_oid(config, "1.2.840.113549.2.10", "HMAC(SHA-384)"); + add_oid(config, "1.2.840.113549.2.11", "HMAC(SHA-512)"); + /* Key Wrap */ add_oid(config, "1.2.840.113549.1.9.16.3.6", "KeyWrap.TripleDES"); add_oid(config, "1.2.840.113549.1.9.16.3.7", "KeyWrap.RC2"); diff --git a/src/libstate/scan_name.cpp b/src/libstate/scan_name.cpp index 9e046e8ea..861934200 100644 --- a/src/libstate/scan_name.cpp +++ b/src/libstate/scan_name.cpp @@ -71,6 +71,8 @@ SCAN_Name::SCAN_Name(const std::string& algo_spec) u32bit level = 0; std::pair<u32bit, std::string> accum = std::make_pair(level, ""); + std::string decoding_error = "Bad SCAN name '" + algo_spec + "': "; + for(u32bit i = 0; i != algo_spec.size(); ++i) { char c = algo_spec[i]; @@ -82,7 +84,7 @@ SCAN_Name::SCAN_Name(const std::string& algo_spec) else if(c == ')') { if(level == 0) - throw Decoding_Error("Bad SCAN name " + algo_spec); + throw Decoding_Error(decoding_error + "Mismatched parens"); --level; } @@ -102,8 +104,11 @@ SCAN_Name::SCAN_Name(const std::string& algo_spec) if(accum.second != "") name.push_back(deref_aliases(accum)); - if(level != 0 || name.size() == 0) - throw Decoding_Error("Bad SCAN name " + algo_spec); + if(level != 0) + throw Decoding_Error(decoding_error + "Missing close paren"); + + if(name.size() == 0) + throw Decoding_Error(decoding_error + "Empty name"); alg_name = name[0].second; @@ -146,7 +151,7 @@ std::string SCAN_Name::algo_name_and_args() const std::string SCAN_Name::arg(u32bit i) const { if(i >= arg_count()) - throw std::range_error("SCAN_Name::argument"); + throw std::range_error("SCAN_Name::argument - i out of range"); return args[i]; } diff --git a/src/math/gfpmath/gfp_element.h b/src/math/gfpmath/gfp_element.h index c84806f9a..a4d9ac250 100644 --- a/src/math/gfpmath/gfp_element.h +++ b/src/math/gfpmath/gfp_element.h @@ -234,7 +234,6 @@ class BOTAN_DLL GFpElement mutable BigInt m_value; // ordinary residue or m-residue respectively mutable BigInt workspace; - // ***************************************** // data members for montgomery multiplication mutable bool m_use_montgm; //mutable BigInt m_mres; diff --git a/src/math/gfpmath/gfp_modulus.h b/src/math/gfpmath/gfp_modulus.h index 4773a8b89..03e8a19e0 100644 --- a/src/math/gfpmath/gfp_modulus.h +++ b/src/math/gfpmath/gfp_modulus.h @@ -13,7 +13,7 @@ namespace Botan { -class BOTAN_DLL GFpElement; +class GFpElement; /** * This class represents a GFpElement modulus including the modulus diff --git a/src/math/gfpmath/point_gfp.cpp b/src/math/gfpmath/point_gfp.cpp index 4dae1afc8..050fd0f50 100644 --- a/src/math/gfpmath/point_gfp.cpp +++ b/src/math/gfpmath/point_gfp.cpp @@ -921,7 +921,7 @@ SecureVector<byte> EC2OSP(const PointGFp& point, byte format) } else { - throw Format_Error("illegal point encoding format specification"); + throw Invalid_Argument("illegal point encoding format specification"); } return result; } @@ -1078,7 +1078,7 @@ PointGFp OS2ECP(MemoryRegion<byte> const& os, const CurveGFp& curve) } break; default: - throw Format_Error("encountered illegal format specification while decoding point"); + throw Invalid_Argument("encountered illegal format specification while decoding point"); } z = GFpElement(curve.get_p(), BigInt(1)); //assert((x.is_trf_to_mres() && x.is_use_montgm()) || !x.is_trf_to_mres()); diff --git a/src/math/numbertheory/powm_mnt.cpp b/src/math/numbertheory/powm_mnt.cpp index e356387c0..2d18ccdef 100644 --- a/src/math/numbertheory/powm_mnt.cpp +++ b/src/math/numbertheory/powm_mnt.cpp @@ -156,10 +156,9 @@ BigInt Montgomery_Exponentiator::execute() const Montgomery_Exponentiator::Montgomery_Exponentiator(const BigInt& mod, Power_Mod::Usage_Hints hints) { - if(!mod.is_positive()) - throw Exception("Montgomery_Exponentiator: modulus must be positive"); - if(mod.is_even()) - throw Exception("Montgomery_Exponentiator: modulus must be odd"); + // Montgomery reduction only works for positive odd moduli + if(!mod.is_positive() || mod.is_even()) + throw Invalid_Argument("Montgomery_Exponentiator: invalid modulus"); window_bits = 0; this->hints = hints; diff --git a/src/pk_pad/eme1/eme1.cpp b/src/pk_pad/eme1/eme1.cpp index 13f68f8e4..d99ffaf58 100644 --- a/src/pk_pad/eme1/eme1.cpp +++ b/src/pk_pad/eme1/eme1.cpp @@ -21,7 +21,7 @@ SecureVector<byte> EME1::pad(const byte in[], u32bit in_length, key_length /= 8; if(in_length > key_length - 2*HASH_LENGTH - 1) - throw Exception("EME1: Input is too large"); + throw Invalid_Argument("EME1: Input is too large"); SecureVector<byte> out(key_length); diff --git a/src/pubkey/dl_group/dl_group.cpp b/src/pubkey/dl_group/dl_group.cpp index 6bb49fa5a..55a83794c 100644 --- a/src/pubkey/dl_group/dl_group.cpp +++ b/src/pubkey/dl_group/dl_group.cpp @@ -193,7 +193,7 @@ const BigInt& DL_Group::get_q() const { init_check(); if(q == 0) - throw Format_Error("DLP group has no q prime specified"); + throw Invalid_State("DLP group has no q prime specified"); return q; } @@ -325,7 +325,7 @@ BigInt DL_Group::make_dsa_generator(const BigInt& p, const BigInt& q) } if(g == 1) - throw Exception("DL_Group: Couldn't create a suitable generator"); + throw Internal_Error("DL_Group: Couldn't create a suitable generator"); return g; } diff --git a/src/pubkey/dlies/dlies.cpp b/src/pubkey/dlies/dlies.cpp index 3a3ab52ee..6ef3292e1 100644 --- a/src/pubkey/dlies/dlies.cpp +++ b/src/pubkey/dlies/dlies.cpp @@ -127,7 +127,7 @@ SecureVector<byte> DLIES_Decryptor::dec(const byte msg[], u32bit length) const mac->update(0); SecureVector<byte> T2 = mac->final(); if(T != T2) - throw Integrity_Failure("DLIES: message authentication failed"); + throw Decoding_Error("DLIES: message authentication failed"); xor_buf(C, K.begin() + mac_keylen, C.size()); diff --git a/src/pubkey/dsa/dsa.cpp b/src/pubkey/dsa/dsa.cpp index b0688ae0d..5be3e1d48 100644 --- a/src/pubkey/dsa/dsa.cpp +++ b/src/pubkey/dsa/dsa.cpp @@ -97,6 +97,8 @@ SecureVector<byte> DSA_PrivateKey::sign(const byte in[], u32bit length, { const BigInt& q = group_q(); + rng.add_entropy(in, length); + BigInt k; do k.randomize(rng, q.bits()); diff --git a/src/pubkey/ecc_key/ecc_key.cpp b/src/pubkey/ecc_key/ecc_key.cpp index 8d9e89f1e..7d3c79868 100644 --- a/src/pubkey/ecc_key/ecc_key.cpp +++ b/src/pubkey/ecc_key/ecc_key.cpp @@ -134,9 +134,9 @@ void EC_PublicKey::set_parameter_encoding(EC_dompar_enc type) m_param_enc = type; } -/******************************** +/* * EC_PrivateKey -********************************/ +*/ void EC_PrivateKey::affirm_init() const // virtual { if(m_private_value == 0) diff --git a/src/pubkey/ecdsa/ecdsa.cpp b/src/pubkey/ecdsa/ecdsa.cpp index ea90010b1..dffd37e6f 100644 --- a/src/pubkey/ecdsa/ecdsa.cpp +++ b/src/pubkey/ecdsa/ecdsa.cpp @@ -155,9 +155,9 @@ u32bit ECDSA_PublicKey::max_input_bits() const return mp_dom_pars->get_order().bits(); } -/************************* +/* * ECDSA_PrivateKey -*************************/ +*/ void ECDSA_PrivateKey::affirm_init() const // virtual { EC_PrivateKey::affirm_init(); diff --git a/src/pubkey/eckaeg/eckaeg.cpp b/src/pubkey/eckaeg/eckaeg.cpp index a2dec5279..15c817fa7 100644 --- a/src/pubkey/eckaeg/eckaeg.cpp +++ b/src/pubkey/eckaeg/eckaeg.cpp @@ -16,9 +16,9 @@ namespace Botan { -/********************************* +/* * ECKAEG_PublicKey -*********************************/ +*/ void ECKAEG_PublicKey::affirm_init() const // virtual { @@ -72,9 +72,9 @@ ECKAEG_PublicKey::ECKAEG_PublicKey(EC_Domain_Params const& dom_par, PointGFp con m_eckaeg_core = ECKAEG_Core(*mp_dom_pars, BigInt(0), *mp_public_point); } -/********************************* +/* * ECKAEG_PrivateKey -*********************************/ +*/ void ECKAEG_PrivateKey::affirm_init() const // virtual { EC_PrivateKey::affirm_init(); diff --git a/src/pubkey/pk_codecs/pkcs8.cpp b/src/pubkey/pk_codecs/pkcs8.cpp index 6cbdabac0..830f3a10d 100644 --- a/src/pubkey/pk_codecs/pkcs8.cpp +++ b/src/pubkey/pk_codecs/pkcs8.cpp @@ -168,7 +168,7 @@ void encrypt_key(const Private_Key& key, const std::string& pass, const std::string& pbe_algo, X509_Encoding encoding) { - const std::string DEFAULT_PBE = "PBE-PKCS5v20(SHA-1,TripleDES/CBC)"; + const std::string DEFAULT_PBE = "PBE-PKCS5v20(SHA-1,AES-128/CBC)"; Pipe raw_key; raw_key.start_msg(); diff --git a/src/pubkey/pk_codecs/pkcs8.h b/src/pubkey/pk_codecs/pkcs8.h index 28008bdba..adfad0e63 100644 --- a/src/pubkey/pk_codecs/pkcs8.h +++ b/src/pubkey/pk_codecs/pkcs8.h @@ -82,9 +82,8 @@ BOTAN_DLL void encode(const Private_Key& key, Pipe& pipe, * @param pipe the pipe to feed the encoded key into * @param pass the password to use for encryption * @param rng the rng to use -* @param pbe_algo the name of the desired password-based encryption algorithm. -* Provide an empty string to use the default PBE defined in the configuration -* under base/default_pbe. +* @param pbe_algo the name of the desired password-based encryption algorithm; + if empty ("") a reasonable (portable/secure) default will be chosen. * @param enc the encoding type to use */ BOTAN_DLL void encrypt_key(const Private_Key& key, @@ -108,9 +107,8 @@ BOTAN_DLL std::string PEM_encode(const Private_Key& key); * @param key the key to encode * @param rng the rng to use * @param pass the password to use for encryption -* @param pbe_algo the name of the desired password-based encryption algorithm. -* Provide an empty string to use the default PBE defined in the configuration -* under base/default_pbe. +* @param pbe_algo the name of the desired password-based encryption algorithm; + if empty ("") a reasonable (portable/secure) default will be chosen. */ BOTAN_DLL std::string PEM_encode(const Private_Key& key, RandomNumberGenerator& rng, diff --git a/src/pubkey/pubkey.cpp b/src/pubkey/pubkey.cpp index a6e424e05..69002207f 100644 --- a/src/pubkey/pubkey.cpp +++ b/src/pubkey/pubkey.cpp @@ -73,7 +73,7 @@ PK_Encryptor_MR_with_EME::enc(const byte msg[], message.set(msg, length); if(8*(message.size() - 1) + high_bit(message[0]) > key.max_input_bits()) - throw Exception("PK_Encryptor_MR_with_EME: Input is too large"); + throw Invalid_Argument("PK_Encryptor_MR_with_EME: Input is too large"); return key.encrypt(message, message.size(), rng); } @@ -113,11 +113,7 @@ SecureVector<byte> PK_Decryptor_MR_with_EME::dec(const byte msg[], } catch(Invalid_Argument) { - throw Exception("PK_Decryptor_MR_with_EME: Input is invalid"); - } - catch(Decoding_Error) - { - throw Exception("PK_Decryptor_MR_with_EME: Input is invalid"); + throw Decoding_Error("PK_Decryptor_MR_with_EME: Input is invalid"); } } @@ -331,7 +327,6 @@ bool PK_Verifier::check_signature(const byte sig[], u32bit length) std::to_string(sig_format)); } catch(Invalid_Argument) { return false; } - catch(Decoding_Error) { return false; } } /* diff --git a/src/rng/auto_rng/auto_rng.cpp b/src/rng/auto_rng/auto_rng.cpp index 5befc9d14..78a7ca21d 100644 --- a/src/rng/auto_rng/auto_rng.cpp +++ b/src/rng/auto_rng/auto_rng.cpp @@ -6,10 +6,8 @@ */ #include <botan/auto_rng.h> +#include <botan/libstate.h> #include <botan/parsing.h> -#include <botan/hmac.h> -#include <botan/sha2_32.h> -#include <botan/sha2_64.h> #if defined(BOTAN_HAS_RANDPOOL) #include <botan/randpool.h> @@ -23,10 +21,6 @@ #include <botan/x931_rng.h> #endif -#if defined(BOTAN_HAS_AES) - #include <botan/aes.h> -#endif - #if defined(BOTAN_HAS_ENTROPY_SRC_HIGH_RESOLUTION_TIMER) #include <botan/internal/hres_timer.h> #endif @@ -115,10 +109,18 @@ AutoSeeded_RNG::AutoSeeded_RNG(u32bit poll_bits) { rng = 0; + Algorithm_Factory& af = global_state().algorithm_factory(); + #if defined(BOTAN_HAS_HMAC_RNG) - rng = new HMAC_RNG(new HMAC(new SHA_512), new HMAC(new SHA_256)); + + rng = new HMAC_RNG(af.make_mac("HMAC(SHA-512)"), + af.make_mac("HMAC(SHA-256)")); + #elif defined(BOTAN_HAS_RANDPOOL) && defined(BOTAN_HAS_AES) - rng = new Randpool(new AES_256, new HMAC(new SHA_256)); + + rng = new Randpool(af.make_block_cipher("AES-256"), + af.make_mac("HMAC(SHA-256)")); + #endif if(!rng) @@ -126,7 +128,9 @@ AutoSeeded_RNG::AutoSeeded_RNG(u32bit poll_bits) /* If X9.31 is available, use it to wrap the other RNG as a failsafe */ #if defined(BOTAN_HAS_X931_RNG) && defined(BOTAN_HAS_AES) - rng = new ANSI_X931_RNG(new AES_256, rng); + + rng = new ANSI_X931_RNG(af.make_block_cipher("AES-256"), rng); + #endif add_entropy_sources(rng); diff --git a/src/s2k/pbkdf1/pbkdf1.cpp b/src/s2k/pbkdf1/pbkdf1.cpp index 04e3aa453..fcc5b9a97 100644 --- a/src/s2k/pbkdf1/pbkdf1.cpp +++ b/src/s2k/pbkdf1/pbkdf1.cpp @@ -18,10 +18,10 @@ OctetString PKCS5_PBKDF1::derive(u32bit key_len, u32bit iterations) const { if(iterations == 0) - throw Invalid_Argument("PKCS#5 PBKDF1: Invalid iteration count"); + throw Invalid_Argument("PKCS5_PBKDF1: Invalid iteration count"); if(key_len > hash->OUTPUT_LENGTH) - throw Exception("PKCS#5 PBKDF1: Requested output length too long"); + throw Invalid_Argument("PKCS5_PBKDF1: Requested output length too long"); hash->update(passphrase); hash->update(salt, salt_size); diff --git a/src/selftest/selftest.cpp b/src/selftest/selftest.cpp index d1fdd03b0..a11accbd3 100644 --- a/src/selftest/selftest.cpp +++ b/src/selftest/selftest.cpp @@ -197,89 +197,97 @@ void cipher_kat(Algorithm_Factory& af, * Perform Self Tests */ bool passes_self_tests(Algorithm_Factory& af) - { - try - { - cipher_kat(af, "DES", - "0123456789ABCDEF", "1234567890ABCDEF", - "4E6F77206973207468652074696D6520666F7220616C6C20", - "3FA40E8A984D48156A271787AB8883F9893D51EC4B563B53", - "E5C7CDDE872BF27C43E934008C389C0F683788499A7C05F6", - "F3096249C7F46E51A69E839B1A92F78403467133898EA622", - "F3096249C7F46E5135F24A242EEB3D3F3D6D5BE3255AF8C3", - "F3096249C7F46E51163A8CA0FFC94C27FA2F80F480B86F75"); - - cipher_kat(af, "TripleDES", - "385D7189A5C3D485E1370AA5D408082B5CCCCB5E19F2D90E", - "C141B5FCCD28DC8A", - "6E1BD7C6120947A464A6AAB293A0F89A563D8D40D3461B68", - "64EAAD4ACBB9CEAD6C7615E7C7E4792FE587D91F20C7D2F4", - "6235A461AFD312973E3B4F7AA7D23E34E03371F8E8C376C9", - "E26BA806A59B0330DE40CA38E77A3E494BE2B212F6DD624B", - "E26BA806A59B03307DE2BCC25A08BA40A8BA335F5D604C62", - "E26BA806A59B03303C62C2EFF32D3ACDD5D5F35EBCC53371"); - - cipher_kat(af, "AES-128", - "2B7E151628AED2A6ABF7158809CF4F3C", - "000102030405060708090A0B0C0D0E0F", - "6BC1BEE22E409F96E93D7E117393172A" - "AE2D8A571E03AC9C9EB76FAC45AF8E51", - "3AD77BB40D7A3660A89ECAF32466EF97" - "F5D3D58503B9699DE785895A96FDBAAF", - "7649ABAC8119B246CEE98E9B12E9197D" - "5086CB9B507219EE95DB113A917678B2", - "3B3FD92EB72DAD20333449F8E83CFB4A" - "C8A64537A0B3A93FCDE3CDAD9F1CE58B", - "3B3FD92EB72DAD20333449F8E83CFB4A" - "7789508D16918F03F53C52DAC54ED825", - "3B3FD92EB72DAD20333449F8E83CFB4A" - "010C041999E03F36448624483E582D0E"); - - hash_test(af, "SHA-1", - "", "DA39A3EE5E6B4B0D3255BFEF95601890AFD80709"); - - hash_test(af, "SHA-1", - "616263", "A9993E364706816ABA3E25717850C26C9CD0D89D"); - - hash_test(af, "SHA-1", - "6162636462636465636465666465666765666768666768696768696A" - "68696A6B696A6B6C6A6B6C6D6B6C6D6E6C6D6E6F6D6E6F706E6F7071", - "84983E441C3BD26EBAAE4AA1F95129E5E54670F1"); - - mac_test(af, "HMAC(SHA-1)", - "4869205468657265", - "B617318655057264E28BC0B6FB378C8EF146BE00", - "0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B"); - - hash_test(af, "SHA-256", - "", - "E3B0C44298FC1C149AFBF4C8996FB924" - "27AE41E4649B934CA495991B7852B855"); - - hash_test(af, "SHA-256", - "616263", - "BA7816BF8F01CFEA414140DE5DAE2223" - "B00361A396177A9CB410FF61F20015AD"); - - hash_test(af, "SHA-256", - "6162636462636465636465666465666765666768666768696768696A" - "68696A6B696A6B6C6A6B6C6D6B6C6D6E6C6D6E6F6D6E6F706E6F7071", - "248D6A61D20638B8E5C026930C3E6039" - "A33CE45964FF2167F6ECEDD419DB06C1"); - - mac_test(af, "HMAC(SHA-256)", - "4869205468657265", - "198A607EB44BFBC69903A0F1CF2BBDC5" - "BA0AA3F3D9AE3C1C7A3B1696A0B68CF7", - "0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B" - "0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B"); - } - catch(Self_Test_Failure) - { - return false; - } + { + try + { + confirm_startup_self_tests(af); + } + catch(Self_Test_Failure) + { + return false; + } - return true; + return true; + } + +/* +* Perform Self Tests +*/ +void confirm_startup_self_tests(Algorithm_Factory& af) + { + cipher_kat(af, "DES", + "0123456789ABCDEF", "1234567890ABCDEF", + "4E6F77206973207468652074696D6520666F7220616C6C20", + "3FA40E8A984D48156A271787AB8883F9893D51EC4B563B53", + "E5C7CDDE872BF27C43E934008C389C0F683788499A7C05F6", + "F3096249C7F46E51A69E839B1A92F78403467133898EA622", + "F3096249C7F46E5135F24A242EEB3D3F3D6D5BE3255AF8C3", + "F3096249C7F46E51163A8CA0FFC94C27FA2F80F480B86F75"); + + cipher_kat(af, "TripleDES", + "385D7189A5C3D485E1370AA5D408082B5CCCCB5E19F2D90E", + "C141B5FCCD28DC8A", + "6E1BD7C6120947A464A6AAB293A0F89A563D8D40D3461B68", + "64EAAD4ACBB9CEAD6C7615E7C7E4792FE587D91F20C7D2F4", + "6235A461AFD312973E3B4F7AA7D23E34E03371F8E8C376C9", + "E26BA806A59B0330DE40CA38E77A3E494BE2B212F6DD624B", + "E26BA806A59B03307DE2BCC25A08BA40A8BA335F5D604C62", + "E26BA806A59B03303C62C2EFF32D3ACDD5D5F35EBCC53371"); + + cipher_kat(af, "AES-128", + "2B7E151628AED2A6ABF7158809CF4F3C", + "000102030405060708090A0B0C0D0E0F", + "6BC1BEE22E409F96E93D7E117393172A" + "AE2D8A571E03AC9C9EB76FAC45AF8E51", + "3AD77BB40D7A3660A89ECAF32466EF97" + "F5D3D58503B9699DE785895A96FDBAAF", + "7649ABAC8119B246CEE98E9B12E9197D" + "5086CB9B507219EE95DB113A917678B2", + "3B3FD92EB72DAD20333449F8E83CFB4A" + "C8A64537A0B3A93FCDE3CDAD9F1CE58B", + "3B3FD92EB72DAD20333449F8E83CFB4A" + "7789508D16918F03F53C52DAC54ED825", + "3B3FD92EB72DAD20333449F8E83CFB4A" + "010C041999E03F36448624483E582D0E"); + + hash_test(af, "SHA-1", + "", "DA39A3EE5E6B4B0D3255BFEF95601890AFD80709"); + + hash_test(af, "SHA-1", + "616263", "A9993E364706816ABA3E25717850C26C9CD0D89D"); + + hash_test(af, "SHA-1", + "6162636462636465636465666465666765666768666768696768696A" + "68696A6B696A6B6C6A6B6C6D6B6C6D6E6C6D6E6F6D6E6F706E6F7071", + "84983E441C3BD26EBAAE4AA1F95129E5E54670F1"); + + mac_test(af, "HMAC(SHA-1)", + "4869205468657265", + "B617318655057264E28BC0B6FB378C8EF146BE00", + "0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B"); + + hash_test(af, "SHA-256", + "", + "E3B0C44298FC1C149AFBF4C8996FB924" + "27AE41E4649B934CA495991B7852B855"); + + hash_test(af, "SHA-256", + "616263", + "BA7816BF8F01CFEA414140DE5DAE2223" + "B00361A396177A9CB410FF61F20015AD"); + + hash_test(af, "SHA-256", + "6162636462636465636465666465666765666768666768696768696A" + "68696A6B696A6B6C6A6B6C6D6B6C6D6E6C6D6E6F6D6E6F706E6F7071", + "248D6A61D20638B8E5C026930C3E6039" + "A33CE45964FF2167F6ECEDD419DB06C1"); + + mac_test(af, "HMAC(SHA-256)", + "4869205468657265", + "198A607EB44BFBC69903A0F1CF2BBDC5" + "BA0AA3F3D9AE3C1C7A3B1696A0B68CF7", + "0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B" + "0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B"); } } diff --git a/src/selftest/selftest.h b/src/selftest/selftest.h index 4cb6e23d7..df71e6f8e 100644 --- a/src/selftest/selftest.h +++ b/src/selftest/selftest.h @@ -18,6 +18,8 @@ namespace Botan { /* * Self Tests */ +BOTAN_DLL void confirm_startup_self_tests(Algorithm_Factory& af); + BOTAN_DLL bool passes_self_tests(Algorithm_Factory& af); BOTAN_DLL std::map<std::string, bool> diff --git a/src/stream/stream_cipher.h b/src/stream/stream_cipher.h index 29c16c8b5..cb6fb3481 100644 --- a/src/stream/stream_cipher.h +++ b/src/stream/stream_cipher.h @@ -42,8 +42,8 @@ class BOTAN_DLL StreamCipher : public SymmetricAlgorithm virtual void set_iv(const byte[], u32bit iv_len) { if(iv_len) - throw Exception("The stream cipher " + name() + - " does not support resyncronization"); + throw Invalid_Argument("The stream cipher " + name() + + " does not support resyncronization"); } /** diff --git a/src/utils/bswap.h b/src/utils/bswap.h index 96ec4982a..fcb0fa7ea 100644 --- a/src/utils/bswap.h +++ b/src/utils/bswap.h @@ -16,10 +16,6 @@ #include <emmintrin.h> #endif -#if defined(BOTAN_TARGET_CPU_HAS_SSSE3) - #include <tmmintrin.h> -#endif - namespace Botan { /* @@ -32,8 +28,7 @@ inline u16bit reverse_bytes(u16bit input) inline u32bit reverse_bytes(u32bit input) { -#if BOTAN_USE_GCC_INLINE_ASM && (defined(BOTAN_TARGET_ARCH_IS_IA32) || \ - defined(BOTAN_TARGET_ARCH_IS_AMD64)) +#if BOTAN_USE_GCC_INLINE_ASM && defined(BOTAN_TARGET_CPU_IS_X86_FAMILY) // GCC-style inline assembly for x86 or x86-64 asm("bswapl %0" : "=r" (input) : "0" (input)); @@ -83,23 +78,7 @@ inline void bswap_4(T x[4]) x[3] = reverse_bytes(x[3]); } -#if defined(BOTAN_TARGET_CPU_HAS_SSSE3) - -template<> -inline void bswap_4(u32bit x[4]) - { - const __m128i bswap_mask = _mm_set_epi8( - 12, 13, 14, 15, - 8, 9, 10, 11, - 4, 5, 6, 7, - 0, 1, 2, 3); - - __m128i T = _mm_loadu_si128((const __m128i*)x); - T = _mm_shuffle_epi8(T, bswap_mask); - _mm_storeu_si128((__m128i*)x, T); - } - -#elif defined(BOTAN_TARGET_CPU_HAS_SSE2) +#if defined(BOTAN_TARGET_CPU_HAS_SSE2) template<> inline void bswap_4(u32bit x[4]) diff --git a/src/utils/cpuid.cpp b/src/utils/cpuid.cpp index 2ba7f9b77..924d29b1b 100644 --- a/src/utils/cpuid.cpp +++ b/src/utils/cpuid.cpp @@ -10,7 +10,11 @@ #include <botan/loadstor.h> #include <botan/mem_ops.h> -#if defined(BOTAN_TARGET_ARCH_IS_IA32) || defined(BOTAN_TARGET_ARCH_IS_AMD64) +#if defined(BOTAN_TARGET_OS_IS_DARWIN) + #include <sys/sysctl.h> +#endif + +#if defined(BOTAN_TARGET_CPU_IS_X86_FAMILY) #if defined(BOTAN_BUILD_COMPILER_IS_MSVC) @@ -64,6 +68,73 @@ u32bit get_x86_cache_line_size() return 32; // default cache line guess } +#if defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY) + +bool altivec_check_sysctl() + { +#if defined(BOTAN_TARGET_OS_IS_DARWIN) + + // From Apple's docs + int sels[2] = { CTL_HW, HW_VECTORUNIT }; + int vector_type = 0; + size_t length = sizeof(vector_type); + int error = sysctl(sels, 2, &vector_type, &length, NULL, 0); + + if(error == 0 && vector_type > 0) + return true; +#endif + + return false; + } + +bool altivec_check_pvr_emul() + { + bool altivec_capable = false; + +#if defined(BOTAN_TARGET_OS_IS_LINUX) || defined(BOTAN_TARGET_OS_IS_NETBSD) + + /* + On PowerPC, MSR 287 is PVR, the Processor Version Number + Normally it is only accessible to ring 0, but Linux and NetBSD + (others, too, maybe?) will trap and emulate it for us. + + PVR identifiers for various AltiVec enabled CPUs. Taken from + PearPC and Linux sources, mostly. + */ + + const u16bit PVR_G4_7400 = 0x000C; + const u16bit PVR_G5_970 = 0x0039; + const u16bit PVR_G5_970FX = 0x003C; + const u16bit PVR_G5_970MP = 0x0044; + const u16bit PVR_G5_970GX = 0x0045; + const u16bit PVR_POWER6 = 0x003E; + const u16bit PVR_CELL_PPU = 0x0070; + + // Motorola produced G4s with PVR 0x800[0123C] (at least) + const u16bit PVR_G4_74xx_24 = 0x800; + + u32bit pvr = 0; + + asm volatile("mfspr %0, 287" : "=r" (pvr)); + + // Top 16 bit suffice to identify model + pvr >>= 16; + + altivec_capable |= (pvr == PVR_G4_7400); + altivec_capable |= ((pvr >> 4) == PVR_G4_74xx_24); + altivec_capable |= (pvr == PVR_G5_970); + altivec_capable |= (pvr == PVR_G5_970FX); + altivec_capable |= (pvr == PVR_G5_970MP); + altivec_capable |= (pvr == PVR_G5_970GX); + altivec_capable |= (pvr == PVR_POWER6); + altivec_capable |= (pvr == PVR_CELL_PPU); +#endif + + return altivec_capable; + } + +#endif + } /* @@ -105,58 +176,9 @@ bool CPUID::has_altivec() if(first_time) { -#if defined(BOTAN_TARGET_ARCH_IS_PPC) || defined(BOTAN_TARGET_ARCH_IS_PPC64) - - /* - PVR identifiers for various AltiVec enabled CPUs. Taken from - PearPC and Linux sources, mostly. - */ - const u16bit PVR_G4_7400 = 0x000C; - const u16bit PVR_G5_970 = 0x0039; - const u16bit PVR_G5_970FX = 0x003C; - const u16bit PVR_G5_970MP = 0x0044; - const u16bit PVR_G5_970GX = 0x0045; - const u16bit PVR_POWER6 = 0x003E; - const u16bit PVR_CELL_PPU = 0x0070; - - // Motorola produced G4s with PVR 0x800[0123C] (at least) - const u16bit PVR_G4_74xx_24 = 0x800; - - /* - On PowerPC, MSR 287 is PVR, the Processor Version Number - - Normally it is only accessible to ring 0, but Linux and NetBSD - (at least) will trap and emulate it for us. This is roughly 20x - saner than every other approach I've seen for AltiVec detection - (all of which are entirely OS specific, to boot). - - Apparently OS X doesn't support this, but then again OS X - doesn't really support PPC anymore, so I'm not worrying about it. - - For OSes that aren't (known to) support the emulation, skip the - call, leaving pvr as 0 which will cause all subsequent model - number checks to fail (and we'll assume no AltiVec) - */ - -#if defined(BOTAN_TARGET_OS_IS_LINUX) || defined(BOTAN_TARGET_OS_IS_NETBSD) - #define BOTAN_TARGET_OS_SUPPORTS_MFSPR_EMUL -#endif - - u32bit pvr = 0; - -#if defined(BOTAN_TARGET_OS_SUPPORTS_MFSPR_EMUL) - asm volatile("mfspr %0, 287" : "=r" (pvr)); -#endif - // Top 16 bit suffice to identify model - pvr >>= 16; - - altivec_capable |= (pvr == PVR_G4_7400); - altivec_capable |= ((pvr >> 8) == PVR_G4_74xx_24); - altivec_capable |= (pvr == PVR_G5_970); - altivec_capable |= (pvr == PVR_G5_970FX); - altivec_capable |= (pvr == PVR_G5_970MP); - altivec_capable |= (pvr == PVR_G5_970GX); - altivec_capable |= (pvr == PVR_CELL_PPU); +#if defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY) + if(altivec_check_sysctl() || altivec_check_pvr_emul()) + altivec_capable = true; #endif first_time = false; diff --git a/src/utils/cpuid.h b/src/utils/cpuid.h index 2c9599899..1de97f129 100644 --- a/src/utils/cpuid.h +++ b/src/utils/cpuid.h @@ -21,7 +21,7 @@ class BOTAN_DLL CPUID CPUID_SSSE3_BIT = 41, CPUID_SSE41_BIT = 51, CPUID_SSE42_BIT = 52, - CPUID_INTEL_AES_BIT = 57, + CPUID_INTEL_AES_BIT = 57 }; /** @@ -66,12 +66,6 @@ class BOTAN_DLL CPUID { return ((x86_processor_flags() >> CPUID_INTEL_AES_BIT) & 1); } /** - * Check if the processor supports VIA's AES instructions - * (not implemented) - */ - static bool has_aes_via() { return false; } - - /** * Check if the processor supports AltiVec/VMX */ static bool has_altivec(); diff --git a/src/utils/debug.cpp b/src/utils/debug.cpp new file mode 100644 index 000000000..894418650 --- /dev/null +++ b/src/utils/debug.cpp @@ -0,0 +1,33 @@ +/** +* Internal-use debugging functions for Botan +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/internal/debug.h> +#include <cstdio> + +namespace Botan { + +namespace Debug { + +void print_vec(const std::string& name, + const byte array[], + size_t array_len) + { + std::printf("%s = ", name.c_str()); + for(size_t i = 0; i != array_len; ++i) + std::printf("%02X", array[i]); + std::printf("\n"); + } + +void print_vec(const std::string& name, + const MemoryRegion<byte>& vec) + { + print_vec(name, &vec[0], vec.size()); + } + +} + +} diff --git a/src/utils/debug.h b/src/utils/debug.h new file mode 100644 index 000000000..ee93d5ea0 --- /dev/null +++ b/src/utils/debug.h @@ -0,0 +1,29 @@ +/** +* Internal-use debugging functions for Botan +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#ifndef BOTAN_DEBUG_H__ +#define BOTAN_DEBUG_H__ + +#include <botan/secmem.h> + +namespace Botan { + +namespace Debug { + +void print_vec(const std::string& name, + const byte array[], + size_t array_len); + +void print_vec(const std::string& name, + const MemoryRegion<byte>& vec); + + +} + +} + +#endif diff --git a/src/utils/exceptn.cpp b/src/utils/exceptn.cpp deleted file mode 100644 index 2fa05f59d..000000000 --- a/src/utils/exceptn.cpp +++ /dev/null @@ -1,62 +0,0 @@ -/* -* Exceptions -* (C) 1999-2007 Jack Lloyd -* -* Distributed under the terms of the Botan license -*/ - -#include <botan/exceptn.h> -#include <botan/parsing.h> - -namespace Botan { - -/* -* Constructor for Invalid_Key_Length -*/ -Invalid_Key_Length::Invalid_Key_Length(const std::string& name, u32bit length) - { - set_msg(name + " cannot accept a key of length " + std::to_string(length)); - } - -/* -* Constructor for Invalid_Block_Size -*/ -Invalid_Block_Size::Invalid_Block_Size(const std::string& mode, - const std::string& pad) - { - set_msg("Padding method " + pad + " cannot be used with " + mode); - } - -/* -* Constructor for Invalid_IV_Length -*/ -Invalid_IV_Length::Invalid_IV_Length(const std::string& mode, u32bit bad_len) - { - set_msg("IV length " + std::to_string(bad_len) + " is invalid for " + mode); - } - -/* -* Constructor for Algorithm_Not_Found -*/ -Algorithm_Not_Found::Algorithm_Not_Found(const std::string& name) - { - set_msg("Could not find any algorithm named \"" + name + "\""); - } - -/* -* Constructor for Invalid_Algorithm_Name -*/ -Invalid_Algorithm_Name::Invalid_Algorithm_Name(const std::string& name) - { - set_msg("Invalid algorithm name: " + name); - } - -/* -* Constructor for Config_Error -*/ -Config_Error::Config_Error(const std::string& err, u32bit line) - { - set_msg("Config error at line " + std::to_string(line) + ": " + err); - } - -} diff --git a/src/utils/exceptn.h b/src/utils/exceptn.h index a55d842bc..86efebc7c 100644 --- a/src/utils/exceptn.h +++ b/src/utils/exceptn.h @@ -1,6 +1,6 @@ /* * Exceptions -* (C) 1999-2007 Jack Lloyd +* (C) 1999-2009 Jack Lloyd * * Distributed under the terms of the Botan license */ @@ -9,32 +9,44 @@ #define BOTAN_EXCEPTION_H__ #include <botan/types.h> +#include <botan/parsing.h> #include <exception> +#include <stdexcept> #include <string> namespace Botan { +typedef std::runtime_error Exception; +typedef std::invalid_argument Invalid_Argument; + /* -* Exception Base Class +* Invalid_State Exception */ -class BOTAN_DLL Exception : public std::exception +struct BOTAN_DLL Invalid_State : public Exception { - public: - const char* what() const throw() { return msg.c_str(); } - Exception(const std::string& m = "Unknown error") { set_msg(m); } - virtual ~Exception() throw() {} - protected: - void set_msg(const std::string& m) { msg = "Botan: " + m; } - private: - std::string msg; + Invalid_State(const std::string& err) : + Exception(err) + {} }; /* -* Invalid_Argument Exception +* Lookup_Error Exception */ -struct BOTAN_DLL Invalid_Argument : public Exception +struct BOTAN_DLL Lookup_Error : public Exception { - Invalid_Argument(const std::string& err = "") : Exception(err) {} + Lookup_Error(const std::string& err) : + Exception(err) + {} + }; + +/* +* Internal_Error Exception +*/ +struct BOTAN_DLL Internal_Error : public Exception + { + Internal_Error(const std::string& err) : + Exception("Internal error: " + err) + {} }; /* @@ -42,7 +54,10 @@ struct BOTAN_DLL Invalid_Argument : public Exception */ struct BOTAN_DLL Invalid_Key_Length : public Invalid_Argument { - Invalid_Key_Length(const std::string&, u32bit); + Invalid_Key_Length(const std::string& name, u32bit length) : + Invalid_Argument(name + " cannot accept a key of length " + + to_string(length)) + {} }; /* @@ -50,7 +65,11 @@ struct BOTAN_DLL Invalid_Key_Length : public Invalid_Argument */ struct BOTAN_DLL Invalid_Block_Size : public Invalid_Argument { - Invalid_Block_Size(const std::string&, const std::string&); + Invalid_Block_Size(const std::string& mode, + const std::string& pad) : + Invalid_Argument("Padding method " + pad + + " cannot be used with " + mode) + {} }; /* @@ -58,15 +77,10 @@ struct BOTAN_DLL Invalid_Block_Size : public Invalid_Argument */ struct BOTAN_DLL Invalid_IV_Length : public Invalid_Argument { - Invalid_IV_Length(const std::string&, u32bit); - }; - -/* -* Invalid_State Exception -*/ -struct BOTAN_DLL Invalid_State : public Exception - { - Invalid_State(const std::string& err) : Exception(err) {} + Invalid_IV_Length(const std::string& mode, u32bit bad_len) : + Invalid_Argument("IV length " + to_string(bad_len) + + " is invalid for " + mode) + {} }; /* @@ -75,7 +89,8 @@ struct BOTAN_DLL Invalid_State : public Exception struct BOTAN_DLL PRNG_Unseeded : public Invalid_State { PRNG_Unseeded(const std::string& algo) : - Invalid_State("PRNG not seeded: " + algo) {} + Invalid_State("PRNG not seeded: " + algo) + {} }; /* @@ -84,57 +99,46 @@ struct BOTAN_DLL PRNG_Unseeded : public Invalid_State struct BOTAN_DLL Policy_Violation : public Invalid_State { Policy_Violation(const std::string& err) : - Invalid_State("Policy violation: " + err) {} - }; - -/* -* Lookup_Error Exception -*/ -struct BOTAN_DLL Lookup_Error : public Exception - { - Lookup_Error(const std::string& err) : Exception(err) {} + Invalid_State("Policy violation: " + err) + {} }; /* * Algorithm_Not_Found Exception */ -struct BOTAN_DLL Algorithm_Not_Found : public Exception +struct BOTAN_DLL Algorithm_Not_Found : public Lookup_Error { - Algorithm_Not_Found(const std::string&); - }; - -/* -* Format_Error Exception -*/ -struct BOTAN_DLL Format_Error : public Exception - { - Format_Error(const std::string& err = "") : Exception(err) {} + Algorithm_Not_Found(const std::string& name) : + Lookup_Error("Could not find any algorithm named \"" + name + "\"") + {} }; /* * Invalid_Algorithm_Name Exception */ -struct BOTAN_DLL Invalid_Algorithm_Name : public Format_Error +struct BOTAN_DLL Invalid_Algorithm_Name : public Invalid_Argument { - Invalid_Algorithm_Name(const std::string&); + Invalid_Algorithm_Name(const std::string& name): + Invalid_Argument("Invalid algorithm name: " + name) + {} }; /* * Encoding_Error Exception */ -struct BOTAN_DLL Encoding_Error : public Format_Error +struct BOTAN_DLL Encoding_Error : public Invalid_Argument { Encoding_Error(const std::string& name) : - Format_Error("Encoding error: " + name) {} + Invalid_Argument("Encoding error: " + name) {} }; /* * Decoding_Error Exception */ -struct BOTAN_DLL Decoding_Error : public Format_Error +struct BOTAN_DLL Decoding_Error : public Invalid_Argument { Decoding_Error(const std::string& name) : - Format_Error("Decoding error: " + name) {} + Invalid_Argument("Decoding error: " + name) {} }; /* @@ -152,44 +156,27 @@ struct BOTAN_DLL Invalid_OID : public Decoding_Error struct BOTAN_DLL Stream_IO_Error : public Exception { Stream_IO_Error(const std::string& err) : - Exception("I/O error: " + err) {} + Exception("I/O error: " + err) + {} }; /* -* Configuration Error Exception -*/ -struct BOTAN_DLL Config_Error : public Format_Error - { - Config_Error(const std::string& err) : - Format_Error("Config error: " + err) {} - Config_Error(const std::string&, u32bit); - }; - -/* -* Integrity Failure Exception -*/ -struct BOTAN_DLL Integrity_Failure : public Exception - { - Integrity_Failure(const std::string& err) : - Exception("Integrity failure: " + err) {} - }; - -/* -* Internal_Error Exception +* Self Test Failure Exception */ -struct BOTAN_DLL Internal_Error : public Exception +struct BOTAN_DLL Self_Test_Failure : public Internal_Error { - Internal_Error(const std::string& err) : - Exception("Internal error: " + err) {} + Self_Test_Failure(const std::string& err) : + Internal_Error("Self test failed: " + err) + {} }; /* -* Self Test Failure Exception +* Memory Allocation Exception */ -struct BOTAN_DLL Self_Test_Failure : public Internal_Error +struct BOTAN_DLL Memory_Exhaustion : public std::bad_alloc { - Self_Test_Failure(const std::string& err) : - Internal_Error("Self test failed: " + err) {} + const char* what() const throw() + { return "Ran out of memory, allocation failed"; } }; } diff --git a/src/utils/info.txt b/src/utils/info.txt index 9ef961f0d..f9d33d9d8 100644 --- a/src/utils/info.txt +++ b/src/utils/info.txt @@ -5,7 +5,7 @@ load_on always <source> charset.cpp cpuid.cpp -exceptn.cpp +debug.cpp mlock.cpp parsing.cpp time.cpp @@ -16,6 +16,7 @@ version.cpp <header:internal> async.h bit_ops.h +debug.h mlock.h prefetch.h rounding.h diff --git a/src/utils/parsing.cpp b/src/utils/parsing.cpp index 3412cf02b..3b5ee42d0 100644 --- a/src/utils/parsing.cpp +++ b/src/utils/parsing.cpp @@ -121,7 +121,7 @@ std::vector<std::string> split_on(const std::string& str, char delim) } if(substr == "") - throw Format_Error("Unable to split string: " + str); + throw Invalid_Argument("Unable to split string: " + str); elems.push_back(substr); return elems; diff --git a/src/utils/prefetch.h b/src/utils/prefetch.h index 7afdbda0a..ede196692 100644 --- a/src/utils/prefetch.h +++ b/src/utils/prefetch.h @@ -32,7 +32,7 @@ inline void readwrite(const T* addr, u32bit length) const u32bit Ts_per_cache_line = CPUID::cache_line_size() / sizeof(T); for(u32bit i = 0; i <= length; i += Ts_per_cache_line) - __builtin_prefetch(addr + i, 0); + __builtin_prefetch(addr + i, 1); #endif } diff --git a/src/utils/simd_32/info.txt b/src/utils/simd_32/info.txt index 08cbdfa52..362e90235 100644 --- a/src/utils/simd_32/info.txt +++ b/src/utils/simd_32/info.txt @@ -1,7 +1,5 @@ define SIMD_32 -load_on always - <header:internal> simd_32.h simd_sse.h diff --git a/src/utils/simd_32/simd_32.h b/src/utils/simd_32/simd_32.h index 38ea078d0..4bd983f5e 100644 --- a/src/utils/simd_32/simd_32.h +++ b/src/utils/simd_32/simd_32.h @@ -27,4 +27,20 @@ #endif +namespace Botan { + +inline SIMD_32 rotate_left(SIMD_32 x, u32bit rot) + { + x.rotate_left(rot); + return x; + } + +inline SIMD_32 rotate_right(SIMD_32 x, u32bit rot) + { + x.rotate_right(rot); + return x; + } + +} + #endif diff --git a/src/utils/simd_32/simd_altivec.h b/src/utils/simd_32/simd_altivec.h index 9cc5c1068..859a48a5f 100644 --- a/src/utils/simd_32/simd_altivec.h +++ b/src/utils/simd_32/simd_altivec.h @@ -145,6 +145,11 @@ class SIMD_Altivec reg = vec_or(reg, other.reg); } + SIMD_Altivec operator&(const SIMD_Altivec& other) + { + return vec_and(reg, other.reg); + } + void operator&=(const SIMD_Altivec& other) { reg = vec_and(reg, other.reg); diff --git a/src/utils/simd_32/simd_scalar.h b/src/utils/simd_32/simd_scalar.h index 148b76c35..5cf1a11c3 100644 --- a/src/utils/simd_32/simd_scalar.h +++ b/src/utils/simd_32/simd_scalar.h @@ -142,6 +142,14 @@ class SIMD_Scalar R3 |= other.R3; } + SIMD_Scalar operator&(const SIMD_Scalar& other) + { + return SIMD_Scalar(R0 & other.R0, + R1 & other.R1, + R2 & other.R2, + R3 & other.R3); + } + void operator&=(const SIMD_Scalar& other) { R0 &= other.R0; diff --git a/src/utils/simd_32/simd_sse.h b/src/utils/simd_32/simd_sse.h index 31bbce2c7..0189c2e4d 100644 --- a/src/utils/simd_32/simd_sse.h +++ b/src/utils/simd_32/simd_sse.h @@ -101,6 +101,11 @@ class SIMD_SSE2 reg = _mm_or_si128(reg, other.reg); } + SIMD_SSE2 operator&(const SIMD_SSE2& other) + { + return _mm_and_si128(reg, other.reg); + } + void operator&=(const SIMD_SSE2& other) { reg = _mm_and_si128(reg, other.reg); diff --git a/src/wrap/python/filter.cpp b/src/wrap/python/filter.cpp index a678af9e5..48a3f84eb 100644 --- a/src/wrap/python/filter.cpp +++ b/src/wrap/python/filter.cpp @@ -1,7 +1,9 @@ -/************************************************* -* Boost.Python module definition * -* (C) 1999-2007 Jack Lloyd * -*************************************************/ +/* +* Boost.Python module definition +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ #include <boost/python.hpp> using namespace boost::python; diff --git a/src/wrap/python/python_botan.h b/src/wrap/python/python_botan.h index 646c2e2c1..a7a2e505e 100644 --- a/src/wrap/python/python_botan.h +++ b/src/wrap/python/python_botan.h @@ -1,3 +1,8 @@ +/* +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ #ifndef BOTAN_BOOST_PYTHON_COMMON_H__ #define BOTAN_BOOST_PYTHON_COMMON_H__ diff --git a/src/wrap/python/x509.cpp b/src/wrap/python/x509.cpp index 90c2bba1c..c2c9533c8 100644 --- a/src/wrap/python/x509.cpp +++ b/src/wrap/python/x509.cpp @@ -1,7 +1,9 @@ -/************************************************* -* Boost.Python module definition * -* (C) 1999-2007 Jack Lloyd * -*************************************************/ +/* +* Boost.Python module definition +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ #include <botan/oids.h> #include <botan/pipe.h> |