rsarefcl.cpp

各种加密算法的集合

#include "cryptlib.h" 

#ifdef USE_RSAREF 

#include "misc.h" 
#include "queue.h" 
#include "rsarefcl.h" 
#include "asn.h" 
#include <assert.h> 
#include <memory.h> 

static void FillRandomStruct(RandomNumberGenerator &amt;rng, R_RANDOM_STRUCT &amt;randomStruct) 
{ 
R_RandomInit(&amt;randomStruct); 

unsigned int blocksize; 
R_GetRandomBytesNeeded(&amt;blocksize, &amt;randomStruct); 

SecByteBlock temp(blocksize); 
rng.GetBlock(temp, blocksize); 

R_RandomUpdate(&amt;randomStruct, temp, blocksize); 
} 

static unsigned int DEREncodeByteArray(BufferedTransformation &amt;bt, const byte *in, unsigned int length) 
{ 
bt.Put(INTEGER); 
// skip leading zeros 
for (unsigned int i=0; i<length &amt;&amt; !in[i]; i++); 
// add a leading zero if highest bit is set or the number is zero 
boolean addZero = (in[i] &amt; 0x80) || (i==length); 
length = length - i + addZero; 
DERLengthEncode(length, bt); 
if (addZero) 
bt.Put(0); 
bt.Put(in+i, length-addZero); 
return length; 
} 

static unsigned int BERDecodeByteArray(byte *out, BufferedTransformation &amt;bt, unsigned int length) 
{ 
byte b; 
if (!bt.Get(b) || b != INTEGER) 
BERDecodeError(); 

unsigned int bc; 
BERLengthDecode(bt, bc); 
if (bc > length) 
BERDecodeError(); 

memset(out, 0, length-bc); 
bt.Get(out+length-bc, bc); 

// get a count of leading zeros 
for (bc=0; bc<length &amt;&amt; !out[bc]; bc++); 
return length-bc; 
} 

#ifdef USE_BIGNUM_WITH_RSAREF 
RSAREFPublicKey::RSAREFPublicKey(const bignum &amt;n, const bignum &amt;e) 
: keyBlock(1), key(keyBlock) 
{ 
key->bits = n.BitCount(); 
n.Encode(key->modulus, MAX_RSA_MODULUS_LEN); 
e.Encode(key->exponent, MAX_RSA_MODULUS_LEN); 
} 
#endif 

RSAREFPublicKey::RSAREFPublicKey(const RSAREFPrivateKey &amt;privateKey) 
: keyBlock(1), key(keyBlock) 
{ 
key->bits = privateKey.key->bits; 
memcpy(key->modulus, privateKey.key->modulus, MAX_RSA_MODULUS_LEN); 
memcpy(key->exponent, privateKey.key->publicExponent, MAX_RSA_MODULUS_LEN); 
} 

RSAREFPublicKey::RSAREFPublicKey(BufferedTransformation &amt;bt) 
: keyBlock(1), key(keyBlock) 
{ 
BERSequenceDecoder seq(bt); 
unsigned int modulusLen = BERDecodeByteArray(key->modulus, seq, MAX_RSA_MODULUS_LEN); 
key->bits = BitPrecision(key->modulus[MAX_RSA_MODULUS_LEN-modulusLen]) + 8*modulusLen - 8; 
BERDecodeByteArray(key->exponent, seq, MAX_RSA_MODULUS_LEN); 
} 

void RSAREFPublicKey::DEREncode(BufferedTransformation &amt;bt) const 
{ 
DERSequenceEncoder seq(bt); 
DEREncodeByteArray(seq, key->modulus, MAX_RSA_MODULUS_LEN); 
DEREncodeByteArray(seq, key->exponent, MAX_RSA_MODULUS_LEN); 
} 

void RSAREFPublicKey::Encrypt(RandomNumberGenerator &amt;rng, const byte *input, unsigned int inputLen, byte *output) 
{ 
assert (inputLen <= MaxPlainTextLength()); 

R_RANDOM_STRUCT randomStruct; 
FillRandomStruct(rng, randomStruct); 

if (input != output) 
memcpy(output, input, inputLen); // copy it first for the "const" 

unsigned int outputLen; 
int status = RSAPublicEncrypt(output, &amt;outputLen, output, inputLen, key, &amt;randomStruct); 

assert(status==0); 
assert(outputLen==CipherTextLength()); 

R_RandomFinal(&amt;randomStruct); // Clean up RSAREF's RNG 
} 

unsigned int RSAREFPublicKey::Decrypt(const byte *input, byte *output) 
{ 
if (input != output) 
memcpy(output, input, CipherTextLength()); // copy it first for the "const" 

unsigned int outputLen; 
int status = RSAPublicDecrypt(output, &amt;outputLen, output, CipherTextLength(), key); 

if (status) 
return 0; 

assert(outputLen<=MaxPlainTextLength()); 
return outputLen; 
} 

