actions/itgmania212121
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Applied GCC 3.4 patch from Crypto++ website, with slight workaround to avoid adding fips140.h. Now compiles on Linux with GCC 3.4.

Browse Source
This commit is contained in:
Ben Anderson
2004-10-23 00:57:40 +00:00
parent f9bcb3c78b
commit 715099fc5b
13 changed files with 121 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
stepmania/src/crypto51/algebra.cpp
+1 -1
View File
@@ -54,7 +54,7 @@ template <class T> const T& AbstractEuclideanDomain<T>::Gcd(const Element &a, co
Element g[3]={b, a}; Element g[3]={b, a};
unsigned int i0=0, i1=1, i2=2; unsigned int i0=0, i1=1, i2=2;
while (!Equal(g[i1], Identity())) while (!Equal(g[i1], this->Identity()))
{ {
g[i2] = Mod(g[i0], g[i1]); g[i2] = Mod(g[i0], g[i1]);
unsigned int t = i0; i0 = i1; i1 = i2; i2 = t; unsigned int t = i0; i0 = i1; i1 = i2; i2 = t;
stepmania/src/crypto51/asn.h
+2 -2
View File
@@ -221,8 +221,8 @@ public:
} }
void DEREncode(BufferedTransformation &out) void DEREncode(BufferedTransformation &out)
{ {
if (get() != NULL) if (this->get() != NULL)
get()->DEREncode(out); this->get()->DEREncode(out);
} }
}; };
stepmania/src/crypto51/files.cpp
+2 -1
View File
@@ -106,7 +106,8 @@ unsigned int FileStore::CopyRangeTo2(BufferedTransformation &target, unsigned lo
streampos endPosition = m_stream->seekg(0, ios::end).tellg(); streampos endPosition = m_stream->seekg(0, ios::end).tellg();
streampos newPosition = current + (streamoff)begin; streampos newPosition = current + (streamoff)begin;
if (newPosition >= endPosition) // if (newPosition >= endPosition)
if (std::streamoff(newPosition) >= std::streamoff(endPosition))
{ {
m_stream->seekg(current); m_stream->seekg(current);
return 0; // don't try to seek beyond the end of file return 0; // don't try to seek beyond the end of file
stepmania/src/crypto51/iterhash.h
+12 -12
View File
@@ -82,7 +82,7 @@ class IteratedHashWithStaticTransform : public IteratedHash<T, B, S>
{ {
protected: protected:
IteratedHashWithStaticTransform(unsigned int digestSize) : IteratedHash<T, B, S>(digestSize) {} IteratedHashWithStaticTransform(unsigned int digestSize) : IteratedHash<T, B, S>(digestSize) {}
void vTransform(const T *data) {M::Transform(m_digest, data);} void vTransform(const T *data) {M::Transform(this->m_digest, data);}
std::string AlgorithmName() const {return M::StaticAlgorithmName();} std::string AlgorithmName() const {return M::StaticAlgorithmName();}
}; };
@@ -90,19 +90,19 @@ protected:
template <class T, class B, class BASE> void IteratedHashBase2<T, B, BASE>::TruncatedFinal(byte *hash, unsigned int size) template <class T, class B, class BASE> void IteratedHashBase2<T, B, BASE>::TruncatedFinal(byte *hash, unsigned int size)
{ {
ThrowIfInvalidTruncatedSize(size); this->ThrowIfInvalidTruncatedSize(size);
PadLastBlock(BlockSize() - 2*sizeof(HashWordType)); PadLastBlock(this->BlockSize() - 2*sizeof(HashWordType));
CorrectEndianess(m_data, m_data, BlockSize() - 2*sizeof(HashWordType)); CorrectEndianess(this->m_data, this->m_data, this->BlockSize() - 2*sizeof(HashWordType));
m_data[m_data.size()-2] = B::ToEnum() ? GetBitCountHi() : GetBitCountLo(); this->m_data[this->m_data.size()-2] = B::ToEnum() ? this->GetBitCountHi() : this->GetBitCountLo();
m_data[m_data.size()-1] = B::ToEnum() ? GetBitCountLo() : GetBitCountHi(); this->m_data[this->m_data.size()-1] = B::ToEnum() ? this->GetBitCountLo() : this->GetBitCountHi();
vTransform(m_data); vTransform(this->m_data);
CorrectEndianess(m_digest, m_digest, DigestSize()); CorrectEndianess(this->m_digest, this->m_digest, this->DigestSize());
memcpy(hash, m_digest, size); memcpy(hash, this->m_digest, size);
Restart(); // reinit for next use this->Restart(); // reinit for next use
} }
template <class T, class B, class BASE> void IteratedHashBase2<T, B, BASE>::HashBlock(const HashWordType *input) template <class T, class B, class BASE> void IteratedHashBase2<T, B, BASE>::HashBlock(const HashWordType *input)
@@ -111,8 +111,8 @@ template <class T, class B, class BASE> void IteratedHashBase2<T, B, BASE>::Hash
vTransform(input); vTransform(input);
else else
{ {
ByteReverse(m_data.begin(), input, BlockSize()); ByteReverse(this->m_data.begin(), input, this->BlockSize());
vTransform(m_data); vTransform(this->m_data);
} }
} }
stepmania/src/crypto51/mdc.h
+7 -7
View File
@@ -30,22 +30,22 @@ class MDC : public MDC_Info<T>
void UncheckedSetKey(CipherDir direction, const byte *userKey, unsigned int length) void UncheckedSetKey(CipherDir direction, const byte *userKey, unsigned int length)
{ {
assert(direction == ENCRYPTION); assert(direction == ENCRYPTION);
AssertValidKeyLength(length); this->AssertValidKeyLength(length);
memcpy(Key(), userKey, KEYLENGTH); memcpy(Key(), userKey, this->KEYLENGTH);
T::CorrectEndianess(Key(), Key(), KEYLENGTH); T::CorrectEndianess(Key(), Key(), this->KEYLENGTH);
} }
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
{ {
T::CorrectEndianess(Buffer(), (HashWordType *)inBlock, BLOCKSIZE); T::CorrectEndianess(Buffer(), (HashWordType *)inBlock, this->BLOCKSIZE);
T::Transform(Buffer(), Key()); T::Transform(Buffer(), Key());
if (xorBlock) if (xorBlock)
{ {
T::CorrectEndianess(Buffer(), Buffer(), BLOCKSIZE); T::CorrectEndianess(Buffer(), Buffer(), this->BLOCKSIZE);
xorbuf(outBlock, xorBlock, m_buffer, BLOCKSIZE); xorbuf(outBlock, xorBlock, m_buffer, this->BLOCKSIZE);
} }
else else
T::CorrectEndianess((HashWordType *)outBlock, Buffer(), BLOCKSIZE); T::CorrectEndianess((HashWordType *)outBlock, Buffer(), this->BLOCKSIZE);
} }
bool IsPermutation() const {return false;} bool IsPermutation() const {return false;}
stepmania/src/crypto51/modes.h
+6 -6
View File
@@ -188,18 +188,18 @@ class CipherModeFinalTemplate_CipherHolder : public ObjectHolder<CIPHER>, public
public: public:
CipherModeFinalTemplate_CipherHolder() CipherModeFinalTemplate_CipherHolder()
{ {
m_cipher = &m_object; this->m_cipher = &this->m_object;
ResizeBuffers(); this->ResizeBuffers();
} }
CipherModeFinalTemplate_CipherHolder(const byte *key, unsigned int length) CipherModeFinalTemplate_CipherHolder(const byte *key, unsigned int length)
{ {
m_cipher = &m_object; this->m_cipher = &this->m_object;
SetKey(key, length); this->SetKey(key, length);
} }
CipherModeFinalTemplate_CipherHolder(const byte *key, unsigned int length, const byte *iv, int feedbackSize = 0) CipherModeFinalTemplate_CipherHolder(const byte *key, unsigned int length, const byte *iv, int feedbackSize = 0)
{ {
m_cipher = &m_object; this->m_cipher = &this->m_object;
SetKey(key, length, MakeParameters("IV", iv)("FeedbackSize", feedbackSize)); this->SetKey(key, length, MakeParameters("IV", iv)("FeedbackSize", feedbackSize));
} }
}; };
stepmania/src/crypto51/osrng.h
+8 -1
View File
@@ -8,6 +8,9 @@
#include "randpool.h" #include "randpool.h"
#include "rng.h" #include "rng.h"
//added
#include "cryptlib.h"
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
//! Exception class for Operating-System Random Number Generator. //! Exception class for Operating-System Random Number Generator.
@@ -147,7 +150,11 @@ byte AutoSeededX917RNG<BLOCK_CIPHER>::GenerateByte()
if (m_counter == m_lastBlock.size()) if (m_counter == m_lastBlock.size())
{ {
if (!m_isDifferent) if (!m_isDifferent)
throw SelfTestFailure("AutoSeededX917RNG: Continuous random number generator test failed."); // This originally threw a SelfTestFailure, which is
// only available from fips140.h, which I figure
// probably was excluded for a good reason. Here's
// my workaround.
throw Exception(Exception::OTHER_ERROR, "AutoSeededX917RNG: Continuous random number generator test failed.");
m_counter = 0; m_counter = 0;
m_isDifferent = false; m_isDifferent = false;
} }
stepmania/src/crypto51/pubkey.h
+48 -42
View File
@@ -37,6 +37,8 @@
#include "argnames.h" #include "argnames.h"
#include <memory> #include <memory>
#include "modarith.h"
// VC60 workaround: this macro is defined in shlobj.h and conflicts with a template parameter used in this file // VC60 workaround: this macro is defined in shlobj.h and conflicts with a template parameter used in this file
#undef INTERFACE #undef INTERFACE
@@ -140,12 +142,12 @@ template <class INTERFACE, class BASE>
class TF_CryptoSystemBase : public INTERFACE, protected BASE class TF_CryptoSystemBase : public INTERFACE, protected BASE
{ {
public: public:
unsigned int FixedMaxPlaintextLength() const {return GetMessageEncodingInterface().MaxUnpaddedLength(PaddedBlockBitLength());} unsigned int FixedMaxPlaintextLength() const {return this->GetMessageEncodingInterface().MaxUnpaddedLength(PaddedBlockBitLength());}
unsigned int FixedCiphertextLength() const {return GetTrapdoorFunctionBounds().MaxImage().ByteCount();} unsigned int FixedCiphertextLength() const {return this->GetTrapdoorFunctionBounds().MaxImage().ByteCount();}
protected: protected:
unsigned int PaddedBlockByteLength() const {return BitsToBytes(PaddedBlockBitLength());} unsigned int PaddedBlockByteLength() const {return BitsToBytes(PaddedBlockBitLength());}
unsigned int PaddedBlockBitLength() const {return GetTrapdoorFunctionBounds().PreimageBound().BitCount()-1;} unsigned int PaddedBlockBitLength() const {return this->GetTrapdoorFunctionBounds().PreimageBound().BitCount()-1;}
}; };
//! . //! .
@@ -286,7 +288,7 @@ template <class HASH_ALGORITHM>
class PK_MessageAccumulatorImpl : public PK_MessageAccumulatorBase, protected ObjectHolder<HASH_ALGORITHM> class PK_MessageAccumulatorImpl : public PK_MessageAccumulatorBase, protected ObjectHolder<HASH_ALGORITHM>
{ {
public: public:
HashTransformation & AccessHash() {return m_object;} HashTransformation & AccessHash() {return this->m_object;}
}; };
//! . //! .
@@ -295,22 +297,22 @@ class TF_SignatureSchemeBase : public INTERFACE, protected BASE
{ {
public: public:
unsigned int SignatureLength() const unsigned int SignatureLength() const
{return GetTrapdoorFunctionBounds().MaxPreimage().ByteCount();} {return this->GetTrapdoorFunctionBounds().MaxPreimage().ByteCount();}
unsigned int MaxRecoverableLength() const unsigned int MaxRecoverableLength() const
{return GetMessageEncodingInterface().MaxRecoverableLength(MessageRepresentativeBitLength(), GetHashIdentifier().second, GetDigestSize());} {return this->GetMessageEncodingInterface().MaxRecoverableLength(MessageRepresentativeBitLength(), GetHashIdentifier().second, GetDigestSize());}
unsigned int MaxRecoverableLengthFromSignatureLength(unsigned int signatureLength) const unsigned int MaxRecoverableLengthFromSignatureLength(unsigned int signatureLength) const
{return MaxRecoverableLength();} {return this->MaxRecoverableLength();}
bool IsProbabilistic() const bool IsProbabilistic() const
{return GetTrapdoorFunctionInterface().IsRandomized() || GetMessageEncodingInterface().IsProbabilistic();} {return this->GetTrapdoorFunctionInterface().IsRandomized() || this->GetMessageEncodingInterface().IsProbabilistic();}
bool AllowNonrecoverablePart() const bool AllowNonrecoverablePart() const
{return GetMessageEncodingInterface().AllowNonrecoverablePart();} {return this->GetMessageEncodingInterface().AllowNonrecoverablePart();}
bool RecoverablePartFirst() const bool RecoverablePartFirst() const
{return GetMessageEncodingInterface().RecoverablePartFirst();} {return this->GetMessageEncodingInterface().RecoverablePartFirst();}
protected: protected:
unsigned int MessageRepresentativeLength() const {return BitsToBytes(MessageRepresentativeBitLength());} unsigned int MessageRepresentativeLength() const {return BitsToBytes(MessageRepresentativeBitLength());}
unsigned int MessageRepresentativeBitLength() const {return GetTrapdoorFunctionBounds().ImageBound().BitCount()-1;} unsigned int MessageRepresentativeBitLength() const {return this->GetTrapdoorFunctionBounds().ImageBound().BitCount()-1;}
virtual HashIdentifier GetHashIdentifier() const =0; virtual HashIdentifier GetHashIdentifier() const =0;
virtual unsigned int GetDigestSize() const =0; virtual unsigned int GetDigestSize() const =0;
}; };
@@ -399,8 +401,12 @@ protected:
// for signature scheme // for signature scheme
HashIdentifier GetHashIdentifier() const HashIdentifier GetHashIdentifier() const
{ {
typedef CPP_TYPENAME SchemeOptions::MessageEncodingMethod::HashIdentifierLookup::HashIdentifierLookup2<CPP_TYPENAME SchemeOptions::HashFunction> L; typedef CPP_TYPENAME SchemeOptions::MessageEncodingMethod::HashIdentifierLookup::template HashIdentifierLookup2<CPP_TYPENAME SchemeOptions::HashFunction> L;
return L::Lookup(); return L::Lookup();
/* typedef typename SchemeOptions::MessageEncodingMethod MEnMeth;
typedef typename MEnMeth::HashIdentifierLookup HLookup;
typedef typename SchemeOptions::HashFunction HashF;
return HLookup::template HashIdentifierLookup2<HashF>::Lookup(); */
} }
unsigned int GetDigestSize() const unsigned int GetDigestSize() const
{ {
@@ -444,7 +450,7 @@ template <class BASE, class SCHEME_OPTIONS>
class TF_PublicObjectImpl : public TF_ObjectImpl<BASE, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>, public PublicKeyCopier<SCHEME_OPTIONS> class TF_PublicObjectImpl : public TF_ObjectImpl<BASE, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>, public PublicKeyCopier<SCHEME_OPTIONS>
{ {
public: public:
void CopyKeyInto(typename SCHEME_OPTIONS::PublicKey &key) const {key = GetKey();} void CopyKeyInto(typename SCHEME_OPTIONS::PublicKey &key) const {key = this->GetKey();}
}; };
//! . //! .
@@ -452,8 +458,8 @@ template <class BASE, class SCHEME_OPTIONS>
class TF_PrivateObjectImpl : public TF_ObjectImpl<BASE, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>, public PrivateKeyCopier<SCHEME_OPTIONS> class TF_PrivateObjectImpl : public TF_ObjectImpl<BASE, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>, public PrivateKeyCopier<SCHEME_OPTIONS>
{ {
public: public:
void CopyKeyInto(typename SCHEME_OPTIONS::PrivateKey &key) const {key = GetKey();} void CopyKeyInto(typename SCHEME_OPTIONS::PrivateKey &key) const {key = this->GetKey();}
void CopyKeyInto(typename SCHEME_OPTIONS::PublicKey &key) const {key = GetKey();} void CopyKeyInto(typename SCHEME_OPTIONS::PublicKey &key) const {key = this->GetKey();}
}; };
//! . //! .
@@ -542,107 +548,107 @@ public:
PK_FinalTemplate() {} PK_FinalTemplate() {}
PK_FinalTemplate(const Integer &v1) PK_FinalTemplate(const Integer &v1)
{AccessKey().Initialize(v1);} {this->AccessKey().Initialize(v1);}
PK_FinalTemplate(const typename BASE::KeyClass &key) {AccessKey().operator=(key);} PK_FinalTemplate(const typename BASE::KeyClass &key) {this->AccessKey().operator=(key);}
template <class T> template <class T>
PK_FinalTemplate(const PublicKeyCopier<T> &key) PK_FinalTemplate(const PublicKeyCopier<T> &key)
{key.CopyKeyInto(AccessKey());} {key.CopyKeyInto(this->AccessKey());}
template <class T> template <class T>
PK_FinalTemplate(const PrivateKeyCopier<T> &key) PK_FinalTemplate(const PrivateKeyCopier<T> &key)
{key.CopyKeyInto(AccessKey());} {key.CopyKeyInto(this->AccessKey());}
PK_FinalTemplate(BufferedTransformation &bt) {AccessKey().BERDecode(bt);} PK_FinalTemplate(BufferedTransformation &bt) {this->AccessKey().BERDecode(bt);}
#if (defined(_MSC_VER) && _MSC_VER < 1300) #if (defined(_MSC_VER) && _MSC_VER < 1300)
template <class T1, class T2> template <class T1, class T2>
PK_FinalTemplate(T1 &v1, T2 &v2) PK_FinalTemplate(T1 &v1, T2 &v2)
{AccessKey().Initialize(v1, v2);} {this->AccessKey().Initialize(v1, v2);}
template <class T1, class T2, class T3> template <class T1, class T2, class T3>
PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3) PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3)
{AccessKey().Initialize(v1, v2, v3);} {this->AccessKey().Initialize(v1, v2, v3);}
template <class T1, class T2, class T3, class T4> template <class T1, class T2, class T3, class T4>
PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4) PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4)
{AccessKey().Initialize(v1, v2, v3, v4);} {this->AccessKey().Initialize(v1, v2, v3, v4);}
template <class T1, class T2, class T3, class T4, class T5> template <class T1, class T2, class T3, class T4, class T5>
PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5) PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5)
{AccessKey().Initialize(v1, v2, v3, v4, v5);} {this->AccessKey().Initialize(v1, v2, v3, v4, v5);}
template <class T1, class T2, class T3, class T4, class T5, class T6> template <class T1, class T2, class T3, class T4, class T5, class T6>
PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6) PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6)
{AccessKey().Initialize(v1, v2, v3, v4, v5, v6);} {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7> template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7) PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7)
{AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);} {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8> template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7, T8 &v8) PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7, T8 &v8)
{AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);} {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}
#else #else
template <class T1, class T2> template <class T1, class T2>
PK_FinalTemplate(const T1 &v1, const T2 &v2) PK_FinalTemplate(const T1 &v1, const T2 &v2)
{AccessKey().Initialize(v1, v2);} {this->AccessKey().Initialize(v1, v2);}
template <class T1, class T2, class T3> template <class T1, class T2, class T3>
PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3) PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3)
{AccessKey().Initialize(v1, v2, v3);} {this->AccessKey().Initialize(v1, v2, v3);}
template <class T1, class T2, class T3, class T4> template <class T1, class T2, class T3, class T4>
PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4) PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4)
{AccessKey().Initialize(v1, v2, v3, v4);} {this->AccessKey().Initialize(v1, v2, v3, v4);}
template <class T1, class T2, class T3, class T4, class T5> template <class T1, class T2, class T3, class T4, class T5>
PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5) PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5)
{AccessKey().Initialize(v1, v2, v3, v4, v5);} {this->AccessKey().Initialize(v1, v2, v3, v4, v5);}
template <class T1, class T2, class T3, class T4, class T5, class T6> template <class T1, class T2, class T3, class T4, class T5, class T6>
PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6) PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6)
{AccessKey().Initialize(v1, v2, v3, v4, v5, v6);} {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7> template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7) PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7)
{AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);} {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8> template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8) PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8)
{AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);} {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}
template <class T1, class T2> template <class T1, class T2>
PK_FinalTemplate(T1 &v1, const T2 &v2) PK_FinalTemplate(T1 &v1, const T2 &v2)
{AccessKey().Initialize(v1, v2);} {this->AccessKey().Initialize(v1, v2);}
template <class T1, class T2, class T3> template <class T1, class T2, class T3>
PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3) PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3)
{AccessKey().Initialize(v1, v2, v3);} {this->AccessKey().Initialize(v1, v2, v3);}
template <class T1, class T2, class T3, class T4> template <class T1, class T2, class T3, class T4>
PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4) PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4)
{AccessKey().Initialize(v1, v2, v3, v4);} {this->AccessKey().Initialize(v1, v2, v3, v4);}
template <class T1, class T2, class T3, class T4, class T5> template <class T1, class T2, class T3, class T4, class T5>
PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5) PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5)
{AccessKey().Initialize(v1, v2, v3, v4, v5);} {this->AccessKey().Initialize(v1, v2, v3, v4, v5);}
template <class T1, class T2, class T3, class T4, class T5, class T6> template <class T1, class T2, class T3, class T4, class T5, class T6>
PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6) PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6)
{AccessKey().Initialize(v1, v2, v3, v4, v5, v6);} {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7> template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7) PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7)
{AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);} {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8> template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8) PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8)
{AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);} {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}
#endif #endif
}; };
stepmania/src/crypto51/secblock.h
+9 -6
View File
@@ -188,7 +188,10 @@ template <class T, class A = AllocatorWithCleanup<T> >
class SecBlock class SecBlock
{ {
public: public:
explicit SecBlock(unsigned int size=0) //added
typedef T value_type;
explicit SecBlock(unsigned int size=0)
: m_size(size) {m_ptr = m_alloc.allocate(size, NULL);} : m_size(size) {m_ptr = m_alloc.allocate(size, NULL);}
SecBlock(const SecBlock<T, A> &t) SecBlock(const SecBlock<T, A> &t)
: m_size(t.m_size) {m_ptr = m_alloc.allocate(m_size, NULL); memcpy(m_ptr, t.m_ptr, m_size*sizeof(T));} : m_size(t.m_size) {m_ptr = m_alloc.allocate(m_size, NULL); memcpy(m_ptr, t.m_ptr, m_size*sizeof(T));}
@@ -205,26 +208,26 @@ public:
~SecBlock() ~SecBlock()
{m_alloc.deallocate(m_ptr, m_size);} {m_alloc.deallocate(m_ptr, m_size);}
#if defined(__GNUC__) || defined(__BCPLUSPLUS__) //#if defined(__GNUC__) || defined(__BCPLUSPLUS__)
operator const void *() const operator const void *() const
{return m_ptr;} {return m_ptr;}
operator void *() operator void *()
{return m_ptr;} {return m_ptr;}
#endif /*#endif
#if defined(__GNUC__) // reduce warnings #if defined(__GNUC__) // reduce warnings
operator const void *() operator const void *()
{return m_ptr;} {return m_ptr;}
#endif #endif
*/
operator const T *() const operator const T *() const
{return m_ptr;} {return m_ptr;}
operator T *() operator T *()
{return m_ptr;} {return m_ptr;}
#if defined(__GNUC__) // reduce warnings /*#if defined(__GNUC__) // reduce warnings
operator const T *() operator const T *()
{return m_ptr;} {return m_ptr;}
#endif #endif
*/
template <typename I> template <typename I>
T *operator +(I offset) T *operator +(I offset)
{return m_ptr+offset;} {return m_ptr+offset;}
stepmania/src/crypto51/seckey.h
+5 -5
View File
@@ -156,7 +156,7 @@ template <class INFO, class INTERFACE = BlockCipher>
class BlockCipherBaseTemplate : public AlgorithmImpl<SimpleKeyingInterfaceImpl<TwoBases<INFO, INTERFACE> > > class BlockCipherBaseTemplate : public AlgorithmImpl<SimpleKeyingInterfaceImpl<TwoBases<INFO, INTERFACE> > >
{ {
public: public:
unsigned int BlockSize() const {return BLOCKSIZE;} unsigned int BlockSize() const {return this->BLOCKSIZE;}
}; };
//! . //! .
@@ -166,11 +166,11 @@ class BlockCipherTemplate : public BASE
public: public:
BlockCipherTemplate() {} BlockCipherTemplate() {}
BlockCipherTemplate(const byte *key) BlockCipherTemplate(const byte *key)
{SetKey(key, DEFAULT_KEYLENGTH);} {SetKey(key, this->DEFAULT_KEYLENGTH);}
BlockCipherTemplate(const byte *key, unsigned int length) BlockCipherTemplate(const byte *key, unsigned int length)
{SetKey(key, length);} {SetKey(key, length);}
BlockCipherTemplate(const byte *key, unsigned int length, unsigned int rounds) BlockCipherTemplate(const byte *key, unsigned int length, unsigned int rounds)
{SetKeyWithRounds(key, length, rounds);} {this->SetKeyWithRounds(key, length, rounds);}
bool IsForwardTransformation() const {return DIR == ENCRYPTION;} bool IsForwardTransformation() const {return DIR == ENCRYPTION;}
@@ -194,11 +194,11 @@ class MessageAuthenticationCodeTemplate : public
public: public:
MessageAuthenticationCodeTemplate() {} MessageAuthenticationCodeTemplate() {}
MessageAuthenticationCodeTemplate(const byte *key) MessageAuthenticationCodeTemplate(const byte *key)
{SetKey(key, DEFAULT_KEYLENGTH);} {SetKey(key, this->DEFAULT_KEYLENGTH);}
MessageAuthenticationCodeTemplate(const byte *key, unsigned int length) MessageAuthenticationCodeTemplate(const byte *key, unsigned int length)
{SetKey(key, length);} {SetKey(key, length);}
std::string AlgorithmName() const {return StaticAlgorithmName();} std::string AlgorithmName() const {return this->StaticAlgorithmName();}
void SetKey(const byte *key, unsigned int length, const NameValuePairs &param = g_nullNameValuePairs) void SetKey(const byte *key, unsigned int length, const NameValuePairs &param = g_nullNameValuePairs)
{ {
stepmania/src/crypto51/simple.h
+3 -1
View File
@@ -58,6 +58,8 @@ template <class T>
class Unflushable : public T class Unflushable : public T
{ {
public: public:
using T::NULL_CHANNEL;
Unflushable() {} Unflushable() {}
Unflushable(BufferedTransformation *q) : T(q) {} Unflushable(BufferedTransformation *q) : T(q) {}
bool Flush(bool completeFlush, int propagation=-1, bool blocking=true) bool Flush(bool completeFlush, int propagation=-1, bool blocking=true)
@@ -70,7 +72,7 @@ public:
throw CannotFlush("Unflushable<T>: this object has buffered input that cannot be flushed"); throw CannotFlush("Unflushable<T>: this object has buffered input that cannot be flushed");
else else
{ {
BufferedTransformation *attached = AttachedTransformation(); BufferedTransformation *attached = this->AttachedTransformation();
return attached && propagation ? attached->ChannelFlush(channel, hardFlush, propagation-1, blocking) : false; return attached && propagation ? attached->ChannelFlush(channel, hardFlush, propagation-1, blocking) : false;
} }
} }
stepmania/src/crypto51/strciphr.cpp
+6 -6
View File
@@ -8,7 +8,7 @@ NAMESPACE_BEGIN(CryptoPP)
template <class S> template <class S>
byte AdditiveCipherTemplate<S>::GenerateByte() byte AdditiveCipherTemplate<S>::GenerateByte()
{ {
PolicyInterface &policy = AccessPolicy(); PolicyInterface &policy = this->AccessPolicy();
if (m_leftOver == 0) if (m_leftOver == 0)
{ {
@@ -37,7 +37,7 @@ inline void AdditiveCipherTemplate<S>::ProcessData(byte *outString, const byte *
assert(m_leftOver == 0); assert(m_leftOver == 0);
PolicyInterface &policy = AccessPolicy(); PolicyInterface &policy = this->AccessPolicy();
unsigned int bytesPerIteration = policy.GetBytesPerIteration(); unsigned int bytesPerIteration = policy.GetBytesPerIteration();
unsigned int alignment = policy.GetAlignment(); unsigned int alignment = policy.GetAlignment();
@@ -81,7 +81,7 @@ inline void AdditiveCipherTemplate<S>::ProcessData(byte *outString, const byte *
template <class S> template <class S>
void AdditiveCipherTemplate<S>::Resynchronize(const byte *iv) void AdditiveCipherTemplate<S>::Resynchronize(const byte *iv)
{ {
PolicyInterface &policy = AccessPolicy(); PolicyInterface &policy = this->AccessPolicy();
m_leftOver = 0; m_leftOver = 0;
m_buffer.New(GetBufferByteSize(policy)); m_buffer.New(GetBufferByteSize(policy));
policy.CipherResynchronize(m_buffer, iv); policy.CipherResynchronize(m_buffer, iv);
@@ -90,7 +90,7 @@ void AdditiveCipherTemplate<S>::Resynchronize(const byte *iv)
template <class BASE> template <class BASE>
void AdditiveCipherTemplate<BASE>::Seek(dword position) void AdditiveCipherTemplate<BASE>::Seek(dword position)
{ {
PolicyInterface &policy = AccessPolicy(); PolicyInterface &policy = this->AccessPolicy();
unsigned int bytesPerIteration = policy.GetBytesPerIteration(); unsigned int bytesPerIteration = policy.GetBytesPerIteration();
policy.SeekToIteration(position / bytesPerIteration); policy.SeekToIteration(position / bytesPerIteration);
@@ -108,7 +108,7 @@ void AdditiveCipherTemplate<BASE>::Seek(dword position)
template <class BASE> template <class BASE>
void CFB_CipherTemplate<BASE>::Resynchronize(const byte *iv) void CFB_CipherTemplate<BASE>::Resynchronize(const byte *iv)
{ {
PolicyInterface &policy = AccessPolicy(); PolicyInterface &policy = this->AccessPolicy();
policy.CipherResynchronize(iv); policy.CipherResynchronize(iv);
m_leftOver = policy.GetBytesPerIteration(); m_leftOver = policy.GetBytesPerIteration();
} }
@@ -116,7 +116,7 @@ void CFB_CipherTemplate<BASE>::Resynchronize(const byte *iv)
template <class BASE> template <class BASE>
void CFB_CipherTemplate<BASE>::ProcessData(byte *outString, const byte *inString, unsigned int length) void CFB_CipherTemplate<BASE>::ProcessData(byte *outString, const byte *inString, unsigned int length)
{ {
PolicyInterface &policy = AccessPolicy(); PolicyInterface &policy = this->AccessPolicy();
unsigned int bytesPerIteration = policy.GetBytesPerIteration(); unsigned int bytesPerIteration = policy.GetBytesPerIteration();
unsigned int alignment = policy.GetAlignment(); unsigned int alignment = policy.GetAlignment();
byte *reg = policy.GetRegisterBegin(); byte *reg = policy.GetRegisterBegin();
stepmania/src/crypto51/strciphr.h
+12 -12
View File
@@ -123,12 +123,12 @@ public:
byte GenerateByte(); byte GenerateByte();
void ProcessData(byte *outString, const byte *inString, unsigned int length); void ProcessData(byte *outString, const byte *inString, unsigned int length);
void Resynchronize(const byte *iv); void Resynchronize(const byte *iv);
unsigned int OptimalBlockSize() const {return GetPolicy().GetBytesPerIteration();} unsigned int OptimalBlockSize() const {return this->GetPolicy().GetBytesPerIteration();}
unsigned int GetOptimalNextBlockSize() const {return m_leftOver;} unsigned int GetOptimalNextBlockSize() const {return m_leftOver;}
unsigned int OptimalDataAlignment() const {return GetPolicy().GetAlignment();} unsigned int OptimalDataAlignment() const {return this->GetPolicy().GetAlignment();}
bool IsSelfInverting() const {return true;} bool IsSelfInverting() const {return true;}
bool IsForwardTransformation() const {return true;} bool IsForwardTransformation() const {return true;}
bool IsRandomAccess() const {return GetPolicy().IsRandomAccess();} bool IsRandomAccess() const {return this->GetPolicy().IsRandomAccess();}
void Seek(dword position); void Seek(dword position);
typedef typename BASE::PolicyInterface PolicyInterface; typedef typename BASE::PolicyInterface PolicyInterface;
@@ -165,7 +165,7 @@ struct CFB_CipherConcretePolicy : public BASE
unsigned int GetAlignment() const {return sizeof(WordType);} unsigned int GetAlignment() const {return sizeof(WordType);}
unsigned int GetBytesPerIteration() const {return sizeof(WordType) * W;} unsigned int GetBytesPerIteration() const {return sizeof(WordType) * W;}
bool CanIterate() const {return true;} bool CanIterate() const {return true;}
void TransformRegister() {Iterate(NULL, NULL, ENCRYPTION, 1);} void TransformRegister() {this->Iterate(NULL, NULL, ENCRYPTION, 1);}
template <class B> template <class B>
struct RegisterOutput struct RegisterOutput
@@ -215,9 +215,9 @@ class CFB_CipherTemplate : public BASE
public: public:
void ProcessData(byte *outString, const byte *inString, unsigned int length); void ProcessData(byte *outString, const byte *inString, unsigned int length);
void Resynchronize(const byte *iv); void Resynchronize(const byte *iv);
unsigned int OptimalBlockSize() const {return GetPolicy().GetBytesPerIteration();} unsigned int OptimalBlockSize() const {return this->GetPolicy().GetBytesPerIteration();}
unsigned int GetOptimalNextBlockSize() const {return m_leftOver;} unsigned int GetOptimalNextBlockSize() const {return m_leftOver;}
unsigned int OptimalDataAlignment() const {return GetPolicy().GetAlignment();} unsigned int OptimalDataAlignment() const {return this->GetPolicy().GetAlignment();}
bool IsRandomAccess() const {return false;} bool IsRandomAccess() const {return false;}
bool IsSelfInverting() const {return false;} bool IsSelfInverting() const {return false;}
@@ -251,16 +251,16 @@ class SymmetricCipherFinalTemplate : public AlgorithmImpl<SimpleKeyingInterfaceI
public: public:
SymmetricCipherFinalTemplate() {} SymmetricCipherFinalTemplate() {}
SymmetricCipherFinalTemplate(const byte *key) SymmetricCipherFinalTemplate(const byte *key)
{SetKey(key, DEFAULT_KEYLENGTH);} {SetKey(key, this->DEFAULT_KEYLENGTH);}
SymmetricCipherFinalTemplate(const byte *key, unsigned int length) SymmetricCipherFinalTemplate(const byte *key, unsigned int length)
{SetKey(key, length);} {SetKey(key, length);}
SymmetricCipherFinalTemplate(const byte *key, unsigned int length, const byte *iv) SymmetricCipherFinalTemplate(const byte *key, unsigned int length, const byte *iv)
{SetKey(key, length); Resynchronize(iv);} {SetKey(key, length); this->Resynchronize(iv);}
void SetKey(const byte *key, unsigned int length, const NameValuePairs &params = g_nullNameValuePairs) void SetKey(const byte *key, unsigned int length, const NameValuePairs &params = g_nullNameValuePairs)
{ {
ThrowIfInvalidKeyLength(length); this->ThrowIfInvalidKeyLength(length);
UncheckedSetKey(params, key, length); this->UncheckedSetKey(params, key, length);
} }
Clonable * Clone() const {return static_cast<SymmetricCipher *>(new SymmetricCipherFinalTemplate<BASE, INFO>(*this));} Clonable * Clone() const {return static_cast<SymmetricCipher *>(new SymmetricCipherFinalTemplate<BASE, INFO>(*this));}
@@ -269,7 +269,7 @@ public:
template <class S> template <class S>
void AdditiveCipherTemplate<S>::UncheckedSetKey(const NameValuePairs &params, const byte *key, unsigned int length) void AdditiveCipherTemplate<S>::UncheckedSetKey(const NameValuePairs &params, const byte *key, unsigned int length)
{ {
PolicyInterface &policy = AccessPolicy(); PolicyInterface &policy = this->AccessPolicy();
policy.CipherSetKey(params, key, length); policy.CipherSetKey(params, key, length);
m_buffer.New(GetBufferByteSize(policy)); m_buffer.New(GetBufferByteSize(policy));
m_leftOver = 0; m_leftOver = 0;
@@ -278,7 +278,7 @@ void AdditiveCipherTemplate<S>::UncheckedSetKey(const NameValuePairs &params, co
template <class BASE> template <class BASE>
void CFB_CipherTemplate<BASE>::UncheckedSetKey(const NameValuePairs &params, const byte *key, unsigned int length) void CFB_CipherTemplate<BASE>::UncheckedSetKey(const NameValuePairs &params, const byte *key, unsigned int length)
{ {
PolicyInterface &policy = AccessPolicy(); PolicyInterface &policy = this->AccessPolicy();
policy.CipherSetKey(params, key, length); policy.CipherSetKey(params, key, length);
m_leftOver = policy.GetBytesPerIteration(); m_leftOver = policy.GetBytesPerIteration();
} }