exa/codecrypt
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

algos_sig: new cubehash-based algorithms

Browse source
This commit is contained in:
Mirek Kratochvil 2013-09-29 20:53:24 +02:00
parent c65557724e
commit 72bcc1080a
3 changed files with 344 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/algo_suite.cpp
View file

@ -37,5 +37,11 @@ void fill_algorithm_suite (algorithm_suite&s)
do_alg (algo_mceqd128cube); do_alg (algo_mceqd128cube);
do_alg (algo_mceqd192cube); do_alg (algo_mceqd192cube);
do_alg (algo_mceqd256cube); do_alg (algo_mceqd256cube);
do_alg (algo_fmtseq128cube);
do_alg (algo_fmtseq192cube);
do_alg (algo_fmtseq256cube);
do_alg (algo_fmtseq128h20cube);
do_alg (algo_fmtseq192h20cube);
do_alg (algo_fmtseq256h20cube);
#undef do_alg #undef do_alg
} }

276
src/algos_sig.cpp
View file

@ -90,11 +90,11 @@ static void msg_pad (const bvector&in, std::vector<byte>&out, size_t minsize)
*/ */
template <int h, int l, int hs, class message_hash, class tree_hash> template <int h, int l, int hs, class message_hash, class tree_hash>
int fmtseq_generic_sign (const bvector&msg, static int fmtseq_generic_sign (const bvector&msg,
bvector&sig, bvector&sig,
sencode**privkey, sencode**privkey,
bool&dirty, bool&dirty,
prng&rng) prng&rng)
{ {
//load the key //load the key
fmtseq::privkey Priv; fmtseq::privkey Priv;
@ -131,9 +131,9 @@ int fmtseq_generic_sign (const bvector&msg,
} }
template <int h, int l, int hs, class message_hash, class tree_hash> template <int h, int l, int hs, class message_hash, class tree_hash>
int fmtseq_generic_verify (const bvector&sig, static int fmtseq_generic_verify (const bvector&sig,
const bvector&msg, const bvector&msg,
sencode*pubkey) sencode*pubkey)
{ {
//load the key //load the key
fmtseq::pubkey Pub; fmtseq::pubkey Pub;
@ -161,6 +161,23 @@ int fmtseq_generic_verify (const bvector&sig,
return 0; return 0;
} }
template<class treehash, int hs, int h, int l>
static int fmtseq_create_keypair (sencode**pub, sencode**priv, prng&rng)
{
fmtseq::pubkey Pub;
fmtseq::privkey Priv;
treehash hf;
if (fmtseq::generate (Pub, Priv, rng, hf, hs, h, l) )
return 1;
*pub = Pub.serialize();
*priv = Priv.serialize();
return 0;
}
/* /*
* actual instantiations * actual instantiations
*/ */
@ -227,47 +244,20 @@ int algo_fmtseq256::verify (const bvector&sig,
int algo_fmtseq128::create_keypair (sencode**pub, sencode**priv, prng&rng) int algo_fmtseq128::create_keypair (sencode**pub, sencode**priv, prng&rng)
{ {
fmtseq::pubkey Pub; return fmtseq_create_keypair<rmd128hash, 256, 4, 4>
fmtseq::privkey Priv; (pub, priv, rng);
rmd128hash hf;
if (fmtseq::generate (Pub, Priv, rng, hf, 256, 4, 4) )
return 1;
*pub = Pub.serialize();
*priv = Priv.serialize();
return 0;
} }
int algo_fmtseq192::create_keypair (sencode**pub, sencode**priv, prng&rng) int algo_fmtseq192::create_keypair (sencode**pub, sencode**priv, prng&rng)
{ {
fmtseq::pubkey Pub; return fmtseq_create_keypair<tiger192hash, 384, 4, 4>
fmtseq::privkey Priv; (pub, priv, rng);
tiger192hash hf;
if (fmtseq::generate (Pub, Priv, rng, hf, 384, 4, 4) )
return 1;
*pub = Pub.serialize();
*priv = Priv.serialize();
return 0;
} }
int algo_fmtseq256::create_keypair (sencode**pub, sencode**priv, prng&rng) int algo_fmtseq256::create_keypair (sencode**pub, sencode**priv, prng&rng)
{ {
fmtseq::pubkey Pub; return fmtseq_create_keypair<sha256hash, 512, 4, 4>
fmtseq::privkey Priv; (pub, priv, rng);
sha256hash hf;
if (fmtseq::generate (Pub, Priv, rng, hf, 512, 4, 4) )
return 1;
*pub = Pub.serialize();
*priv = Priv.serialize();
return 0;
} }
/* /*
@ -339,46 +329,184 @@ int algo_fmtseq256h20::verify (const bvector&sig,
int algo_fmtseq128h20::create_keypair (sencode**pub, sencode**priv, prng&rng) int algo_fmtseq128h20::create_keypair (sencode**pub, sencode**priv, prng&rng)
{ {
fmtseq::pubkey Pub; return fmtseq_create_keypair<rmd128hash, 256, 4, 5>
fmtseq::privkey Priv; (pub, priv, rng);
rmd128hash hf;
if (fmtseq::generate (Pub, Priv, rng, hf, 256, 4, 5) )
return 1;
*pub = Pub.serialize();
*priv = Priv.serialize();
return 0;
} }
int algo_fmtseq192h20::create_keypair (sencode**pub, sencode**priv, prng&rng) int algo_fmtseq192h20::create_keypair (sencode**pub, sencode**priv, prng&rng)
{ {
fmtseq::pubkey Pub; return fmtseq_create_keypair<tiger192hash, 384, 4, 5>
fmtseq::privkey Priv; (pub, priv, rng);
tiger192hash hf;
if (fmtseq::generate (Pub, Priv, rng, hf, 384, 4, 5) )
return 1;
*pub = Pub.serialize();
*priv = Priv.serialize();
return 0;
} }
int algo_fmtseq256h20::create_keypair (sencode**pub, sencode**priv, prng&rng) int algo_fmtseq256h20::create_keypair (sencode**pub, sencode**priv, prng&rng)
{ {
fmtseq::pubkey Pub; return fmtseq_create_keypair<sha256hash, 512, 4, 5>
fmtseq::privkey Priv; (pub, priv, rng);
sha256hash hf;
if (fmtseq::generate (Pub, Priv, rng, hf, 512, 4, 5) )
return 1;
*pub = Pub.serialize();
*priv = Priv.serialize();
return 0;
} }
/*
* CubeHash variants of everything above.
*/
#include "cube_hash.h"
int algo_fmtseq128cube::sign (const bvector&msg,
bvector&sig,
sencode**privkey,
bool&dirty,
prng&rng)
{
return fmtseq_generic_sign
<4, 4, 256, cube256hash, cube128hash>
(msg, sig, privkey, dirty, rng);
}
int algo_fmtseq128cube::verify (const bvector&sig,
const bvector&msg,
sencode*pubkey)
{
return fmtseq_generic_verify
<4, 4, 256, cube256hash, cube128hash>
(sig, msg, pubkey);
}
int algo_fmtseq192cube::sign (const bvector&msg,
bvector&sig,
sencode**privkey,
bool&dirty,
prng&rng)
{
return fmtseq_generic_sign
<4, 4, 384, cube384hash, cube192hash>
(msg, sig, privkey, dirty, rng);
}
int algo_fmtseq192cube::verify (const bvector&sig,
const bvector&msg,
sencode*pubkey)
{
return fmtseq_generic_verify
<4, 4, 384, cube384hash, cube192hash>
(sig, msg, pubkey);
}
int algo_fmtseq256cube::sign (const bvector&msg,
bvector&sig,
sencode**privkey,
bool&dirty,
prng&rng)
{
return fmtseq_generic_sign
<4, 4, 512, cube512hash, cube256hash>
(msg, sig, privkey, dirty, rng);
}
int algo_fmtseq256cube::verify (const bvector&sig,
const bvector&msg,
sencode*pubkey)
{
return fmtseq_generic_verify
<4, 4, 512, cube512hash, cube256hash>
(sig, msg, pubkey);
}
int algo_fmtseq128cube::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
return fmtseq_create_keypair<cube128hash, 256, 4, 4>
(pub, priv, rng);
}
int algo_fmtseq192cube::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
return fmtseq_create_keypair<cube192hash, 384, 4, 4>
(pub, priv, rng);
}
int algo_fmtseq256cube::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
return fmtseq_create_keypair<cube256hash, 512, 4, 4>
(pub, priv, rng);
}
/*
* h=20 variants with cubehash.
*/
int algo_fmtseq128h20cube::sign (const bvector&msg,
bvector&sig,
sencode**privkey,
bool&dirty,
prng&rng)
{
return fmtseq_generic_sign
<4, 5, 256, cube256hash, cube128hash>
(msg, sig, privkey, dirty, rng);
}
int algo_fmtseq128h20cube::verify (const bvector&sig,
const bvector&msg,
sencode*pubkey)
{
return fmtseq_generic_verify
<4, 5, 256, cube256hash, cube128hash>
(sig, msg, pubkey);
}
int algo_fmtseq192h20cube::sign (const bvector&msg,
bvector&sig,
sencode**privkey,
bool&dirty,
prng&rng)
{
return fmtseq_generic_sign
<4, 5, 384, cube384hash, cube192hash>
(msg, sig, privkey, dirty, rng);
}
int algo_fmtseq192h20cube::verify (const bvector&sig,
const bvector&msg,
sencode*pubkey)
{
return fmtseq_generic_verify
<4, 5, 384, cube384hash, cube192hash>
(sig, msg, pubkey);
}
int algo_fmtseq256h20cube::sign (const bvector&msg,
bvector&sig,
sencode**privkey,
bool&dirty,
prng&rng)
{
return fmtseq_generic_sign
<4, 5, 512, cube512hash, cube256hash>
(msg, sig, privkey, dirty, rng);
}
int algo_fmtseq256h20cube::verify (const bvector&sig,
const bvector&msg,
sencode*pubkey)
{
return fmtseq_generic_verify
<4, 5, 512, cube512hash, cube256hash>
(sig, msg, pubkey);
}
int algo_fmtseq128h20cube::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
return fmtseq_create_keypair<cube128hash, 256, 4, 5>
(pub, priv, rng);
}
int algo_fmtseq192h20cube::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
return fmtseq_create_keypair<cube192hash, 384, 4, 5>
(pub, priv, rng);
}
int algo_fmtseq256h20cube::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
return fmtseq_create_keypair<cube256hash, 512, 4, 5>
(pub, priv, rng);
}