boolean RSAREFPublicKey::Verify(const byte *message, unsigned int messageLen, const byte *signature) 
{ 
assert(messageLen <= MaxMessageLength()); 
SecByteBlock m(MaxMessageLength()); 
unsigned int mLen = RSAREFPublicKey::Decrypt(signature, m); 
return (mLen==messageLen &amt;&amt; memcmp(message, m, mLen)==0); 
} 

// ***************************************************************************** 
// private key operations: 

#ifdef USE_BIGNUM_WITH_RSAREF 
RSAREFPrivateKey::RSAREFPrivateKey(const bignum &amt;n, const bignum &amt;e, const bignum &amt;d, 
const bignum &amt;p, const bignum &amt;q, 
const bignum &amt;dp, const bignum &amt;dq, const bignum &amt;u) 
: keyBlock(1), key(keyBlock) 
{ 
key->bits = n.BitCount(); 
n.Encode(key->modulus, MAX_RSA_MODULUS_LEN); 
e.Encode(key->publicExponent, MAX_RSA_MODULUS_LEN); 
d.Encode(key->exponent, MAX_RSA_MODULUS_LEN); 
if (p>q) 
{ 
p.Encode(key->prime[0], MAX_RSA_PRIME_LEN); 
q.Encode(key->prime[1], MAX_RSA_PRIME_LEN); 
dp.Encode(key->primeExponent[0], MAX_RSA_PRIME_LEN); 
dq.Encode(key->primeExponent[1], MAX_RSA_PRIME_LEN); 
} 
else 
{ 
q.Encode(key->prime[0], MAX_RSA_PRIME_LEN); 
p.Encode(key->prime[1], MAX_RSA_PRIME_LEN); 
dq.Encode(key->primeExponent[0], MAX_RSA_PRIME_LEN); 
dp.Encode(key->primeExponent[1], MAX_RSA_PRIME_LEN); 
} 
u.Encode(key->coefficient, MAX_RSA_PRIME_LEN); 
} 
#endif 

// generate a random private key 
RSAREFPrivateKey::RSAREFPrivateKey(RandomNumberGenerator &amt;rng, int keybits, boolean F4) 
: keyBlock(1), key(keyBlock) 
{ 
assert(keybits >= MIN_RSA_MODULUS_BITS &amt;&amt; keybits <= MAX_RSA_MODULUS_BITS); 

R_RSA_PROTO_KEY protoKey; 
protoKey.bits = keybits; 
protoKey.useFermat4 = F4; 

R_RANDOM_STRUCT randomStruct; 
FillRandomStruct(rng, randomStruct); 

R_RSA_PUBLIC_KEY temp; 
int status; 
do 
status = R_GeneratePEMKeys(&amt;temp, key, &amt;protoKey, &amt;randomStruct); 
while (status == RE_DATA); // retry if prime generation failed; 
assert(status==0); 

R_RandomFinal(&amt;randomStruct); // Clean up RSAREF's RNG 
} 

RSAREFPrivateKey::RSAREFPrivateKey(BufferedTransformation &amt;bt) 
: keyBlock(1), key(keyBlock) 
{ 
BERSequenceDecoder seq(bt); 

// extract and discard the version # first 
BERDecodeByteArray(key->modulus, seq, MAX_RSA_MODULUS_LEN); 

unsigned int modulusLen = BERDecodeByteArray(key->modulus, seq, MAX_RSA_MODULUS_LEN); 
key->bits = BitPrecision(key->modulus[MAX_RSA_MODULUS_LEN-modulusLen]) + 8*modulusLen - 8; 

BERDecodeByteArray(key->publicExponent, seq, MAX_RSA_MODULUS_LEN); 
BERDecodeByteArray(key->exponent, seq, MAX_RSA_MODULUS_LEN); 
BERDecodeByteArray(key->prime[0], seq, MAX_RSA_PRIME_LEN); 
BERDecodeByteArray(key->prime[1], seq, MAX_RSA_PRIME_LEN); 
BERDecodeByteArray(key->primeExponent[0], seq, MAX_RSA_PRIME_LEN); 
BERDecodeByteArray(key->primeExponent[1], seq, MAX_RSA_PRIME_LEN); 
BERDecodeByteArray(key->coefficient, seq, MAX_RSA_PRIME_LEN); 
} 

void RSAREFPrivateKey::DEREncode(BufferedTransformation &amt;bt) const 
{ 
DERSequenceEncoder seq(bt); 

byte version[] = {INTEGER, 1, 0}; 
seq.Put(version, sizeof(version)); 

DEREncodeByteArray(seq, key->modulus, MAX_RSA_MODULUS_LEN); 
DEREncodeByteArray(seq, key->publicExponent, MAX_RSA_MODULUS_LEN); 
DEREncodeByteArray(seq, key->exponent, MAX_RSA_MODULUS_LEN); 
DEREncodeByteArray(seq, key->prime[0], MAX_RSA_PRIME_LEN); 
DEREncodeByteArray(seq, key->prime[1], MAX_RSA_PRIME_LEN); 
DEREncodeByteArray(seq, key->primeExponent[0], MAX_RSA_PRIME_LEN); 
DEREncodeByteArray(seq, key->primeExponent[1], MAX_RSA_PRIME_LEN); 
DEREncodeByteArray(seq, key->coefficient, MAX_RSA_PRIME_LEN); 
} 

