/*
	PIP - Platform Independent Primitives
	Cryptographic class using lib Sodium
	Andrey Bychkov work.a.b@yandex.ru

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU Lesser General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License
	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "picrypt.h"
#ifdef PIP_CRYPT
#  include <sodium.h>
#endif

#define PICRYPT_DISABLED_WARNING piCout << "[PICrypt]" << "Warning: PICrypt is disabled, to enable install sodium library and rebuild pip";

const char hash_def_key[] = "_picrypt_\0\0\0\0\0\0\0";
const int hash_def_key_size = 9;


PICrypt::PICrypt() {
#ifdef PIP_CRYPT
	if (!init()) piCout << "[PICrypt]" << "Error while initialize sodium!";
	nonce_.resize(crypto_secretbox_NONCEBYTES);
	key_.resize(crypto_secretbox_KEYBYTES);
	randombytes_buf(key_.data(), key_.size());
	randombytes_buf(nonce_.data(), nonce_.size());
#else
	PICRYPT_DISABLED_WARNING
#endif
}


bool PICrypt::setKey(const PIByteArray & _key) {
	if (_key.size() != key_.size()) return false;
	key_ = _key;
	return true;
}


PIByteArray PICrypt::setKey(const PIString & secret) {
	PIByteArray hash;
#ifdef PIP_CRYPT
	hash.resize(crypto_generichash_BYTES);
	PIByteArray s(secret.data(), secret.size());
	crypto_generichash(hash.data(), hash.size(), s.data(), s.size(), (const uchar*)hash_def_key, hash_def_key_size);
	hash.resize(key_.size());
	setKey(hash);
#endif
	return hash;
}


PIByteArray PICrypt::crypt(const PIByteArray & data) {
	PIByteArray ret;
#ifdef PIP_CRYPT
	ret.resize(data.size() + crypto_secretbox_MACBYTES);
	randombytes_buf(nonce_.data(), nonce_.size());
	crypto_secretbox_easy(ret.data(), data.data(), data.size(), nonce_.data(), key_.data());
	ret.append(nonce_);
#endif
	return ret;
}


PIByteArray PICrypt::crypt(const PIByteArray & data, PIByteArray key) {
	PIByteArray ret;
#ifdef PIP_CRYPT
	if (key.size() != crypto_secretbox_KEYBYTES)
		key.resize(crypto_secretbox_KEYBYTES, ' ');
		//return PIByteArray();
	if (!init()) return ret;
	PIByteArray n;
	ret.resize(data.size() + crypto_secretbox_MACBYTES);
	n.resize(crypto_secretbox_NONCEBYTES);
	randombytes_buf(n.data(), n.size());
	crypto_secretbox_easy(ret.data(), data.data(), data.size(), n.data(), key.data());
	ret.append(n);
#else
	PICRYPT_DISABLED_WARNING
#endif
	return ret;
}


PIByteArray PICrypt::decrypt(const PIByteArray & crypt_data, bool *ok) {
	PIByteArray ret;
#ifdef PIP_CRYPT
	if (crypt_data.size() < nonce_.size() + crypto_secretbox_MACBYTES) {
		if (ok) *ok = false;
		return PIByteArray();
	}
	ret.resize(crypt_data.size() - nonce_.size() - crypto_secretbox_MACBYTES);
	memcpy(nonce_.data(), crypt_data.data(crypt_data.size() - nonce_.size()), nonce_.size());
	if (crypto_secretbox_open_easy(ret.data(), crypt_data.data(), crypt_data.size() - nonce_.size(), nonce_.data(), key_.data()) != 0) {
		if (ok) *ok = false;
		//			piCout << "[PICrypt]" << "bad key_";
		return PIByteArray();
	}
#endif
	if (ok) *ok = true;
	return ret;
}


PIByteArray PICrypt::decrypt(const PIByteArray & crypt_data, PIByteArray key, bool *ok) {
	PIByteArray ret;
#ifdef PIP_CRYPT
	if (key.size() != crypto_secretbox_KEYBYTES)
		key.resize(crypto_secretbox_KEYBYTES, ' ');
		/*if (ok) *ok = false;
		return PIByteArray();
	}*/
	if (crypt_data.size() < crypto_secretbox_NONCEBYTES + crypto_secretbox_MACBYTES) {
		if (ok) *ok = false;
		return PIByteArray();
	}
	if (!init()) return ret;
	PIByteArray n;
	n.resize(crypto_secretbox_NONCEBYTES);
	ret.resize(crypt_data.size() - n.size() - crypto_secretbox_MACBYTES);
	memcpy(n.data(), crypt_data.data(crypt_data.size() - n.size()), n.size());
	if (crypto_secretbox_open_easy(ret.data(), crypt_data.data(), crypt_data.size() - n.size(), n.data(), key.data()) != 0) {
		if (ok) *ok = false;
		//			piCout << "[PICrypt]" << "bad key_";
		return PIByteArray();
	} else if (ok) *ok = true;