136
src/algos_sig.h
View file

@ -153,5 +153,141 @@ public:
int create_keypair (sencode**pub, sencode**priv, prng&rng); int create_keypair (sencode**pub, sencode**priv, prng&rng);
}; };
/*
* Cubehash variants
*/
class algo_fmtseq128cube : public algorithm
{
public:
bool provides_signatures() {
return true;
}
bool provides_encryption() {
return false;
}
std::string get_alg_id() {
return "FMTSEQ128-CUBE256-CUBE128";
}
virtual int sign (const bvector&msg, bvector&sig,
sencode** privkey, bool&dirty, prng&rng);
virtual int verify (const bvector&sig, const bvector&msg,
sencode* pubkey);
int create_keypair (sencode**pub, sencode**priv, prng&rng);
};
class algo_fmtseq192cube : public algorithm
{
public:
bool provides_signatures() {
return true;
}
bool provides_encryption() {
return false;
}
std::string get_alg_id() {
return "FMTSEQ192-CUBE384-CUBE192";
}
virtual int sign (const bvector&msg, bvector&sig,
sencode** privkey, bool&dirty, prng&rng);
virtual int verify (const bvector&sig, const bvector&msg,
sencode* pubkey);
int create_keypair (sencode**pub, sencode**priv, prng&rng);
};
class algo_fmtseq256cube : public algorithm
{
public:
bool provides_signatures() {
return true;
}
bool provides_encryption() {
return false;
}
std::string get_alg_id() {
return "FMTSEQ256-CUBE512-CUBE256";
}
virtual int sign (const bvector&msg, bvector&sig,
sencode** privkey, bool&dirty, prng&rng);
virtual int verify (const bvector&sig, const bvector&msg,
sencode* pubkey);
int create_keypair (sencode**pub, sencode**priv, prng&rng);
};
class algo_fmtseq128h20cube : public algorithm
{
public:
bool provides_signatures() {
return true;
}
bool provides_encryption() {
return false;
}
std::string get_alg_id() {
return "FMTSEQ128H20-CUBE256-CUBE128";
}
virtual int sign (const bvector&msg, bvector&sig,
sencode** privkey, bool&dirty, prng&rng);
virtual int verify (const bvector&sig, const bvector&msg,
sencode* pubkey);
int create_keypair (sencode**pub, sencode**priv, prng&rng);
};
class algo_fmtseq192h20cube : public algorithm
{
public:
bool provides_signatures() {
return true;
}
bool provides_encryption() {
return false;
}
std::string get_alg_id() {
return "FMTSEQ192H20-CUBE384-CUBE192";
}
virtual int sign (const bvector&msg, bvector&sig,
sencode** privkey, bool&dirty, prng&rng);
virtual int verify (const bvector&sig, const bvector&msg,
sencode* pubkey);
int create_keypair (sencode**pub, sencode**priv, prng&rng);
};
class algo_fmtseq256h20cube : public algorithm
{
public:
bool provides_signatures() {
return true;
}
bool provides_encryption() {
return false;
}
std::string get_alg_id() {
return "FMTSEQ256H20-CUBE512-CUBE256";
}
virtual int sign (const bvector&msg, bvector&sig,
sencode** privkey, bool&dirty, prng&rng);
virtual int verify (const bvector&sig, const bvector&msg,
sencode* pubkey);
int create_keypair (sencode**pub, sencode**priv, prng&rng);
};
#endif #endif