aboutsummaryrefslogtreecommitdiff
path: root/gcc/testsuite/g++.old-deja/g++.mike/eh43.C
diff options
context:
space:
mode:
Diffstat (limited to 'gcc/testsuite/g++.old-deja/g++.mike/eh43.C')
-rw-r--r--gcc/testsuite/g++.old-deja/g++.mike/eh43.C741
1 files changed, 0 insertions, 741 deletions
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh43.C b/gcc/testsuite/g++.old-deja/g++.mike/eh43.C
deleted file mode 100644
index c5fbde939d0..00000000000
--- a/gcc/testsuite/g++.old-deja/g++.mike/eh43.C
+++ /dev/null
@@ -1,741 +0,0 @@
-// Build don't link:
-// Special g++ Options: -fexceptions
-
-// testcase to check obstack allocation for cleanups
-
-typedef unsigned char byte;
-typedef unsigned short word16;
-typedef unsigned long word32;
-typedef unsigned char boolean;
-enum {FALSE, TRUE};
-extern "C" {
-extern void __eprintf (const char *, const char *, unsigned, const char *);
-}
-extern "C" {
-typedef unsigned int size_t;
-extern void *memccpy(void *, const void *, int, size_t);
-extern void *memchr(const void *, int, size_t);
-extern void *memset(void *, int, size_t);
-}
-template <class T> struct SecBlock
-{
-public:
- SecBlock(unsigned int size)
- : size(size), ptr((new T [( size )]) ) {}
- ~SecBlock()
- {(memset(( ptr ), 0, ( size )*sizeof(*( ptr ))), delete [] ( ptr )) ;}
- operator T *() const
- {return ptr;}
- T *operator +(unsigned int offset)
- {return ptr+offset;}
- T& operator[](int index)
- {((void) (( index<size ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n", "misc.h" , 31 , "index<size" ), 0) )) ; return ptr[index];}
- const T& operator[](int index) const
- {((void) (( index<size ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n", "misc.h" , 33 , "index<size" ), 0) )) ; return ptr[index];}
- const unsigned int size;
- T *const ptr;
-};
-typedef SecBlock<byte> SecByteBlock;
-void xorbuf(byte *buf, const byte *mask, unsigned int count);
-void byteReverse(word16 *out, const word16 *in, unsigned int byteCount);
-void byteReverse(word32 *out, const word32 *in, unsigned int byteCount);
-inline word16 Invert(const word16 value)
-{
- return (value << 8) | (value >> 8);
-}
-inline word32 Invert(const word32 value)
-{
- word32 work = ((value & 0xFF00FF00L) >> 8) | ((value & 0x00FF00FFL) << 8);
- return (work << 16) | (work >> 16);
-}
-template <class T> inline T min (const T t1, const T t2)
-{
- return (t1 < t2 ? t1 : t2);
-}
-template <class T> inline T max (const T t1, const T t2)
-{
- return (t1 > t2 ? t1 : t2);
-}
-template <class T> inline void swap (T &a, T &b)
-{
- T temp = a;
- a = b;
- b = temp;
-}
-template <class T> inline T rotl(T x, unsigned int y)
-{
- return ((x<<y) | (x>>(sizeof(T)*8-y)));
-}
-template <class T> inline T rotr(T x, unsigned int y)
-{
- return ((x>>y) | (x<<(sizeof(T)*8-y)));
-}
-int BytePrecision(unsigned long);
-int BitPrecision(unsigned long);
-unsigned long Crop(unsigned long, int size);
-enum CipherDir {ENCRYPTION, DECRYPTION};
-class BlockTransformation
-{
-public:
- virtual ~BlockTransformation() {}
- virtual void ProcessBlock(byte *inoutBlock) =0;
- virtual void ProcessBlock(const byte *inBlock, byte *outBlock) =0;
- virtual unsigned int BlockSize() const =0;
-};
-class StreamCipher
-{
-public:
- virtual ~StreamCipher() {}
- virtual byte ProcessByte(byte input) =0;
- virtual void ProcessString(byte *outString, const byte *inString, unsigned int length);
- virtual void ProcessString(byte *inoutString, unsigned int length);
-};
-class RandomAccessStreamCipher : public StreamCipher
-{
-public:
- virtual ~RandomAccessStreamCipher() {}
- virtual void Seek(unsigned long position) =0;
-};
-class RandomNumberGenerator
-{
-public:
- virtual ~RandomNumberGenerator() {}
- virtual byte GetByte() =0;
- virtual int GetBit();
- virtual word32 GetLong(word32 min=0, word32 max=0xffffffffL);
- virtual word16 GetShort(word16 min=0, word16 max=0xffff)
- {return (word16)GetLong(min, max);}
- virtual void GetBlock(byte *output, unsigned int size);
-};
-template <class T> void Shuffle(RandomNumberGenerator &rng, T *array, unsigned int size)
-{
- while (--size)
- swap(array[size], array[(unsigned int)rng.GetLong(0, size)]);
-}
-class HashModule
-{
-public:
- virtual ~HashModule() {}
- virtual void Update(const byte *input, unsigned int length) =0;
- virtual void Final(byte *digest) =0;
- virtual int DigestSize() const =0;
- virtual void CalculateDigest(byte *digest, const byte *input, int length)
- {Update(input, length); Final(digest);}
-};
-class BufferedTransformation
-{
-public:
- virtual ~BufferedTransformation() {}
- virtual unsigned long MaxRetrieveable() =0;
- virtual void TransferTo(BufferedTransformation &target);
- virtual boolean Attachable() {return FALSE;}
- virtual void Detach(BufferedTransformation *) {}
- virtual void Attach(BufferedTransformation *) {}
- virtual void Close() {InputFinished();}
- virtual void Put(byte inByte) =0;
- virtual void Put(const byte *inString, unsigned int length) =0;
- virtual void InputFinished() {}
- void PutShort(word16 value, boolean highFirst=TRUE);
- void PutLong(word32 value, boolean highFirst=TRUE);
- virtual int Get(byte &outByte) =0;
- virtual unsigned int Get(byte *outString, unsigned int getMax) =0;
- int GetShort(word16 &value, boolean highFirst=TRUE);
- int GetLong(word32 &value, boolean highFirst=TRUE);
- unsigned int Skip(unsigned int skipMax);
-};
-class PK_CryptoSystem
-{
-public:
- virtual ~PK_CryptoSystem() {};
- virtual unsigned int MaxPlainTextLength() const =0;
- virtual unsigned int CipherTextLength() const =0;
-};
-class PK_Encryptor : public PK_CryptoSystem
-{
-public:
- virtual void Encrypt(RandomNumberGenerator &rng, const byte *plainText, unsigned int plainTextLength, byte *cipherText) =0;
-};
-class PK_Decryptor : public PK_CryptoSystem
-{
-public:
- virtual unsigned int Decrypt(const byte *cipherText, byte *plainText) =0;
-};
-class PK_SignatureSystem
-{
-public:
- virtual ~PK_SignatureSystem() {};
- virtual unsigned int MaxMessageLength() const =0;
- virtual unsigned int SignatureLength() const =0;
-};
-class PK_Signer : public PK_SignatureSystem
-{
-public:
- virtual void Sign(RandomNumberGenerator &rng, const byte *message, unsigned int messageLen, byte *signature) =0;
-};
-class PK_Verifier : public PK_SignatureSystem
-{
-public:
- virtual boolean Verify(const byte *message, unsigned int messageLen, const byte *signature) =0;
-};
-class ByteQueueNode;
-class ByteQueue : public BufferedTransformation
-{
-public:
- ByteQueue();
- ~ByteQueue();
- unsigned long CurrentSize() const;
- unsigned long MaxRetrieveable()
- {return CurrentSize();}
- void Put(byte inByte);
- void Put(const byte *inString, unsigned int length);
- int Get(byte &outByte);
- unsigned int Get(byte *outString, unsigned int getMax);
-private:
- ByteQueueNode *head, *tail;
-};
-enum ASNTag {INTEGER=0x02, BIT_STRING=0x03, SEQUENCE=0x10};
-enum ASNIdFlag {CONSTRUCTED = 0x20};
-unsigned int DERLengthEncode(unsigned int length, byte *output);
-unsigned int DERLengthEncode(unsigned int length, BufferedTransformation &);
-class BERDecodeErr {};
-boolean BERLengthDecode(BufferedTransformation &, unsigned int &);
-class BERSequenceDecoder : public BufferedTransformation
-{
-public:
- BERSequenceDecoder(BufferedTransformation &inQueue);
- ~BERSequenceDecoder();
- void Put(byte inByte) {}
- void Put(const byte *, unsigned int) {}
- unsigned long MaxRetrieveable()
- {return inQueue.MaxRetrieveable();}
- int Get(byte &outByte)
- {return inQueue.Get(outByte);}
- unsigned int Get(byte *outString, unsigned int getMax)
- {return inQueue.Get(outString, getMax);}
-private:
- BufferedTransformation &inQueue;
- boolean definiteLength;
- unsigned int length;
-};
-class DERSequenceEncoder : public ByteQueue
-{
-public:
- DERSequenceEncoder(BufferedTransformation &outQueue);
- ~DERSequenceEncoder();
-private:
- BufferedTransformation &outQueue;
-};
-extern "C" {
-}
-extern "C" {
-extern void *memmove(void *, const void *, size_t);
-extern char *strcpy(char *, const char *);
-extern char *strncpy(char *, const char *, size_t);
-extern char *strcat(char *, const char *);
-extern char *strncat(char *, const char *, size_t);
-extern int strcmp(const char *, const char *);
-extern int strcoll(const char *, const char *);
-extern int strncmp(const char *, const char *, size_t);
-extern size_t strxfrm(char *, const char *, size_t);
-extern void * __hide_memchr (const void *, int, size_t);
-extern char * __hide_strchr (const char *, int);
-extern size_t strcspn(const char *, const char *);
-extern char * __hide_strpbrk (const char *, const char *);
-extern char * __hide_strrchr (const char *, int);
-extern size_t strspn(const char *, const char *);
-extern char * __hide_strstr (const char *, const char *);
-extern char *strtok(char *, const char *);
-extern void *memset(void *, int, size_t);
-extern char *strerror(int);
-extern void *memccpy(void *, const void *, int, size_t);
-extern char *strdup(const char *);
-extern char *strsignal(int);
-extern int ffs(const int);
-extern int strcasecmp(const char *, const char *);
-extern int strncasecmp(const char *, const char *, size_t);
-}
-typedef int ptrdiff_t;
-extern "C" const char *strchr (const char *, int);
-inline char *
-strchr (char *s, int c)
-{
- return (char*) strchr ((const char *) s, c);
-}
-extern "C" const char *strpbrk (const char *, const char *);
-inline char *
-strpbrk (char *s1, const char *s2)
-{
- return (char *) strpbrk ((const char *) s1, s2);
-}
-extern "C" const char *strrchr (const char *, int);
-inline char *
-strrchr (char *s, int c)
-{
- return (char *) strrchr ((const char *) s, c);
-}
-extern "C" const char *strstr (const char *, const char *);
-inline char *
-strstr (char *s1, const char *s2)
-{
- return (char *) strstr ((const char *) s1, s2);
-}
-extern "C" void *memchr (const void *, int, size_t);
-inline void *
-memchr (void *s, int c, size_t n)
-{
- return (void *) memchr ((const void *) s, c, n);
-}
-typedef word16 unit;
-typedef short signedunit;
-typedef unit *unitptr;
-extern short global_precision;
-boolean mp_addc
- (register unitptr r1,const unit * r2,register boolean carry);
-boolean mp_subb
- (register unitptr r1,const unit * r2,register boolean borrow);
-boolean mp_rotate_left(register unitptr r1,register boolean carry);
-void mp_shift_right_bits(register unitptr r1,register short bits);
-short mp_compare(const unit * r1,const unit * r2);
-boolean mp_inc(register unitptr r);
-boolean mp_dec(register unitptr r);
-void mp_neg(register unitptr r);
-void mp_init(register unitptr r, word16 value);
-short significance(const unit * r);
-int mp_udiv(register unitptr remainder,register unitptr quotient,
- const unit * dividend,const unit * divisor);
-int mp_recip(register unitptr quotient,const unit * divisor);
-int mp_div(register unitptr remainder,register unitptr quotient,
- unit * dividend, unit * divisor);
-word16 mp_shortdiv(register unitptr quotient,
- const unit * dividend,register word16 divisor);
-int mp_mod(register unitptr remainder,
- const unit * dividend,const unit * divisor);
-word16 mp_shortmod(register unitptr dividend,register word16 divisor);
-int mp_mult(register unitptr prod,
- const unit * multiplicand,const unit * multiplier);
-int countbits(const unit * r);
-int stage_peasant_modulus(const unit * n);
-int stage_merritt_modulus(const unit * n);
-int stage_upton_modulus(const unit * n);
-int stage_smith_modulus(const unit * n);
-int peasant_modmult(register unitptr prod,
- const unit * multiplicand,const unit * multiplier);
-int merritt_modmult(register unitptr prod,
- const unit * multiplicand,const unit * multiplier);
-int upton_modmult(register unitptr prod,
- const unit * multiplicand,const unit * multiplier);
-int smith_modmult(register unitptr prod,
- const unit * multiplicand,const unit * multiplier);
-void peasant_burn();
-void merritt_burn();
-void upton_burn();
-void smith_burn();
-int mp_modexp(register unitptr expout,const unit * expin,
- const unit * exponent,const unit * modulus);
-int mp_modexp_crt(unitptr expout, const unit * expin,
- const unit * p, const unit * q, const unit * ep, const unit * eq, const unit * u);
-word16 fetch_word16(byte *buf);
-byte *put_word16(word16 w, byte *buf);
-word32 fetch_word32(byte *buf);
-byte *put_word32(word32 w, byte *buf);
-int string_length(const char *s);
-int str2reg(unit * reg,const char* digitstr);
-int reg2str(char * s,const unit * n,short radix);
-void mp_display(char * s,unitptr r);
-word16 checksum(register byte * buf, register word16 count);
-void cbc_xor(register unitptr dst, register unitptr src, word16 bytecount);
-void hiloswap(byte * r1,short numbytes);
-short mpi2reg(register unitptr r, register byte * buf);
-short reg2mpi(register byte * buf, register unitptr r);
-enum RandomNumberType {ANY, ODD, PRIME, BLUMINT};
-class MPIRegister : public SecBlock<unit>
-{
-public:
- MPIRegister() : SecBlock<unit>((2048 / 16 ) ) {}
-};
-class ostream;
-class bignum
-{
-public:
- bignum()
- {}
- bignum(unsigned long value);
- bignum(const char *str)
- {str2reg(reg, str);}
- enum Signedness{UNSIGNED, SIGNED};
- bignum(const byte *encodedBignum, unsigned int byteCount, Signedness s=UNSIGNED)
- {Decode(encodedBignum, byteCount, s);}
- bignum(const byte *BEREncodedInteger)
- {BERDecode(BEREncodedInteger);}
- bignum(BufferedTransformation &bt)
- {BERDecode(bt);}
- bignum(RandomNumberGenerator &rng, unsigned int bitcount)
- {Randomize(rng, bitcount);}
- bignum(RandomNumberGenerator &rng, const bignum &min, const bignum &max, RandomNumberType rnType=ANY)
- {Randomize(rng, min, max, rnType);}
- bignum(const bignum& t)
- {memcpy(reg, t.reg, (2048 /8) );}
- unsigned int Encode(byte *output) const;
- unsigned int Encode(byte *output, unsigned int outputLen) const;
- void Decode(const byte *input, unsigned int inputLen, Signedness=UNSIGNED);
- unsigned int DEREncode(byte *output) const;
- unsigned int DEREncode(BufferedTransformation &bt) const;
- void BERDecode(const byte *input);
- void BERDecode(BufferedTransformation &bt);
- void Randomize(RandomNumberGenerator &rng, unsigned int bitcount);
- void Randomize(RandomNumberGenerator &rng, const bignum &min, const bignum &max);
- void Randomize(RandomNumberGenerator &rng, const bignum &min, const bignum &max, RandomNumberType rnType);
- unsigned int ByteCount() const
- {
- return ((countbits( reg )+7)>>3) ;
- }
- int BitCount() const
- {
- return countbits(reg);
- }
- bignum& operator++()
- {
- mp_inc(reg);
- return *this;
- }
- bignum& operator--()
- {
- mp_dec(reg);
- return *this;
- }
- int operator!() const
- {
- return ( ((* (( reg.ptr )+( global_precision )-1) ) ==( 0 )) && (significance( reg.ptr )<=1) ) ;
- }
- bignum& operator=(const bignum& t)
- {
- memcpy(reg, t.reg, (2048 /8) );
- return *this;
- }
- bignum& operator+=(const bignum& t)
- {
- mp_addc( reg , t.reg ,(boolean)0) ;
- return *this;
- }
- bignum& operator-=(const bignum& t)
- {
- mp_subb( reg , t.reg ,(boolean)0) ;
- return *this;
- }
- bignum& operator*=(const bignum& t)
- {
- *this = (*this) * t;
- return *this;
- }
- bignum& operator/=(const bignum& t)
- {
- *this = (*this) / t;
- return *this;
- }
- bignum& operator%=(const bignum& t)
- {
- *this = (*this) % t;
- return *this;
- }
- bignum& operator<<=(unsigned int);
- bignum& operator>>=(unsigned int);
- unsigned MaxBitPrecision() const {return 2048 ;}
- int operator[](unsigned int n) const;
- friend bignum operator+(bignum a, const bignum &b)
- {
- return (a+=b);
- }
- friend bignum operator-(bignum a, const bignum &b)
- {
- return (a-=b);
- }
- friend bignum operator*(const bignum &a, const bignum &b);
- friend bignum operator/(const bignum &a, const bignum &b);
- friend bignum operator%(const bignum &a, const bignum &b);
- friend bignum operator/(const bignum &a, word16 b);
- friend word16 operator%(const bignum &a, word16 b);
- friend bignum operator>>(bignum a, unsigned int n)
- {return (a>>=n);}
- friend bignum operator<<(bignum a, unsigned int n)
- {return (a<<=n);}
- void Negate() {mp_neg(reg);}
- friend bignum operator-(bignum a)
- {
- a.Negate();
- return a;
- }
- friend int operator==(const bignum &a, const bignum &b)
- {
- return (memcmp(a.reg.ptr, b.reg.ptr, (2048 /8) )==0);
- }
- friend int operator!=(const bignum& a, const bignum& b)
- {
- return (memcmp(a.reg.ptr, b.reg.ptr, (2048 /8) )!=0);
- }
- friend int operator>(const bignum& a, const bignum& b)
- {
- return (mp_compare(a.reg, b.reg)>0);
- }
- friend int operator>=(const bignum& a, const bignum& b)
- {
- return (mp_compare(a.reg, b.reg)>=0);
- }
- friend int operator<(const bignum& a, const bignum& b)
- {
- return (mp_compare(a.reg, b.reg)<0);
- }
- friend int operator<=(const bignum& a, const bignum& b)
- {
- return (mp_compare(a.reg, b.reg)<=0);
- }
- friend bignum a_times_b_mod_c(const bignum &x, const bignum& y, const bignum& m);
- friend bignum a_exp_b_mod_c(const bignum &x, const bignum& e, const bignum& m);
- class DivideErr {};
- friend void Divide(bignum &r, bignum &q,
- const bignum &a, const bignum &d,
- Signedness s=SIGNED);
- friend boolean Negative(const bignum &a)
- {
- return ((signedunit) (* ( a.reg.ptr ) ) < 0) ;
- }
- friend bignum Abs(bignum a)
- {
- (((signedunit) (* ( a.reg.ptr ) ) < 0) ? (mp_neg( a.reg.ptr ),TRUE) : FALSE) ;
- return a;
- }
- friend ostream& operator<<(ostream& out, const bignum &a);
- unit lsUnit() {return (* (( reg.ptr )+( global_precision )-1) ) ;}
-private:
- MPIRegister reg;
-};
-class RSAPublicKey : public PK_Encryptor, public PK_Decryptor,
- public PK_Verifier
-{
-public:
- RSAPublicKey(const bignum &n, const bignum &e);
- RSAPublicKey(BufferedTransformation &bt);
- void DEREncode(BufferedTransformation &bt) const;
- void Encrypt(RandomNumberGenerator &rng, const byte *plainText, unsigned int plainTextLength, byte *cipherText);
- unsigned int Decrypt(const byte *cipherText, byte *plainText);
- boolean Verify(const byte *message, unsigned int messageLen, const byte *signature);
- unsigned int MaxPlainTextLength() const {return modulusLen-11;}
- unsigned int CipherTextLength() const {return modulusLen;}
- unsigned int MaxMessageLength() const {return modulusLen-11;}
- unsigned int SignatureLength() const {return modulusLen;}
- const bignum& Exponent() const {return e;}
- const bignum& Modulus() const {return n;}
-protected:
- void RawEncrypt(const bignum &in, bignum &out) const;
-private:
- friend class RSAPrivateKey;
- RSAPublicKey() {}
- bignum n;
- bignum e;
- unsigned int modulusLen;
-};
-class RSAPrivateKey : public RSAPublicKey, public PK_Signer
-{
-public:
- RSAPrivateKey(const bignum &n, const bignum &e, const bignum &d,
- const bignum &p, const bignum &q, const bignum &dp, const bignum &dq, const bignum &u);
- RSAPrivateKey(RandomNumberGenerator &rng, int keybits, bignum eStart=17);
- RSAPrivateKey(BufferedTransformation &bt);
- void DEREncode(BufferedTransformation &bt) const;
- void Encrypt(const byte *plainText, unsigned int plainTextLength, byte *cipherText);
- unsigned int Decrypt(const byte *cipherText, byte *plainText);
- void Encrypt(RandomNumberGenerator &, const byte *plainText, unsigned int plainTextLength, byte *cipherText)
- {Encrypt(plainText, plainTextLength, cipherText);}
- void Sign(const byte *message, unsigned int messageLen, byte *signature)
- {Encrypt(message, messageLen, signature);}
- void Sign(RandomNumberGenerator &, const byte *message, unsigned int messageLen, byte *signature)
- {Encrypt(message, messageLen, signature);}
- unsigned int MaxMessageLength() const {return modulusLen-11;}
- unsigned int SignatureLength() const {return modulusLen;}
-protected:
- void RawEncrypt(const bignum &in, bignum &out) const;
-private:
- bignum d;
- bignum p;
- bignum q;
- bignum dp;
- bignum dq;
- bignum u;
-};
-bignum Gcd(const bignum &a, const bignum &b);
-bignum Inverse(const bignum &a, const bignum &m);
-boolean IsSmallPrime(const bignum &p);
-boolean SmallDivisorsTest(const bignum &p);
-boolean FermatTest(const bignum &p, unsigned int rounds);
-boolean RabinMillerTest(RandomNumberGenerator &rng, const bignum &w, unsigned int rounds);
-inline boolean IsPrime(const bignum &p)
-{
- return (IsSmallPrime(p) || (SmallDivisorsTest(p) && FermatTest(p, 2)));
-}
-boolean NextPrime(bignum &p, const bignum &max, boolean blumInt=FALSE);
-bignum a_exp_b_mod_pq(const bignum &a, const bignum &ep, const bignum &eq,
- const bignum &p, const bignum &q, const bignum &u);
-class PrimeAndGenerator
-{
-public:
- PrimeAndGenerator(RandomNumberGenerator &rng, unsigned int pbits);
- PrimeAndGenerator(RandomNumberGenerator &rng, unsigned int pbits, unsigned qbits);
- const bignum& Prime() const {return p;}
- const bignum& SubPrime() const {return q;}
- const bignum& Generator() const {return g;}
-private:
- bignum p, q, g;
-};
-extern "C" {
-extern void __eprintf (const char *, const char *, unsigned, const char *);
-}
-RSAPublicKey::RSAPublicKey(const bignum &n, const bignum &e)
- : n(n), e(e), modulusLen(n.ByteCount())
-{
-}
-RSAPublicKey::RSAPublicKey(BufferedTransformation &bt)
-{
- BERSequenceDecoder seq(bt);
- n.BERDecode(seq);
- modulusLen = n.ByteCount();
- e.BERDecode(seq);
-}
-void RSAPublicKey::DEREncode(BufferedTransformation &bt) const
-{
- DERSequenceEncoder seq(bt);
- n.DEREncode(seq);
- e.DEREncode(seq);
-}
-void RSAPublicKey::Encrypt(RandomNumberGenerator &rng, const byte *input, unsigned int inputLen, byte *output)
-{unsigned int i;
- ((void) (( inputLen <= MaxPlainTextLength() ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n", "rsa.cpp" , 30 , "inputLen <= MaxPlainTextLength()" ), 0) )) ;
- SecByteBlock pkcsBlock(modulusLen);
- pkcsBlock[0] = 0;
- pkcsBlock[1] = 2;
- for (i = 2; i < modulusLen - inputLen - 1; i++)
- {
- do
- pkcsBlock[i] = rng.GetByte();
- while (pkcsBlock[i] == 0);
- }
- pkcsBlock[i++] = 0;
- memcpy(pkcsBlock+i, input, inputLen);
- bignum c;
- RawEncrypt(bignum(pkcsBlock, modulusLen), c);
- c.Encode(output, modulusLen);
-}
-unsigned int RSAPublicKey::Decrypt(const byte *input, byte *output)
-{unsigned int i;
- bignum m;
- RawEncrypt(bignum(input, modulusLen), m);
- SecByteBlock pkcsBlock(modulusLen);
- m.Encode(pkcsBlock, modulusLen);
- if ((pkcsBlock[0] != 0) || (pkcsBlock[1] != 1))
- return 0;
- for (i = 2; i < modulusLen-1; i++)
- if (pkcsBlock[i] != 0xff)
- break;
- if (pkcsBlock[i++] != 0)
- return 0;
- unsigned int outputLen = modulusLen - i;
- if (outputLen > MaxPlainTextLength())
- return 0;
- memcpy (output, pkcsBlock+i, outputLen);
- return outputLen;
-}
-boolean RSAPublicKey::Verify(const byte *message, unsigned int messageLen, const byte *signature)
-{
- ((void) (( messageLen <= MaxMessageLength() ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n", "rsa.cpp" , 83 , "messageLen <= MaxMessageLength()" ), 0) )) ;
- SecByteBlock m(MaxMessageLength());
- unsigned int mLen = RSAPublicKey::Decrypt(signature, m);
- return (mLen==messageLen && memcmp(message, m, mLen)==0);
-}
-void RSAPublicKey::RawEncrypt(const bignum &in, bignum &out) const
-{
- out = a_exp_b_mod_c(in, e, n);
-}
-RSAPrivateKey::RSAPrivateKey(const bignum &nIn, const bignum &eIn, const bignum &dIn,
- const bignum &pIn, const bignum &qIn,
- const bignum &dpIn, const bignum &dqIn, const bignum &uIn)
- : RSAPublicKey(nIn, eIn)
-{
- d=dIn;
- if (pIn < qIn)
- {
- p=pIn;
- q=qIn;
- dp=dpIn;
- dq=dqIn;
- }
- else
- {
- p=qIn;
- q=pIn;
- dp=dqIn;
- dq=dpIn;
- }
- u=uIn;
-}
-RSAPrivateKey::RSAPrivateKey(RandomNumberGenerator &rng, int keybits, bignum eStart)
-{
- p = bignum(rng, keybits/2, PRIME);
- const bignum minQ = ((bignum(1) << (keybits-1)) / p) + 1;
- const bignum maxQ = (bignum(1) << keybits) / p;
- do
- {
- bignum temp(rng, minQ, maxQ, PRIME);
- if (p>temp && p.BitCount()-(p-temp).BitCount() < 7)
- {
- q=p;
- p=temp;
- break;
- }
- if (p<temp && temp.BitCount()-(temp-p).BitCount() < 7)
- {
- q=temp;
- break;
- }
- } while (1);
- bignum phi = (p-1)*(q-1);
- for (e = eStart; Gcd(e, phi)!=1; ++e, ++e);
- d = Inverse(e, phi/Gcd(p-1, q-1));
- dp = d % (p-1);
- dq = d % (q-1);
- u = Inverse(p, q);
- n = p * q;
- modulusLen = n.ByteCount();
-}
-RSAPrivateKey::RSAPrivateKey(BufferedTransformation &bt)
-{
- BERSequenceDecoder seq(bt);
- bignum version(seq);
- if (!!version)
- throw BERDecodeErr() ;
- n.BERDecode(seq);
- modulusLen = n.ByteCount();
- e.BERDecode(seq);
- d.BERDecode(seq);
- p.BERDecode(seq);
- q.BERDecode(seq);
- dp.BERDecode(seq);
- dq.BERDecode(seq);
- u.BERDecode(seq);
- if (p>q)
- {
- swap(p, q);
- swap(dp, dq);
- }
-}
-void RSAPrivateKey::DEREncode(BufferedTransformation &bt) const
-{
- DERSequenceEncoder seq(bt);
- byte version[] = {INTEGER, 1, 0};
- seq.Put(version, sizeof(version));
- n.DEREncode(seq);
- e.DEREncode(seq);
- d.DEREncode(seq);
- q.DEREncode(seq);
- p.DEREncode(seq);
- dq.DEREncode(seq);
- dp.DEREncode(seq);
- u.DEREncode(seq);
-}
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-11 11:40:43 +0000