#else
	PICRYPT_DISABLED_WARNING
#endif
	return ret;
}


PIByteArray PICrypt::hash(const PIString & secret) {
	PIByteArray hash;
#ifdef PIP_CRYPT
	if (!init()) return hash;
	hash.resize(crypto_generichash_BYTES);
	PIByteArray s(secret.data(), secret.size());
	crypto_generichash(hash.data(), hash.size(), s.data(), s.size(),(const uchar*)hash_def_key, hash_def_key_size);
#else
	PICRYPT_DISABLED_WARNING
#endif
	return hash;
}


PIByteArray PICrypt::hash(const PIByteArray & data) {
	PIByteArray hash;
#ifdef PIP_CRYPT
	if (!init()) return hash;
	hash.resize(crypto_generichash_BYTES);
	crypto_generichash(hash.data(), hash.size(), data.data(), data.size(), (const uchar*)hash_def_key, hash_def_key_size);
#else
	PICRYPT_DISABLED_WARNING
#endif
	return hash;
}


size_t PICrypt::sizeHash() {
#ifdef PIP_CRYPT
	return crypto_generichash_BYTES;
#else
	PICRYPT_DISABLED_WARNING
#endif
	return 0;
}


ullong PICrypt::shorthash(const PIString& s, PIByteArray key) {
	ullong hash = 0;
#ifdef PIP_CRYPT
	if (crypto_shorthash_BYTES != sizeof(hash)) piCout << "[PICrypt]" << "internal error: bad hash size";
	if (!init()) return hash;
	if (key.size() != crypto_shorthash_KEYBYTES) {
		piCout << "[PICrypt]" << "invalid key size" << key.size() << ", shoud be" << crypto_shorthash_KEYBYTES << ", filled zeros";
		key.resize(crypto_shorthash_KEYBYTES, 0);
	}
	PIByteArray in(s.data(), s.size());
	crypto_shorthash((uchar *)&hash, in.data(), in.size(), key.data());
#else
	PICRYPT_DISABLED_WARNING
#endif
	return hash;
}


PIByteArray PICrypt::generateKey() {
	PIByteArray hash;
#ifdef PIP_CRYPT
	if (!init()) return hash;
	hash.resize(crypto_secretbox_KEYBYTES);
	randombytes_buf(hash.data(), hash.size());
#else
	PICRYPT_DISABLED_WARNING
#endif
	return hash;
}


PIByteArray PICrypt::generateRandomBuff(int size) {
	PIByteArray hash;
#ifdef PIP_CRYPT
	if (!init() || size <= 0) return hash;
	hash.resize(size);
	randombytes_buf(hash.data(), hash.size());
#else
	PICRYPT_DISABLED_WARNING
#endif
	return hash;
}


size_t PICrypt::sizeKey() {
#ifdef PIP_CRYPT
	return crypto_secretbox_KEYBYTES;
#else
	PICRYPT_DISABLED_WARNING
#endif
	return 0;
}


