bool WestwoodRSA::Encrypt(unsigned char *in_buffer, unsigned int length, unsigned char *out_buffer)
{
bool success = false;
if (length > 0)
{
Integer e(WWRSA_e);
Integer N(WWRSA_N);
Integer M;
Integer C;
unsigned int offset = 0;
unsigned int remaining = length;
while (remaining >= WWRSA_BLOCK_SIZE)
{
M.Decode(in_buffer + offset, WWRSA_BLOCK_SIZE);
C = a_exp_b_mod_c(M, e, N);
C.Encode(out_buffer + offset, WWRSA_BLOCK_SIZE);
offset += WWRSA_BLOCK_SIZE;
remaining -= WWRSA_BLOCK_SIZE;
}
if (remaining > 0)
{
unsigned char buffer[WWRSA_BLOCK_SIZE];
memcpy(buffer, in_buffer + offset, remaining);
memset(buffer + remaining, 0, WWRSA_BLOCK_SIZE - remaining);
M.Decode(buffer, WWRSA_BLOCK_SIZE);
C = a_exp_b_mod_c(M, e, N);
C.Encode(out_buffer + offset, WWRSA_BLOCK_SIZE);
}
success = true;
}
return success;
};
bool DSA::GeneratePrimes(const byte *seedIn, unsigned int g, int &counter,
Integer &p, unsigned int L, Integer &q, bool useInputCounterValue)
{
assert(g%8 == 0);
SHA sha;
SecByteBlock seed(seedIn, g/8);
SecByteBlock U(SHA::DIGESTSIZE);
SecByteBlock temp(SHA::DIGESTSIZE);
SecByteBlock W(((L-1)/160+1) * SHA::DIGESTSIZE);
const int n = (L-1) / 160;
const int b = (L-1) % 160;
Integer X;
sha.CalculateDigest(U, seed, g/8);
for (int i=g/8-1, carry=true; i>=0 && carry; i--)
carry=!++seed[i];
sha.CalculateDigest(temp, seed, g/8);
xorbuf(U, temp, SHA::DIGESTSIZE);
U[0] |= 0x80;
U[SHA::DIGESTSIZE-1] |= 1;
q.Decode(U, SHA::DIGESTSIZE);
if (!IsPrime(q))
return false;
int counterEnd = useInputCounterValue ? counter+1 : 4096;
for (int c = 0; c < counterEnd; c++)
{
for (int k=0; k<=n; k++)
{
for (int i=g/8-1, carry=true; i>=0 && carry; i--)
carry=!++seed[i];
if (!useInputCounterValue || c == counter)
sha.CalculateDigest(W+(n-k)*SHA::DIGESTSIZE, seed, g/8);
}
if (!useInputCounterValue || c == counter)
{
W[SHA::DIGESTSIZE - 1 - b/8] |= 0x80;
X.Decode(W + SHA::DIGESTSIZE - 1 - b/8, L/8);
p = X-((X % (2*q))-1);
if (p.GetBit(L-1) && IsPrime(p))
{
counter = c;
return true;
}
}
}
return false;
}
Integer NR_EncodeDigest(unsigned int modulusBits, const byte *digest, unsigned int digestLen)
{
Integer h;
if (digestLen*8 < modulusBits)
h.Decode(digest, digestLen);
else
{
h.Decode(digest, bitsToBytes(modulusBits));
h >>= bitsToBytes(modulusBits)*8 - modulusBits + 1;
}
return h;
}
Integer NRDigestVerifier::EncodeDigest(const byte *digest, unsigned int digestLen) const
{
Integer h;
if (digestLen*8 < q.BitCount())
h.Decode(digest, digestLen);
else
{
h.Decode(digest, q.ByteCount());
h >>= q.ByteCount()*8 - q.BitCount() + 1;
}
assert(h < q);
return h;
}
// Generate Agreement
void DH::Agree(byte* agree, const byte* priv, const byte* otherPub, word32
otherSz)
{
const word32 bc(p_.ByteCount());
Integer x(priv, bc);
Integer y;
if (otherSz)
y.Decode(otherPub, otherSz);
else
y.Decode(otherPub, bc);
Integer z(a_exp_b_mod_c(y, x, p_));
z.Encode(agree, bc);
}
bool CMessageCrypter::Decrypt(const string& vchPrivKey, const string& vchCiphertext, string& vchPlaintext)
{
try
{
AutoSeededRandomPool prng;
StringSource ss(vchPrivKey, true /*pumpAll*/);
Integer x;
x.Decode(ss, ss.MaxRetrievable(), Integer::UNSIGNED);
ECIES<ECP>::Decryptor decryptor;
decryptor.AccessKey().AccessGroupParameters().Initialize(ASN1::secp256k1());
//make decryptor's access key using decoded private exponent's value
decryptor.AccessKey().SetPrivateExponent(x);
//check whether decryptor's access key is valid or not
bool valid = decryptor.AccessKey().Validate(prng, 3);
if(!valid)
decryptor.AccessKey().ThrowIfInvalid(prng, 3);
//decrypt the message using private key
StringSource ss2 (vchCiphertext, true, new PK_DecryptorFilter(prng, decryptor, new StringSink(vchPlaintext) ) );
}
catch(const CryptoPP::Exception& ex)
{
return false;
}
return true;
}
ustring PubAddr::getPubOfPriv(ustring priv)
{
OID CURVE = secp256k1();
ECIES < ECP >::PrivateKey privK;
Integer x;
x.Decode(priv.c_str(), priv.size());
privK.Initialize(CURVE, x);
ECIES<ECP>::PublicKey pub;
privK.MakePublicKey(pub);
string encoded;
int len = pub.GetPublicElement().x.MinEncodedSize();
pub.GetPublicElement().x.Encode(StringSink(encoded).Ref(), len);
len = pub.GetPublicElement().y.MinEncodedSize();
pub.GetPublicElement().y.Encode(StringSink(encoded).Ref(), len);
ustring ret;
ret += 0x04;
ret.fromString(encoded);
return ret;
}
std::string Converter::SecByteBlockToString(SecByteBlock data){
Integer a;
a.Decode(data.BytePtr(), data.SizeInBytes());
//cout<< "ze secbyteblock do integera: "<<a<<endl;
std::ostrstream oss;
oss << std::hex << a;
std::string s(oss.str());
s = s.substr(0, 2*data.SizeInBytes()+1); //Do zapamiêtania. d³ugoœæ stringa z s wynosi 2*d³ugoœæ w bytach plus 1.
return s;
}
//***************************************************************
Integer HashClass::getSHA1Integer(string m, Integer r)
{
byte *encodedMessage = (byte *)m.c_str();
int messageSize = m.length();
int rSize = r.MinEncodedSize();
byte * encodedR = new byte[rSize];
r.Encode(encodedR, rSize);
byte * hashInput = new byte[rSize + messageSize];
copy(encodedMessage, encodedMessage + messageSize, hashInput);
copy(encodedR, encodedR + rSize, hashInput + messageSize);
byte *hashOutput = getSHA1(hashInput, rSize+messageSize);
Integer result;
r.Decode(hashOutput, HashClass::size);
return r;
}
Integer HashPointMessage(const ECP& ec, const ECPPoint& R,
const byte* message, int mlen, bool compress = false)
{
const int digestsize = 256/8;
SHA3 sha(digestsize);
int len = ec.EncodedPointSize();
byte *buffer = new byte[len];
ec.EncodePoint(buffer, R, compress);
sha.Update(buffer, len);
delete[] buffer;
sha.Update(message, mlen);
byte digest[digestsize];
sha.Final(digest);
Integer ans;
ans.Decode(digest, digestsize);
return ans;
}
bool WestwoodRSA::Decrypt(unsigned char *in_buffer, unsigned int length, unsigned char *out_buffer)
{
bool success = false;
unsigned int blocks = length / WWRSA_BLOCK_SIZE;
if (blocks * WWRSA_BLOCK_SIZE == length)
{
Integer d(WWRSA_d);
Integer N(WWRSA_N);
Integer C;
Integer M;
unsigned int offset = 0;
for (unsigned int i = 0; i < blocks; i++)
{
C.Decode(in_buffer + offset, WWRSA_BLOCK_SIZE);
M = a_exp_b_mod_c(C, d, N);
M.Encode(out_buffer + offset, WWRSA_BLOCK_SIZE);
offset += WWRSA_BLOCK_SIZE;
}
success = true;
}
return success;
};
void DL_PrivateKey_EC<EC>::BERDecodeKey2(BufferedTransformation &bt, bool parametersPresent, unsigned int size)
{
BERSequenceDecoder seq(bt);
word32 version;
BERDecodeUnsigned<word32>(seq, version, INTEGER, 1, 1); // check version
BERGeneralDecoder dec(seq, OCTET_STRING);
if (!dec.IsDefiniteLength())
BERDecodeError();
Integer x;
x.Decode(dec, dec.RemainingLength());
dec.MessageEnd();
if (!parametersPresent && seq.PeekByte() != (CONTEXT_SPECIFIC | CONSTRUCTED | 0))
BERDecodeError();
if (!seq.EndReached() && seq.PeekByte() == (CONTEXT_SPECIFIC | CONSTRUCTED | 0))
{
BERGeneralDecoder parameters(seq, CONTEXT_SPECIFIC | CONSTRUCTED | 0);
AccessGroupParameters().BERDecode(parameters);
parameters.MessageEnd();
}
if (!seq.EndReached())
{
// skip over the public element
SecByteBlock subjectPublicKey;
unsigned int unusedBits;
BERGeneralDecoder publicKey(seq, CONTEXT_SPECIFIC | CONSTRUCTED | 1);
BERDecodeBitString(publicKey, subjectPublicKey, unusedBits);
publicKey.MessageEnd();
Element Q;
if (!(unusedBits == 0 && GetGroupParameters().GetCurve().DecodePoint(Q, subjectPublicKey, subjectPublicKey.size())))
BERDecodeError();
}
seq.MessageEnd();
SetPrivateExponent(x);
}
//********************************************************************************************************
Integer Converter::decodeSecByteBlock(SecByteBlock key)
{
Integer x;
x.Decode(key.BytePtr(), key.SizeInBytes());
return x;
}
int Addr::generateDeterministic(ustring passphrase, int nonce)
{
int nonce_old = nonce;
int stream = 1;
int version = 4;
OID CURVE = secp256k1();
AutoSeededRandomPool rng;
ECIES<ECP>::PrivateKey privE, privS;
ustring pubSKey;
ustring pubEKey;
string encoded;
size_t len;
byte digest2[CryptoPP::RIPEMD160::DIGESTSIZE];
int zeros = 0;
do
{
CryptoPP::SHA512 hash;
byte digest[CryptoPP::SHA512::DIGESTSIZE];
ustring passP = passphrase;
passP.appendVarInt_B(nonce++);
hash.CalculateDigest(digest, (byte*)passP.c_str(), passP.size());
Integer x;
x.Decode(digest, 32); //first 32 bytes
privS.Initialize(CURVE, x);
passP = passphrase;
passP.appendVarInt_B(nonce++);
hash.CalculateDigest(digest, (byte*)passP.c_str(), passP.size());
x.Decode(digest, 32);
privE.Initialize(CURVE, x);
ECIES<ECP>::PublicKey pubE, pubS;
privE.MakePublicKey(pubE);
privS.MakePublicKey(pubS);
encoded.clear();
len = pubE.GetPublicElement().x.MinEncodedSize();
pubE.GetPublicElement().x.Encode(StringSink(encoded).Ref(), len);
len = pubE.GetPublicElement().y.MinEncodedSize();
pubE.GetPublicElement().y.Encode(StringSink(encoded).Ref(), len);
pubEKey.clear();
pubEKey += 0x04;
pubEKey.fromString(encoded);
encoded.clear();
len = pubS.GetPublicElement().x.MinEncodedSize();
pubS.GetPublicElement().x.Encode(StringSink(encoded).Ref(), len);
len = pubS.GetPublicElement().y.MinEncodedSize();
pubS.GetPublicElement().y.Encode(StringSink(encoded).Ref(), len);
pubSKey.clear();
pubSKey += 0x04;
pubSKey.fromString(encoded);
memset(digest, 0, SHA512::DIGESTSIZE);
ustring buffer;
buffer += pubSKey;
buffer += pubEKey;
hash.CalculateDigest(digest, (byte*)buffer.c_str(), buffer.length());
CryptoPP::RIPEMD160 hash2;
memset(digest2, 0x00, 20);
hash2.CalculateDigest(digest2, digest, sizeof digest);
while (digest2[zeros] == 0x00)
zeros++;
} while (zeros == 0);
encoded.clear();
len = privE.GetPrivateExponent().MinEncodedSize();
privE.GetPrivateExponent().Encode(StringSink(encoded).Ref(), len);
ustring privEKey;
privEKey.fromString(encoded);
encoded.clear();
len = privS.GetPrivateExponent().MinEncodedSize();
privS.GetPrivateExponent().Encode(StringSink(encoded).Ref(), len);
ustring privSKey;
privSKey.fromString(encoded);
if (!this->loadKeys(pubEKey, pubSKey, privEKey, privSKey, stream, version))
return nonce_old;
return nonce;
}
packet_pubkey Addr::encodePubKey()
{
std::shared_lock<std::shared_timed_mutex> mlock(this->mutex_);
packet_pubkey pubkey;
time_t ltime = std::time(nullptr);
this->lastPubKeyRequest = ltime;
std::random_device rd;
std::mt19937 engine(rd());
std::uniform_int_distribution<int> distribution(-300, 300);
int random = distribution(engine);
time_t TTL = 4 * 24 * 60 * 60 + random; //4 days +- 5 min
ltime = ltime + TTL;
pubkey.objectType = 1;
pubkey.Time = ltime;
pubkey.stream = this->getStream();
pubkey.version = 4;
pubkey.encodePayload();
ustring plain;
OID CURVE = secp256k1();
AutoSeededRandomPool rng;
ECDH < ECP >::Domain dhA(CURVE);
//generating ephemeral key pair
SecByteBlock privA(dhA.PrivateKeyLength()), pubA(dhA.PublicKeyLength());
dhA.GenerateKeyPair(rng, privA, pubA);
ustring pubEKey;
pubEKey.append(pubA.data(), pubA.size());
ustring privEKey;
privEKey.append(privA.data(), privA.size());
plain.appendInt32(1); //bitfiled 1 not yet integrated
plain.append(this->pubSigningKey.c_str() + 1, 64);
plain.append(this->pubEncryptionKey.c_str() + 1, 64);
plain.appendVarInt_B(this->nonce_trials);
plain.appendVarInt_B(this->extra_bytes);
AutoSeededRandomPool prng;
ECDSA<ECP, SHA1>::PrivateKey privateKey;
Integer x;
x.Decode(this->getPrivSigningKey().c_str(), this->getPrivSigningKey().size());
privateKey.Initialize(CURVE, x);
ECDSA<ECP, SHA1>::Signer signer(privateKey);
string signature;
string mess;
ustring mess1;
unsigned int i = 8;
mess1.appendInt64(pubkey.message_payload.getInt64(i));
mess1.appendInt32(pubkey.message_payload.getInt32(i));
mess1.appendVarInt_B(pubkey.message_payload.getVarInt_B(i));
mess1.appendVarInt_B(pubkey.message_payload.getVarInt_B(i));
mess1 += this->getTag();
mess += mess1.toString();
mess += plain.toString();
StringSource ss(mess, true /*pump all*/,
new SignerFilter(prng,
signer,
new StringSink(signature)
) // SignerFilter
); // StringSource
//DER encoding
Integer r, s;
StringStore store(signature);
r.Decode(store, signature.size() / 2);
s.Decode(store, signature.size() / 2);
string sign;
StringSink sink(sign);
DERSequenceEncoder seq(sink);
r.DEREncode(seq);
s.DEREncode(seq);
seq.MessageEnd();
//end conversion
plain.appendVarInt_B(sign.size());
plain.append((unsigned char*)sign.c_str(), sign.size());
ECIES<ECP>::PrivateKey priv;
ustring pubK = this->getPubOfPriv(this->getTagE());
//Integer e;
//e.Decode(this->getTagE().c_str(), 32);
//priv.Initialize(CURVE, e);
//ECIES<ECP>::PublicKey pub;
//priv.MakePublicKey(pub);
//const ECP::Point& qq = pub.GetPublicElement();
//string pubS;
//StringSink sinkK(pubS);
//qq.x.Encode(sinkK, 32);
//qq.y.Encode(sinkK, 32);
//ustring pubK;
//pubK += 0x04;
//pubK.fromString(pubS);
ustring encoded = this->encode(pubK, privEKey, pubEKey, plain);
pubkey.tag = this->getTag();
pubkey.encrypted = encoded;
pubkey.encodeObject();
return pubkey;
}