Crypto++

- Main Page
- Namespaces
- Classes
- Files

- File List
- 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, size_t length, bool messageEnd);
    00022     lword InputBuffered(word32 channelId) const;
    00023
    00024     void IsolatedInitialize(const NameValuePairs &parameters=g_nullNameValuePairs);
    00025     size_t ChannelPut2(const std::string &channel, const byte *begin, size_t 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     typedef std::map<word32, unsigned int> InputChannelMap;
    00044     InputChannelMap m_inputChannelMap;
    00045     InputChannelMap::iterator m_lastMapPosition;
    00046     std::vector<MessageQueue> m_inputQueues;
    00047     std::vector<word32> m_inputChannelIds, m_outputChannelIds, m_outputToInput;
    00048     std::vector<std::string> m_outputChannelIdStrings;
    00049     std::vector<ByteQueue> m_outputQueues;
    00050     int m_threshold;
    00051     unsigned int m_channelsReady, m_channelsFinished;
    00052     std::vector<SecBlock<word32> > m_v;
    00053     SecBlock<word32> m_u, m_w, m_y;
    00054 };
    00055
    00056 /// a variant of Shamir's Secret Sharing Algorithm
    00057 class SecretSharing : public CustomFlushPropagation<Filter>
    00058 {
    00059 public:
    00060     SecretSharing(RandomNumberGenerator &rng, int threshold, int nShares, BufferedTransformation *attachment=NULL, bool addPadding=true)
    00061         : m_rng(rng), m_ida(new OutputProxy(*this, true))
    00062     {
    00063         Detach(attachment);
    00064         IsolatedInitialize(MakeParameters("RecoveryThreshold", threshold)("NumberOfShares", nShares)("AddPadding", addPadding));
    00065     }
    00066
    00067     void IsolatedInitialize(const NameValuePairs &parameters=g_nullNameValuePairs);
    00068     size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking);
    00069     bool Flush(bool hardFlush, int propagation=-1, bool blocking=true) {return m_ida.Flush(hardFlush, propagation, blocking);}
    00070
    00071 protected:
    00072     RandomNumberGenerator &m_rng;
    00073     RawIDA m_ida;
    00074     bool m_pad;
    00075 };
    00076
    00077 /// a variant of Shamir's Secret Sharing Algorithm
    00078 class SecretRecovery : public RawIDA
    00079 {
    00080 public:
    00081     SecretRecovery(int threshold, BufferedTransformation *attachment=NULL, bool removePadding=true)
    00082         : RawIDA(attachment)
    00083         {IsolatedInitialize(MakeParameters("RecoveryThreshold", threshold)("RemovePadding", removePadding));}
    00084
    00085     void IsolatedInitialize(const NameValuePairs &parameters=g_nullNameValuePairs);
    00086
    00087 protected:
    00088     void FlushOutputQueues();
    00089     void OutputMessageEnds();
    00090
    00091     bool m_pad;
    00092 };
    00093
    00094 /// a variant of Rabin's Information Dispersal Algorithm
    00095 class InformationDispersal : public CustomFlushPropagation<Filter>
    00096 {
    00097 public:
    00098     InformationDispersal(int threshold, int nShares, BufferedTransformation *attachment=NULL, bool addPadding=true)
    00099         : m_ida(new OutputProxy(*this, true))
    00100     {
    00101         Detach(attachment);
    00102         IsolatedInitialize(MakeParameters("RecoveryThreshold", threshold)("NumberOfShares", nShares)("AddPadding", addPadding));
    00103     }
    00104
    00105     void IsolatedInitialize(const NameValuePairs &parameters=g_nullNameValuePairs);
    00106     size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking);
    00107     bool Flush(bool hardFlush, int propagation=-1, bool blocking=true) {return m_ida.Flush(hardFlush, propagation, blocking);}
    00108
    00109 protected:
    00110     RawIDA m_ida;
    00111     bool m_pad;
    00112     unsigned int m_nextChannel;
    00113 };
    00114
    00115 /// a variant of Rabin's Information Dispersal Algorithm
    00116 class InformationRecovery : public RawIDA
    00117 {
    00118 public:
    00119     InformationRecovery(int threshold, BufferedTransformation *attachment=NULL, bool removePadding=true)
    00120         : RawIDA(attachment)
    00121         {IsolatedInitialize(MakeParameters("RecoveryThreshold", threshold)("RemovePadding", removePadding));}
    00122
    00123     void IsolatedInitialize(const NameValuePairs &parameters=g_nullNameValuePairs);
    00124
    00125 protected:
    00126     void FlushOutputQueues();
    00127     void OutputMessageEnds();
    00128
    00129     bool m_pad;
    00130     ByteQueue m_queue;
    00131 };
    00132
    00133 class PaddingRemover : public Unflushable<Filter>
    00134 {
    00135 public:
    00136     PaddingRemover(BufferedTransformation *attachment=NULL)
    00137         : m_possiblePadding(false) {Detach(attachment);}
    00138
    00139     void IsolatedInitialize(const NameValuePairs &parameters) {m_possiblePadding = false;}
    00140     size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking);
    00141
    00142     // GetPossiblePadding() == false at the end of a message indicates incorrect padding
    00143     bool GetPossiblePadding() const {return m_possiblePadding;}
    00144
    00145 private:
    00146     bool m_possiblePadding;
    00147     lword m_zeroCount;
    00148 };
    00149
    00150 NAMESPACE_END
    00151
    00152 #endif