size_t PICrypt::sizeCrypt() {
#ifdef PIP_CRYPT
	return crypto_secretbox_MACBYTES + crypto_secretbox_NONCEBYTES;
#else
	PICRYPT_DISABLED_WARNING
#endif
	return 0;
}


void PICrypt::generateSignKeys(PIByteArray & public_key, PIByteArray & secret_key) {
#ifdef PIP_CRYPT
	if (!init()) return;
	public_key.resize(crypto_sign_PUBLICKEYBYTES);
	secret_key.resize(crypto_sign_SECRETKEYBYTES);
	crypto_sign_keypair(public_key.data(), secret_key.data());
#else
	PICRYPT_DISABLED_WARNING
#endif
}


void PICrypt::generateSignKeys(PIByteArray & public_key, PIByteArray & secret_key, const PIByteArray & seed) {
#ifdef PIP_CRYPT
	if (!init() || seed.isEmpty()) return;
	public_key.resize(crypto_sign_PUBLICKEYBYTES);
	secret_key.resize(crypto_sign_SECRETKEYBYTES);
	crypto_sign_seed_keypair(public_key.data(), secret_key.data(), hash(seed).data());
#else
	PICRYPT_DISABLED_WARNING
#endif
}


PIByteArray PICrypt::extractSignPublicKey(const PIByteArray & secret_key) {
	PIByteArray pk;
#ifdef PIP_CRYPT
	if (!init() || secret_key.size() != crypto_sign_SECRETKEYBYTES) return pk;
	pk.resize(crypto_sign_PUBLICKEYBYTES);
	crypto_sign_ed25519_sk_to_pk(pk.data(), secret_key.data());
#else
	PICRYPT_DISABLED_WARNING
#endif
	return pk;
}


PIByteArray PICrypt::signMessage(const PIByteArray & data, PIByteArray secret_key) {
	PIByteArray sign;
#ifdef PIP_CRYPT
	if (!init()) return sign;
	sign.resize(crypto_sign_BYTES);
	crypto_sign_detached(sign.data(), 0, data.data(), data.size(), secret_key.data());
#else
	PICRYPT_DISABLED_WARNING
#endif
	return sign;
}


bool PICrypt::verifySign(const PIByteArray & data, const PIByteArray & signature, PIByteArray public_key) {
#ifdef PIP_CRYPT
	if (!init()) return false;
	return (crypto_sign_verify_detached(signature.data(), data.data(), data.size(), public_key.data()) == 0);
#else
	PICRYPT_DISABLED_WARNING
#endif
	return false;
}


void PICrypt::generateKeypair(PIByteArray & public_key, PIByteArray & secret_key) {
#ifdef PIP_CRYPT
	if (!init()) return;
	public_key.resize(crypto_box_PUBLICKEYBYTES);
	secret_key.resize(crypto_box_SECRETKEYBYTES);
	crypto_box_keypair(public_key.data(), secret_key.data());
#else
	PICRYPT_DISABLED_WARNING
#endif
}


void PICrypt::generateKeypair(PIByteArray & public_key, PIByteArray & secret_key, const PIByteArray & seed) {
#ifdef PIP_CRYPT
	if (!init()) return;
	public_key.resize(crypto_box_PUBLICKEYBYTES);
	secret_key.resize(crypto_box_SECRETKEYBYTES);
	crypto_box_seed_keypair(public_key.data(), secret_key.data(), hash(seed).data());
#else
	PICRYPT_DISABLED_WARNING
#endif
}