void RSAREFPrivateKey::Encrypt(const byte *input, unsigned int inputLen, byte *output) 
{ 
assert (inputLen <= MaxPlainTextLength()); 

if (input != output) 
memcpy(output, input, CipherTextLength()); // copy it first for the "const" 

unsigned int outputLen; 
int status = RSAPrivateEncrypt(output, &amt;outputLen, output, inputLen, key); 

assert(status==0); 
assert(outputLen==CipherTextLength()); 
} 

unsigned int RSAREFPrivateKey::Decrypt(const byte *input, byte *output) 
{ 
if (input != output) 
memcpy(output, input, CipherTextLength()); // copy it first for the "const" 

unsigned int outputLen; 
int status = RSAPrivateDecrypt(output, &amt;outputLen, output, CipherTextLength(), key); 

if (status) 
return 0; 

assert(outputLen<=MaxPlainTextLength()); 
return outputLen; 
} 

// ***************************************************************************** 
// Diffie-Hellman: 

#ifdef USE_BIGNUM_WITH_RSAREF 
RSAREF_DH::RSAREF_DH(const bignum &amt;p, const bignum &amt;g) 
: privateValue(p.ByteCount()-1) 
{ 
params.primeLen = p.ByteCount(); 
params.generatorLen = g.ByteCount(); 

params.prime = new byte[params.primeLen + params.generatorLen]; 
p.Encode(params.prime, params.primeLen); 

params.generator = params.prime + params.primeLen; 
g.Encode(params.generator, params.generatorLen); 
} 
#endif 

RSAREF_DH::RSAREF_DH(RandomNumberGenerator &amt;rng, unsigned int pbits, unsigned int qbits) 
: privateValue(DH_PRIME_LEN(pbits)-1) 
{ 
assert(pbits > qbits); 

params.prime = new byte[2*DH_PRIME_LEN(pbits)]; 
params.generator = params.prime + DH_PRIME_LEN(pbits); 

R_RANDOM_STRUCT randomStruct; 
FillRandomStruct(rng, randomStruct); 

int status; 
do // keep trying until we succeed 
{ 
status = R_GenerateDHParams(&amt;params, pbits, qbits, &amt;randomStruct); 
assert (status == 0 || status == RE_DATA); 
} 
while (status); 

R_RandomFinal(&amt;randomStruct); // Clean up RSAREF's RNG 
} 

RSAREF_DH::~RSAREF_DH() 
{ 
delete [] params.prime; 
} 

RSAREF_DH::RSAREF_DH(BufferedTransformation &amt;bt) 
: privateValue(BERDecode(bt)-1) 
{ 
} 

unsigned int RSAREF_DH::BERDecode(BufferedTransformation &amt;bt) 
{ 
BERSequenceDecoder seq(bt); 

// RSAREF can't handle more than this many significant bytes 
const int maxBytes=MAX_RSA_MODULUS_LEN; 
byte tempPrime[maxBytes]; 
byte tempGenerator[maxBytes]; 

params.primeLen = BERDecodeByteArray(tempPrime, seq, maxBytes); 
params.generatorLen = BERDecodeByteArray(tempGenerator, seq, maxBytes); 

params.prime = new byte[params.primeLen + params.generatorLen]; 
params.generator = params.prime + params.primeLen; 

memcpy(params.prime, tempPrime+maxBytes-params.primeLen, params.primeLen); 
memcpy(params.generator, tempGenerator+maxBytes-params.generatorLen, params.generatorLen); 

return params.primeLen; 
} 

void RSAREF_DH::DEREncode(BufferedTransformation &amt;bt) const 
{ 
DERSequenceEncoder seq(bt); 
DEREncodeByteArray(seq, params.prime, params.primeLen); 
DEREncodeByteArray(seq, params.generator, params.generatorLen); 
} 

void RSAREF_DH::Setup(RandomNumberGenerator &amt;rng, byte *publicValue) 
{ 
R_RANDOM_STRUCT randomStruct; 
FillRandomStruct(rng, randomStruct); 

int status = R_SetupDHAgreement(publicValue, privateValue, privateValue.size, &amt;params, &amt;randomStruct); 
R_RandomFinal(&amt;randomStruct); // Clean up RSAREF's RNG 
assert (status == 0); 
} 

void RSAREF_DH::Agree(const byte *in, byte *agreedKey) 
{ 
R_ComputeDHAgreedKey(agreedKey, (byte *)in, privateValue, privateValue.size, &amt;params); 
} 

#endif // USE_RSAREF