fCompressedPubKey = b.fCompressedPubKey;
}
+CKey::CKey(const CSecret& b, bool fCompressed)
+{
+ pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
+ if (pkey == NULL)
+ throw key_error("CKey::CKey(const CKey&) : EC_KEY_dup failed");
+ SetSecret(b, fCompressed);
+}
+
CKey& CKey::operator=(const CKey& b)
{
if (!EC_KEY_copy(pkey, b.pkey))
return vchRet;
}
+CSecret CKey::GetSecret() const
+{
+ bool fCompressed;
+ return GetSecret(fCompressed);
+}
+
CPrivKey CKey::GetPrivKey() const
{
int nSize = i2d_ECPrivateKey(pkey, NULL);
return true;
}
+// Initialize from octets stream
+bool CPoint::setPubKey(const CPubKey &vchPubKey)
+{
+ return setBytes(vchPubKey.Raw());
+}
+
// Serialize to octets stream
bool CPoint::getBytes(std::vector<unsigned char> &vchBytes)
{
EC_KEY_free(eckey);
CPoint point;
- if (!point.setBytes(pubKeyL.Raw())) {
+ if (!point.setPubKey(pubKeyL)) {
throw key_error("CMalleablePubKey::GetVariant() : Unable to decode L value");
}
bnHash.setuint160(Hash160(vchLr));
CPoint pointH;
- pointH.setBytes(pubKeyH.Raw());
+ pointH.setPubKey(pubKeyH);
CPoint P;
// Calculate P = Hash(L*r)*G + H
vchPubKeyVariant = CPubKey(vchResult);
}
-std::string CMalleablePubKey::ToString()
+std::string CMalleablePubKey::ToString() const
{
CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION);
ssKey << *this;
return EncodeBase58Check(vch);
}
+bool CMalleablePubKey::setvch(const std::vector<unsigned char> &vchPubKeyPair)
+{
+ CDataStream ssKey(vchPubKeyPair, SER_NETWORK, PROTOCOL_VERSION);
+ ssKey >> *this;
+
+ return IsValid();
+}
+
+std::vector<unsigned char> CMalleablePubKey::Raw() const
+{
+ CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION);
+ ssKey << *this;
+ std::vector<unsigned char> vch(ssKey.begin(), ssKey.end());
+
+ return vch;
+}
+
bool CMalleablePubKey::SetString(const std::string& strMalleablePubKey)
{
std::vector<unsigned char> vchTemp;
bool CMalleablePubKey::operator==(const CMalleablePubKey &b)
{
- return (nVersion == b.nVersion &&
- pubKeyL == b.pubKeyL &&
- pubKeyH == b.pubKeyH);
+ return pubKeyL == b.pubKeyL && pubKeyH == b.pubKeyH;
}
{
vchSecretL.clear();
vchSecretH.clear();
-
- nVersion = 0;
}
void CMalleableKey::MakeNewKeys()
{
- CKey L, H;
- bool fCompressed = true;
-
- L.MakeNewKey(true);
- H.MakeNewKey(true);
+ Reset();
- vchSecretL = L.GetSecret(fCompressed);
- vchSecretH = H.GetSecret(fCompressed);
+ CKey keyL, keyH;
+ keyL.MakeNewKey();
+ keyH.MakeNewKey();
- nVersion = CURRENT_VERSION;
+ vchSecretL = keyL.GetSecret();
+ vchSecretH = keyH.GetSecret();
}
CMalleableKey::CMalleableKey()
SetSecrets(L, H);
}
-CMalleableKey& CMalleableKey::operator=(const CMalleableKey &b)
-{
- SetSecrets(b.vchSecretL, b.vchSecretH);
-
- return (*this);
-}
-
CMalleableKey::~CMalleableKey()
{
}
bool CMalleableKey::IsNull() const
{
- return nVersion != CURRENT_VERSION;
+ return vchSecretL.size() != 32 || vchSecretH.size() != 32;
}
bool CMalleableKey::SetSecrets(const CSecret &pvchSecretL, const CSecret &pvchSecretH)
{
Reset();
- CKey L, H;
- if (!L.SetSecret(pvchSecretL, true) || !H.SetSecret(pvchSecretH, true))
- {
- nVersion = 0;
+ CKey keyL(pvchSecretL);
+ CKey keyH(pvchSecretH);
+
+ if (!keyL.IsValid() || !keyH.IsValid())
return false;
- }
vchSecretL = pvchSecretL;
vchSecretH = pvchSecretH;
- nVersion = CURRENT_VERSION;
return true;
}
-void CMalleableKey::GetSecrets(CSecret &pvchSecretL, CSecret &pvchSecretH) const
-{
- pvchSecretL = vchSecretL;
- pvchSecretH = vchSecretH;
-}
-
CMalleablePubKey CMalleableKey::GetMalleablePubKey() const
{
- CKey L, H;
- L.SetSecret(vchSecretL, true);
- H.SetSecret(vchSecretH, true);
-
- std::vector<unsigned char> vchPubKeyL = L.GetPubKey().Raw();
- std::vector<unsigned char> vchPubKeyH = H.GetPubKey().Raw();
-
- return CMalleablePubKey(vchPubKeyL, vchPubKeyH);
+ CKey L(vchSecretL), H(vchSecretH);
+ return CMalleablePubKey(L.GetPubKey().Raw(), H.GetPubKey().Raw());
}
// Check ownership
-bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant)
+bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const
{
if (IsNull()) {
throw key_error("CMalleableKey::CheckKeyVariant() : Attempting to run on NULL key object.");
}
if (!R.IsValid()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : R is invalid");
+ printf("CMalleableKey::CheckKeyVariant() : R is invalid");
+ return false;
}
if (!vchPubKeyVariant.IsValid()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : public key variant is invalid");
+ printf("CMalleableKey::CheckKeyVariant() : public key variant is invalid");
+ return false;
}
CPoint point_R;
- if (!point_R.setBytes(R.Raw())) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
+ if (!point_R.setPubKey(R)) {
+ printf("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
+ return false;
}
- CKey H;
- H.SetSecret(vchSecretH, true);
+ CKey H(vchSecretH);
std::vector<unsigned char> vchPubKeyH = H.GetPubKey().Raw();
CPoint point_H;
- if (!point_H.setBytes(vchPubKeyH)) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
+ if (!point_H.setPubKey(vchPubKeyH)) {
+ printf("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
+ return false;
}
CPoint point_P;
- if (!point_P.setBytes(vchPubKeyVariant.Raw())) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
+ if (!point_P.setPubKey(vchPubKeyVariant)) {
+ printf("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
+ return false;
}
// Infinity points are senseless
if (point_P.IsInfinity()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : P is infinity");
+ printf("CMalleableKey::CheckKeyVariant() : P is infinity");
+ return false;
}
CBigNum bnl;
std::vector<unsigned char> vchRl;
if (!point_R.getBytes(vchRl)) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value");
+ printf("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value");
+ return false;
}
// Calculate Hash(R*l)
// Infinity points are senseless
if (point_Ps.IsInfinity()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Ps is infinity");
+ printf("CMalleableKey::CheckKeyVariant() : Ps is infinity");
+ return false;
}
// Check ownership
}
// Check ownership and restore private key
-bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant, CKey &privKeyVariant)
+bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant, CKey &privKeyVariant) const
{
if (IsNull()) {
throw key_error("CMalleableKey::CheckKeyVariant() : Attempting to run on NULL key object.");
}
if (!R.IsValid()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : R is invalid");
+ printf("CMalleableKey::CheckKeyVariant() : R is invalid");
+ return false;
}
if (!vchPubKeyVariant.IsValid()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : public key variant is invalid");
+ printf("CMalleableKey::CheckKeyVariant() : public key variant is invalid");
+ return false;
}
CPoint point_R;
- if (!point_R.setBytes(R.Raw())) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
+ if (!point_R.setPubKey(R)) {
+ printf("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
+ return false;
}
- CKey H;
- H.SetSecret(vchSecretH, true);
+ CKey H(vchSecretH);
std::vector<unsigned char> vchPubKeyH = H.GetPubKey().Raw();
CPoint point_H;
- if (!point_H.setBytes(vchPubKeyH)) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
+ if (!point_H.setPubKey(vchPubKeyH)) {
+ printf("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
+ return false;
}
CPoint point_P;
- if (!point_P.setBytes(vchPubKeyVariant.Raw())) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
+ if (!point_P.setPubKey(vchPubKeyVariant)) {
+ printf("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
+ return false;
}
// Infinity points are senseless
if (point_P.IsInfinity()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : P is infinity");
+ printf("CMalleableKey::CheckKeyVariant() : P is infinity");
+ return false;
}
CBigNum bnl;
std::vector<unsigned char> vchRl;
if (!point_R.getBytes(vchRl)) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value");
+ printf("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value");
+ return false;
}
// Calculate Hash(R*l)
// Infinity points are senseless
if (point_Ps.IsInfinity()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Ps is infinity");
+ printf("CMalleableKey::CheckKeyVariant() : Ps is infinity");
+ return false;
}
// Check ownership
CBigNum bnp = bnHash + bnh;
std::vector<unsigned char> vchp = bnp.getBytes();
- privKeyVariant.SetSecret(CSecret(vchp.begin(), vchp.end()), true);
+ privKeyVariant.SetSecret(CSecret(vchp.begin(), vchp.end()));
return true;
}
-std::string CMalleableKey::ToString()
+std::string CMalleableKey::ToString() const
{
CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION);
ssKey << *this;
return EncodeBase58Check(vch);
}
+std::vector<unsigned char> CMalleableKey::Raw() const
+{
+ CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION);
+ ssKey << *this;
+ std::vector<unsigned char> vch(ssKey.begin(), ssKey.end());
+
+ return vch;
+}
+
bool CMalleableKey::SetString(const std::string& strMutableKey)
{
std::vector<unsigned char> vchTemp;
CDataStream ssKey(vchTemp, SER_NETWORK, PROTOCOL_VERSION);
ssKey >> *this;
- return IsNull();
+ return IsValid();
}
// CMalleableKeyView
+CMalleableKeyView::CMalleableKeyView(const std::string &strMalleableKey)
+{
+ SetString(strMalleableKey);
+}
+
CMalleableKeyView::CMalleableKeyView(const CMalleableKey &b)
{
- assert(b.nVersion == CURRENT_VERSION);
+ if (b.vchSecretL.size() != 32)
+ throw key_error("CMalleableKeyView::CMalleableKeyView() : L size must be 32 bytes");
+
+ if (b.vchSecretH.size() != 32)
+ throw key_error("CMalleableKeyView::CMalleableKeyView() : H size must be 32 bytes");
+
vchSecretL = b.vchSecretL;
- CKey H;
- H.SetSecret(b.vchSecretH, true);
+ CKey H(b.vchSecretH);
vchPubKeyH = H.GetPubKey().Raw();
}
-CMalleableKeyView::CMalleableKeyView(const CSecret &L, const CPubKey &pvchPubKeyH)
+CMalleableKeyView::CMalleableKeyView(const CMalleableKeyView &b)
{
- vchSecretL = L;
- vchPubKeyH = pvchPubKeyH.Raw();
+ vchSecretL = b.vchSecretL;
+ vchPubKeyH = b.vchPubKeyH;
}
CMalleableKeyView& CMalleableKeyView::operator=(const CMalleableKey &b)
{
- assert(b.nVersion == CURRENT_VERSION);
vchSecretL = b.vchSecretL;
- CKey H;
- H.SetSecret(b.vchSecretH, true);
+ CKey H(b.vchSecretH);
vchPubKeyH = H.GetPubKey().Raw();
return (*this);
CMalleablePubKey CMalleableKeyView::GetMalleablePubKey() const
{
- CKey keyL;
- keyL.SetSecret(vchSecretL, true);
+ CKey keyL(vchSecretL);
return CMalleablePubKey(keyL.GetPubKey(), vchPubKeyH);
}
// Check ownership
-bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant)
+bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const
{
+ if (!IsValid()) {
+ throw key_error("CMalleableKeyView::CheckKeyVariant() : Attempting to run on invalid view object.");
+ }
+
if (!R.IsValid()) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : R is invalid");
+ printf("CMalleableKeyView::CheckKeyVariant() : R is invalid");
+ return false;
}
if (!vchPubKeyVariant.IsValid()) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : public key variant is invalid");
+ printf("CMalleableKeyView::CheckKeyVariant() : public key variant is invalid");
+ return false;
}
CPoint point_R;
- if (!point_R.setBytes(R.Raw())) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode R value");
+ if (!point_R.setPubKey(R)) {
+ printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode R value");
+ return false;
}
CPoint point_H;
- if (!point_H.setBytes(vchPubKeyH)) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode H value");
+ if (!point_H.setPubKey(vchPubKeyH)) {
+ printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode H value");
+ return false;
}
CPoint point_P;
- if (!point_P.setBytes(vchPubKeyVariant.Raw())) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode P value");
+ if (!point_P.setPubKey(vchPubKeyVariant)) {
+ printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode P value");
+ return false;
}
// Infinity points are senseless
if (point_P.IsInfinity()) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : P is infinity");
+ printf("CMalleableKeyView::CheckKeyVariant() : P is infinity");
+ return false;
}
CBigNum bnl;
std::vector<unsigned char> vchRl;
if (!point_R.getBytes(vchRl)) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to convert Rl value");
+ printf("CMalleableKeyView::CheckKeyVariant() : Unable to convert Rl value");
+ return false;
}
// Calculate Hash(R*l)
// Infinity points are senseless
if (point_Ps.IsInfinity()) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : Ps is infinity");
+ printf("CMalleableKeyView::CheckKeyVariant() : Ps is infinity");
+ return false;
}
// Check ownership
return true;
}
+std::string CMalleableKeyView::ToString() const
+{
+ CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION);
+ ssKey << *this;
+ std::vector<unsigned char> vch(ssKey.begin(), ssKey.end());
+
+ return EncodeBase58Check(vch);
+}
+
+bool CMalleableKeyView::SetString(const std::string& strMutableKey)
+{
+ std::vector<unsigned char> vchTemp;
+ if (!DecodeBase58Check(strMutableKey, vchTemp)) {
+ throw key_error("CMalleableKeyView::SetString() : Provided key data seems corrupted.");
+ }
+
+ CDataStream ssKey(vchTemp, SER_NETWORK, PROTOCOL_VERSION);
+ ssKey >> *this;
+
+ return IsValid();
+}
+
+std::vector<unsigned char> CMalleableKeyView::Raw() const
+{
+ CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION);
+ ssKey << *this;
+ std::vector<unsigned char> vch(ssKey.begin(), ssKey.end());
+
+ return vch;
+}
+
+
+bool CMalleableKeyView::IsValid() const
+{
+ return vchSecretL.size() == 32 && GetMalleablePubKey().IsValid();
+}
+
//// Asymmetric encryption
void CPubKey::EncryptData(const std::vector<unsigned char>& data, std::vector<unsigned char>& encrypted)
git://git.novaco.in / novacoin.git / blobdiff