PIByteArray PICrypt::crypt(const PIByteArray & data, const PIByteArray & public_key, const PIByteArray & secret_key) {
	PIByteArray ret;
#ifdef PIP_CRYPT
	if (!init()) return ret;
	if (public_key.size() != crypto_box_PUBLICKEYBYTES)
		return ret;
	if (secret_key.size() != crypto_box_SECRETKEYBYTES)
		return ret;
	PIByteArray n;
	ret.resize(data.size() + crypto_box_MACBYTES);
	n.resize(crypto_box_NONCEBYTES);
	randombytes_buf(n.data(), n.size());
	if (crypto_box_easy(ret.data(), data.data(), data.size(), n.data(), public_key.data(), secret_key.data()) != 0)
		return PIByteArray();
	ret.append(n);
#else
	PICRYPT_DISABLED_WARNING
#endif
	return ret;
}


PIByteArray PICrypt::decrypt(const PIByteArray & crypt_data, const PIByteArray & public_key, const PIByteArray & secret_key, bool * ok) {
	PIByteArray ret;
#ifdef PIP_CRYPT
	if (!init()) return ret;
	if (public_key.size() != crypto_box_PUBLICKEYBYTES) {
		if (ok) *ok = false;
		return ret;
	}
	if (secret_key.size() != crypto_box_SECRETKEYBYTES) {
		if (ok) *ok = false;
		return ret;
	}
	if (crypt_data.size() < crypto_box_NONCEBYTES + crypto_box_MACBYTES) {
		if (ok) *ok = false;
		return ret;
	}
	PIByteArray n;
	n.resize(crypto_secretbox_NONCEBYTES);
	ret.resize(crypt_data.size() - n.size() - crypto_secretbox_MACBYTES);
	memcpy(n.data(), crypt_data.data(crypt_data.size() - n.size()), n.size());
	if (crypto_box_open_easy(ret.data(), crypt_data.data(), crypt_data.size() - n.size(), n.data(), public_key.data(), secret_key.data()) != 0) {
		if (ok) *ok = false;
		//			piCout << "[PICrypt]" << "bad key_";
		return PIByteArray();
	} else if (ok) *ok = true;
#else
	PICRYPT_DISABLED_WARNING
#endif
	return ret;
}


PIByteArray PICrypt::passwordHash(const PIString & password, const PIByteArray & seed) {
#ifdef crypto_pwhash_ALG_ARGON2I13
//	char out[crypto_pwhash_STRBYTES];
	PIByteArray pass = password.toUTF8();
	PIByteArray n = hash(seed);
	PIByteArray ph;
	ph.resize(crypto_box_SEEDBYTES);
	n.resize(crypto_pwhash_SALTBYTES);
//	randombytes_buf(n.data(), n.size());
//	crypto_shorthash(n.data(), seed.data(), seed.size(), PIByteArray(crypto_shorthash_KEYBYTES).data());
	int r = crypto_pwhash(ph.data(), ph.size(), (const char*)pass.data(), pass.size(), n.data(), crypto_pwhash_argon2i_opslimit_moderate(), crypto_pwhash_argon2i_memlimit_moderate(), crypto_pwhash_ALG_ARGON2I13);
	//crypto_pwhash_str(out, (const char*)pass.data(), pass.size(), crypto_pwhash_argon2i_opslimit_moderate(), crypto_pwhash_argon2i_memlimit_moderate());
	pass.fill(0);
	if (r != 0) return PIByteArray();
	return ph;
//	PIByteArray ret;
//	ret << ph << n << crypto_pwhash_argon2i_opslimit_moderate() << crypto_pwhash_argon2i_memlimit_moderate();
//	return ret;
#else
	return PIByteArray();
#endif
}


PIString PICrypt::version() {
#ifdef PIP_CRYPT
	return SODIUM_VERSION_STRING;
#else
	return PIString();
#endif
}


bool PICrypt::init() {
#ifdef PIP_CRYPT
	static bool inited = false;
	if (inited) return true;
	//piCout << "[PICrypt]" << "init ...";
	inited = sodium_init();
	if (!inited)
		inited = sodium_init();
	//piCout << "[PICrypt]" << "init" << inited;
	return inited;
#else
	PICRYPT_DISABLED_WARNING
#endif
	return false;
}



