00001
00002
00003
00004
00005
00006 #ifndef CRYPTOPP_PANAMA_H
00007 #define CRYPTOPP_PANAMA_H
00008
00009 #include "strciphr.h"
00010 #include "iterhash.h"
00011 #include "secblock.h"
00012
00013 #if CRYPTOPP_BOOL_X32
00014 # define CRYPTOPP_DISABLE_PANAMA_ASM
00015 #endif
00016
00017 NAMESPACE_BEGIN(CryptoPP)
00018
00019
00020 template <class B>
00021 class CRYPTOPP_NO_VTABLE Panama
00022 {
00023 public:
00024 void Reset();
00025 void Iterate(size_t count, const word32 *p=NULL, byte *output=NULL, const byte *input=NULL, KeystreamOperation operation=WRITE_KEYSTREAM);
00026
00027 protected:
00028 typedef word32 Stage[8];
00029 CRYPTOPP_CONSTANT(STAGES = 32)
00030
00031 FixedSizeAlignedSecBlock<word32, 20 + 8*32> m_state;
00032 };
00033
00034 namespace Weak {
00035
00036 template <class B = LittleEndian>
00037 class PanamaHash : protected Panama<B>, public AlgorithmImpl<IteratedHash<word32, NativeByteOrder, 32>, PanamaHash<B> >
00038 {
00039 public:
00040 CRYPTOPP_CONSTANT(DIGESTSIZE = 32)
00041 PanamaHash() {Panama<B>::Reset();}
00042 unsigned int DigestSize() const {return DIGESTSIZE;}
00043 void TruncatedFinal(byte *hash, size_t size);
00044 static const char * StaticAlgorithmName() {return B::ToEnum() == BIG_ENDIAN_ORDER ? "Panama-BE" : "Panama-LE";}
00045
00046 protected:
00047 void Init() {Panama<B>::Reset();}
00048 void HashEndianCorrectedBlock(const word32 *data) {this->Iterate(1, data);}
00049 size_t HashMultipleBlocks(const word32 *input, size_t length);
00050 word32* StateBuf() {return NULL;}
00051 };
00052 }
00053
00054
00055 template <class T_Hash, class T_Info = T_Hash>
00056 class HermeticHashFunctionMAC : public AlgorithmImpl<SimpleKeyingInterfaceImpl<TwoBases<MessageAuthenticationCode, VariableKeyLength<32, 0, INT_MAX> > >, T_Info>
00057 {
00058 public:
00059 void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs ¶ms)
00060 {
00061 CRYPTOPP_UNUSED(params);
00062
00063 m_key.Assign(key, length);
00064 Restart();
00065 }
00066
00067 void Restart()
00068 {
00069 m_hash.Restart();
00070 m_keyed = false;
00071 }
00072
00073 void Update(const byte *input, size_t length)
00074 {
00075 if (!m_keyed)
00076 KeyHash();
00077 m_hash.Update(input, length);
00078 }
00079
00080 void TruncatedFinal(byte *digest, size_t digestSize)
00081 {
00082 if (!m_keyed)
00083 KeyHash();
00084 m_hash.TruncatedFinal(digest, digestSize);
00085 m_keyed = false;
00086 }
00087
00088 unsigned int DigestSize() const
00089 {return m_hash.DigestSize();}
00090 unsigned int BlockSize() const
00091 {return m_hash.BlockSize();}
00092 unsigned int OptimalBlockSize() const
00093 {return m_hash.OptimalBlockSize();}
00094 unsigned int OptimalDataAlignment() const
00095 {return m_hash.OptimalDataAlignment();}
00096
00097 protected:
00098 void KeyHash()
00099 {
00100 m_hash.Update(m_key, m_key.size());
00101 m_keyed = true;
00102 }
00103
00104 T_Hash m_hash;
00105 bool m_keyed;
00106 SecByteBlock m_key;
00107 };
00108
00109 namespace Weak {
00110
00111 template <class B = LittleEndian>
00112 class PanamaMAC : public HermeticHashFunctionMAC<PanamaHash<B> >
00113 {
00114 public:
00115 PanamaMAC() {}
00116 PanamaMAC(const byte *key, unsigned int length)
00117 {this->SetKey(key, length);}
00118 };
00119 }
00120
00121
00122 template <class B>
00123 struct PanamaCipherInfo : public FixedKeyLength<32, SimpleKeyingInterface::UNIQUE_IV, 32>
00124 {
00125 static const char * StaticAlgorithmName() {return B::ToEnum() == BIG_ENDIAN_ORDER ? "Panama-BE" : "Panama-LE";}
00126 };
00127
00128
00129 template <class B>
00130 class PanamaCipherPolicy : public AdditiveCipherConcretePolicy<word32, 8>,
00131 public PanamaCipherInfo<B>,
00132 protected Panama<B>
00133 {
00134 protected:
00135 void CipherSetKey(const NameValuePairs ¶ms, const byte *key, size_t length);
00136 void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount);
00137 bool CipherIsRandomAccess() const {return false;}
00138 void CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length);
00139 unsigned int GetAlignment() const;
00140
00141 FixedSizeSecBlock<word32, 8> m_key;
00142 };
00143
00144
00145 template <class B = LittleEndian>
00146 struct PanamaCipher : public PanamaCipherInfo<B>, public SymmetricCipherDocumentation
00147 {
00148 typedef SymmetricCipherFinal<ConcretePolicyHolder<PanamaCipherPolicy<B>, AdditiveCipherTemplate<> >, PanamaCipherInfo<B> > Encryption;
00149 typedef Encryption Decryption;
00150 };
00151
00152 NAMESPACE_END
00153
00154 #endif