#include <openssl/ecdsa.h>
#include <openssl/obj_mac.h>
-#include <openssl/ssl.h>
#include "key.h"
#include "base58.h"
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);
}
+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;
SetSecrets(L, H);
}
+/*
CMalleableKey& CMalleableKey::operator=(const CMalleableKey &b)
{
SetSecrets(b.vchSecretL, b.vchSecretH);
return (*this);
}
+*/
CMalleableKey::~CMalleableKey()
{
Reset();
CKey L, H;
- if (!L.SetSecret(pvchSecretL, true) || !H.SetSecret(pvchSecretH, true))
+ if (pvchSecretL.size() != 32 || pvchSecretH.size() != 32 || !L.SetSecret(pvchSecretL, true) || !H.SetSecret(pvchSecretH, true))
{
nVersion = 0;
return false;
}
// 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.");
}
CPoint point_R;
- if (!point_R.setBytes(R.Raw())) {
+ if (!point_R.setPubKey(R)) {
throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
}
std::vector<unsigned char> vchPubKeyH = H.GetPubKey().Raw();
CPoint point_H;
- if (!point_H.setBytes(vchPubKeyH)) {
+ if (!point_H.setPubKey(vchPubKeyH)) {
throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
}
CPoint point_P;
- if (!point_P.setBytes(vchPubKeyVariant.Raw())) {
+ if (!point_P.setPubKey(vchPubKeyVariant)) {
throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
}
}
// 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.");
}
CPoint point_R;
- if (!point_R.setBytes(R.Raw())) {
+ if (!point_R.setPubKey(R)) {
throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
}
std::vector<unsigned char> vchPubKeyH = H.GetPubKey().Raw();
CPoint point_H;
- if (!point_H.setBytes(vchPubKeyH)) {
+ if (!point_H.setPubKey(vchPubKeyH)) {
throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
}
CPoint point_P;
- if (!point_P.setBytes(vchPubKeyVariant.Raw())) {
+ if (!point_P.setPubKey(vchPubKeyVariant)) {
throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
}
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;
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() : L size must be 32 bytes");
+
vchSecretL = b.vchSecretL;
CKey H;
H.SetSecret(b.vchSecretH, true);
+
vchPubKeyH = H.GetPubKey().Raw();
+ nVersion = b.nVersion;
+}
+
+CMalleableKeyView::CMalleableKeyView(const CMalleableKeyView &b)
+{
+ vchSecretL = b.vchSecretL;
+ vchPubKeyH = b.vchPubKeyH;
+ nVersion = CURRENT_VERSION;
}
CMalleableKeyView::CMalleableKeyView(const CSecret &L, const CPubKey &pvchPubKeyH)
{
vchSecretL = L;
vchPubKeyH = pvchPubKeyH.Raw();
+ nVersion = CURRENT_VERSION;
}
CMalleableKeyView& CMalleableKeyView::operator=(const CMalleableKey &b)
{
- assert(b.nVersion == CURRENT_VERSION);
vchSecretL = b.vchSecretL;
CKey H;
H.SetSecret(b.vchSecretH, true);
vchPubKeyH = H.GetPubKey().Raw();
+ nVersion = b.nVersion;
return (*this);
}
}
// Check ownership
-bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant)
+bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const
{
if (!R.IsValid()) {
throw key_error("CMalleableKeyView::CheckKeyVariant() : R is invalid");
}
CPoint point_R;
- if (!point_R.setBytes(R.Raw())) {
+ if (!point_R.setPubKey(R)) {
throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode R value");
}
CPoint point_H;
- if (!point_H.setBytes(vchPubKeyH)) {
+ if (!point_H.setPubKey(vchPubKeyH)) {
throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode H value");
}
CPoint point_P;
- if (!point_P.setBytes(vchPubKeyVariant.Raw())) {
+ if (!point_P.setPubKey(vchPubKeyVariant)) {
throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode P value");
}
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 IsNull();
+}
+
+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::IsNull() const
+{
+ return nVersion != CURRENT_VERSION;
+}
+
//// Asymmetric encryption
-bool CPubKey::EncryptData(const std::vector<unsigned char>& data, std::vector<unsigned char>& encrypted)
+void CPubKey::EncryptData(const std::vector<unsigned char>& data, std::vector<unsigned char>& encrypted)
{
- // TODO
+ CKey key;
+ key.SetPubKey(*this);
- return true;
+ key.EncryptData(data, encrypted);
}
-bool CKey::DecryptData(const std::vector<unsigned char>& encrypted, std::vector<unsigned char>& data)
+void CKey::EncryptData(const std::vector<unsigned char>& data, std::vector<unsigned char>& encrypted)
{
- // TODO
+ ies_ctx_t *ctx;
+ char error[1024] = "Unknown error";
+ cryptogram_t *cryptogram;
+
+ ctx = create_context(pkey);
+ if (!EC_KEY_get0_public_key(ctx->user_key))
+ throw key_error("Given EC key is not public key");
+
+ cryptogram = ecies_encrypt(ctx, (unsigned char*)&data[0], data.size(), error);
+ if (cryptogram == NULL) {
+ free(ctx);
+ ctx = NULL;
+ throw key_error(std::string("Error in encryption: %s") + error);
+ }
- return true;
+ encrypted.resize(cryptogram_data_sum_length(cryptogram));
+ unsigned char *key_data = cryptogram_key_data(cryptogram);
+ memcpy(&encrypted[0], key_data, encrypted.size());
+ cryptogram_free(cryptogram);
+ free(ctx);
+}
+
+void CKey::DecryptData(const std::vector<unsigned char>& encrypted, std::vector<unsigned char>& data)
+{
+ ies_ctx_t *ctx;
+ char error[1024] = "Unknown error";
+ cryptogram_t *cryptogram;
+ size_t length;
+ unsigned char *decrypted;
+
+ ctx = create_context(pkey);
+ if (!EC_KEY_get0_private_key(ctx->user_key))
+ throw key_error("Given EC key is not private key");
+
+ size_t key_length = ctx->stored_key_length;
+ size_t mac_length = EVP_MD_size(ctx->md);
+ cryptogram = cryptogram_alloc(key_length, mac_length, encrypted.size() - key_length - mac_length);
+
+ memcpy(cryptogram_key_data(cryptogram), &encrypted[0], encrypted.size());
+
+ decrypted = ecies_decrypt(ctx, cryptogram, &length, error);
+ cryptogram_free(cryptogram);
+ free(ctx);
+
+ if (decrypted == NULL) {
+ throw key_error(std::string("Error in decryption: %s") + error);
+ }
+
+ data.resize(length);
+ memcpy(&data[0], decrypted, length);
+ free(decrypted);
}
git://git.novaco.in / novacoin.git / blobdiff