Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members

# ida.h

    00001 #ifndef CRYPTOPP_IDA_H
    00002 #define CRYPTOPP_IDA_H
    00003
    00004 #include "mqueue.h"
    00005 #include "filters.h"
    00006 #include "channels.h"
    00007 #include <map>
    00008 #include <vector>
    00009
    00010 NAMESPACE_BEGIN(CryptoPP)
    00011
    00012 /// base class for secret sharing and information dispersal
    00013 class RawIDA : public AutoSignaling<Unflushable<Multichannel<Filter> > >
    00014 {
    00015 public:
    00016         RawIDA(BufferedTransformation *attachment=NULL)
    00017                 {Detach(attachment);}
    00018
    00019         unsigned int GetThreshold() const {return m_threshold;}
    00020         void AddOutputChannel(word32 channelId);
    00021         void ChannelData(word32 channelId, const byte *inString, unsigned int length, bool messageEnd);
    00022         unsigned int InputBuffered(word32 channelId) const;
    00023
    00024         void IsolatedInitialize(const NameValuePairs &parameters=g_nullNameValuePairs);
    00025         unsigned int ChannelPut2(const std::string &channel, const byte *begin, unsigned int length, int messageEnd, bool blocking)
    00026         {
    00027                 if (!blocking)
    00028                         throw BlockingInputOnly("RawIDA");
    00029                 ChannelData(StringToWord<word32>(channel), begin, length, messageEnd != 0);
    00030                 return 0;
    00031         }
    00032
    00033 protected:
    00034         virtual void FlushOutputQueues();
    00035         virtual void OutputMessageEnds();
    00036
    00037         unsigned int InsertInputChannel(word32 channelId);
    00038         unsigned int LookupInputChannel(word32 channelId) const;
    00039         void ComputeV(unsigned int);
    00040         void PrepareInterpolation();
    00041         void ProcessInputQueues();
    00042
    00043         std::map<word32, unsigned int> m_inputChannelMap;
    00044         std::map<word32, unsigned int>::iterator m_lastMapPosition;
    00045         std::vector<MessageQueue> m_inputQueues;
    00046         std::vector<word32> m_inputChannelIds, m_outputChannelIds, m_outputToInput;
    00047         std::vector<std::string> m_outputChannelIdStrings;
    00048         std::vector<ByteQueue> m_outputQueues;
    00049         int m_threshold;
    00050         unsigned int m_channelsReady, m_channelsFinished;
    00051         std::vector<SecBlock<word32> > m_v;
    00052         SecBlock<word32> m_u, m_w, m_y;
    00053 };
    00054
    00055 /// a variant of Shamir's Secret Sharing Algorithm
    00056 class SecretSharing : public CustomFlushPropagation<Filter>
    00057 {
    00058 public:
    00059         SecretSharing(RandomNumberGenerator &rng, int threshold, int nShares, BufferedTransformation *attachment=NULL, bool addPadding=true)
    00060                 : m_rng(rng), m_ida(new OutputProxy(*this, true))
    00061         {
    00062                 Detach(attachment);
    00063                 IsolatedInitialize(MakeParameters("RecoveryThreshold", threshold)("NumberOfShares", nShares)("AddPadding", addPadding));
    00064         }
    00065
    00066         void IsolatedInitialize(const NameValuePairs &parameters=g_nullNameValuePairs);
    00067         unsigned int Put2(const byte *begin, unsigned int length, int messageEnd, bool blocking);
    00068         bool Flush(bool hardFlush, int propagation=-1, bool blocking=true) {return m_ida.Flush(hardFlush, propagation, blocking);}
    00069
    00070 protected:
    00071         RandomNumberGenerator &m_rng;
    00072         RawIDA m_ida;
    00073         bool m_pad;
    00074 };
    00075
    00076 /// a variant of Shamir's Secret Sharing Algorithm
    00077 class SecretRecovery : public RawIDA
    00078 {
    00079 public:
    00080         SecretRecovery(int threshold, BufferedTransformation *attachment=NULL, bool removePadding=true)
    00081                 : RawIDA(attachment)
    00082                 {IsolatedInitialize(MakeParameters("RecoveryThreshold", threshold)("RemovePadding", removePadding));}
    00083
    00084         void IsolatedInitialize(const NameValuePairs &parameters=g_nullNameValuePairs);
    00085
    00086 protected:
    00087         void FlushOutputQueues();
    00088         void OutputMessageEnds();
    00089
    00090         bool m_pad;
    00091 };
    00092
    00093 /// a variant of Rabin's Information Dispersal Algorithm
    00094 class InformationDispersal : public CustomFlushPropagation<Filter>
    00095 {
    00096 public:
    00097         InformationDispersal(int threshold, int nShares, BufferedTransformation *attachment=NULL, bool addPadding=true)
    00098                 : m_ida(new OutputProxy(*this, true))
    00099         {
    00100                 Detach(attachment);
    00101                 IsolatedInitialize(MakeParameters("RecoveryThreshold", threshold)("NumberOfShares", nShares)("AddPadding", addPadding));
    00102         }
    00103
    00104         void IsolatedInitialize(const NameValuePairs &parameters=g_nullNameValuePairs);
    00105         unsigned int Put2(const byte *begin, unsigned int length, int messageEnd, bool blocking);
    00106         bool Flush(bool hardFlush, int propagation=-1, bool blocking=true) {return m_ida.Flush(hardFlush, propagation, blocking);}
    00107
    00108 protected:
    00109         RawIDA m_ida;
    00110         bool m_pad;
    00111         unsigned int m_nextChannel;
    00112 };
    00113
    00114 /// a variant of Rabin's Information Dispersal Algorithm
    00115 class InformationRecovery : public RawIDA
    00116 {
    00117 public:
    00118         InformationRecovery(int threshold, BufferedTransformation *attachment=NULL, bool removePadding=true)
    00119                 : RawIDA(attachment)
    00120                 {IsolatedInitialize(MakeParameters("RecoveryThreshold", threshold)("RemovePadding", removePadding));}
    00121
    00122         void IsolatedInitialize(const NameValuePairs &parameters=g_nullNameValuePairs);
    00123
    00124 protected:
    00125         void FlushOutputQueues();
    00126         void OutputMessageEnds();
    00127
    00128         bool m_pad;
    00129         ByteQueue m_queue;
    00130 };
    00131
    00132 class PaddingRemover : public Unflushable<Filter>
    00133 {
    00134 public:
    00135         PaddingRemover(BufferedTransformation *attachment=NULL)
    00136                 : m_possiblePadding(false) {Detach(attachment);}
    00137
    00138         void IsolatedInitialize(const NameValuePairs &parameters) {m_possiblePadding = false;}
    00139         unsigned int Put2(const byte *begin, unsigned int length, int messageEnd, bool blocking);
    00140
    00141         // GetPossiblePadding() == false at the end of a message indicates incorrect padding
    00142         bool GetPossiblePadding() const {return m_possiblePadding;}
    00143
    00144 private:
    00145         bool m_possiblePadding;
    00146         unsigned long m_zeroCount;
    00147 };
    00148
    00149 NAMESPACE_END
    00150
    00151 #endif