private static void CheckEd448Vector(string sSK, string sPK, string sM, string sCTX, string sSig, string text)
{
byte[] sk = Hex.Decode(sSK);
byte[] pk = Hex.Decode(sPK);
byte[] pkGen = new byte[Ed448.PublicKeySize];
Ed448.GeneratePublicKey(sk, 0, pkGen, 0);
Assert.IsTrue(Arrays.AreEqual(pk, pkGen), text);
byte[] m = Hex.Decode(sM);
byte[] ctx = Hex.Decode(sCTX);
byte[] sig = Hex.Decode(sSig);
byte[] sigGen = new byte[Ed448.SignatureSize];
byte[] badsig = Arrays.Clone(sig);
badsig[Ed448.SignatureSize - 1] ^= 0x80;
Ed448.Sign(sk, 0, ctx, m, 0, m.Length, sigGen, 0);
Assert.IsTrue(Arrays.AreEqual(sig, sigGen), text);
Ed448.Sign(sk, 0, pk, 0, ctx, m, 0, m.Length, sigGen, 0);
Assert.IsTrue(Arrays.AreEqual(sig, sigGen), text);
bool shouldVerify = Ed448.Verify(sig, 0, pk, 0, ctx, m, 0, m.Length);
Assert.IsTrue(shouldVerify, text);
bool shouldNotVerify = Ed448.Verify(badsig, 0, pk, 0, ctx, m, 0, m.Length);
Assert.IsFalse(shouldNotVerify, text);
}
public void TestEd448Consistency()
{
byte[] sk = new byte[Ed448.SecretKeySize];
byte[] pk = new byte[Ed448.PublicKeySize];
byte[] ctx = new byte[Random.NextInt() & 7];
byte[] m = new byte[255];
byte[] sig1 = new byte[Ed448.SignatureSize];
byte[] sig2 = new byte[Ed448.SignatureSize];
Random.NextBytes(ctx);
Random.NextBytes(m);
for (int i = 0; i < 10; ++i)
{
Random.NextBytes(sk);
Ed448.GeneratePublicKey(sk, 0, pk, 0);
int mLen = Random.NextInt() & 255;
Ed448.Sign(sk, 0, ctx, m, 0, mLen, sig1, 0);
Ed448.Sign(sk, 0, pk, 0, ctx, m, 0, mLen, sig2, 0);
Assert.IsTrue(Arrays.AreEqual(sig1, sig2), "Ed448 consistent signatures #" + i);
bool shouldVerify = Ed448.Verify(sig1, 0, pk, 0, ctx, m, 0, mLen);
Assert.IsTrue(shouldVerify, "Ed448 consistent sign/verify #" + i);
sig1[Ed448.PublicKeySize - 1] ^= 0x80;
bool shouldNotVerify = Ed448.Verify(sig1, 0, pk, 0, ctx, m, 0, mLen);
Assert.IsFalse(shouldNotVerify, "Ed448 consistent verification failure #" + i);
}
}
public Ed448PublicKeyParameters GeneratePublicKey()
{
lock (data)
{
if (null == cachedPublicKey)
{
byte[] publicKey = new byte[Ed448.PublicKeySize];
Ed448.GeneratePublicKey(data, 0, publicKey, 0);
cachedPublicKey = new Ed448PublicKeyParameters(publicKey, 0);
}
return(cachedPublicKey);
}
}
public void TestPublicKeyValidationPartial()
{
Assert.IsTrue(Ed448.ValidatePublicKeyPartial(Neutral, 0));
byte[] sk = new byte[Ed448.SecretKeySize];
byte[] pk = new byte[Ed448.PublicKeySize];
for (int i = 0; i < 10; ++i)
{
Random.NextBytes(sk);
Ed448.GeneratePublicKey(sk, 0, pk, 0);
Assert.IsTrue(Ed448.ValidatePublicKeyPartial(pk, 0));
}
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080"), 0));
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00"), 0));
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF80"), 0));
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"), 0));
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000081"), 0));
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("C784B7238BDDDB84C44FB80936FB103FCF39C1F74EE83163A57DB4AD3946FDC81BF0504D6EC1DBABABDB750997BCA465D5FCD3A45F8E183D00"), 0));
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("149578BCA53F7D199B472D6D367D22A35942BBCA2051F833122D4DC12FE758A16D672A54D5F8C390C44C2F8B32F21121DA69E9DE8FF9675780"), 0));
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("9E9F6E7A8576E8D7C286C493FE76559419012B164589DF764E735CFFDE21BFCAF4D7553F9B37178A2F20C77473E4195E3E1E327F3174C14500"), 0));
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("1979BDCBE0CEC16602B87257114059029605C720D5AFD2A90EF4B06655B34B561EBA6C1034452C3D8D1DA41C57340B0C9A95297E712CA75C00"), 0));
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("E2B8507036D478F262A7009734CDD383734002CE32397FEA22BFEDEE0CEBB0064D176FB45A05AF19F8B18B07EE20D6E2320D075E95DAF15200"), 0));
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("3C2FFFFCF504A0EBD8051B3962546C39410464A9C44DC3E82FA9437F2450F0F93C892F28E2ABDF7EA84B051E5536CCA6B44762D0941C5D0700"), 0));
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("997FE46037CF6207B27B6D0BB9D7D97A038D5BFCF898D07EE6ED07953F0889CC4745D1E018EB7A894EFE88871004452E99C6A344362DA6E080"), 0));
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("F67C319B8EDCE2E85D450BE46E1671183EB499CE8ABE56BCF666C13A99C5ECBC89FCE9B3B578E2A5D061D3590506BC27614DB6B0C682971B80"), 0));
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("A7776DDD0BD52EC4D017478E38700395F9F4C45A3BEFFE4EA9994EA1A9E92D8D1CC56539BF57FF88401BBDC764904BC0E3635AEE1721FD3380"), 0));
Assert.IsFalse(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("9F914CD9920D2B75ADBF34F758DA39BB35D1C81B5C480571A7A8B2CAAD7BA0F32D13AF9C69B0BECE5775B324DC49C063354EA2F6F231A23800"), 0));
Assert.IsTrue(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("2E0ACAB5953BC2F22C557C75E6B86225BE9CB3E82E78FC886EB57B628229C0C9548CD82630483C03D0E5DC02B2C3B1BD0E5DEE0B8DE4A88000"), 0));
Assert.IsTrue(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("0F89D2E413A36A33031329169EFAAE88D8F84E90E741C3DFBB01C32544D995FF6EB354B6C5C29E62ACC124E806540C46CB0C0ED71931B39D00"), 0));
Assert.IsTrue(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("AB553809FE1B027328EC7DBE71929C1F3A435B74CC0C06BEA831BC5E287EF2ACF4E831EC8E0C964A80BF85B966D32CADAE8E17E12EAFD3AF80"), 0));
Assert.IsTrue(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("3043631378826937A822BDB8878DC33B9174BEC3530B2A8A4048F6B06B378DBC450E34ED623E47B1449E7636DAFB72F584605EF3BE01647F00"), 0));
Assert.IsTrue(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("8A03959C8BD20BA7B1DA92A4C5591BC846F4CD8BE07387B325E179BB12245E17BDDE1AC82E9F7CAB2A79DDDBE68F8BA8DB7F03F91156C24A00"), 0));
Assert.IsTrue(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("46299C8D31BAFEBBCF1719A851123CC4722E5BE9D93D8F98C215D34082AF658C570B4CFD44079993CBC19B0EAD3BFD0DFB2B67EBABB119B780"), 0));
Assert.IsTrue(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("81A58C03708DD60BD68237622EC9934E8DE27FE7997F74A501B06C60C8F9D68856E7D12B88F1507E29EB0C30531B5AA353F154F2551AF5E580"), 0));
Assert.IsTrue(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("DC5028F5AA0B9217B40C7FE00E10503C37B6611BA87CDD70F01536E87AD659711BA1265E679F94EC8D5ED87476CE031D14B2C7E46268F11A80"), 0));
Assert.IsTrue(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("910DDFE36AAB6DCB7D5B72E6F2DF0769AD86665262232C487F722FEA85429DE247D1EBBC5C579A01D04672894E2B0F3FBDF22B43EA191DF700"), 0));
Assert.IsTrue(Ed448.ValidatePublicKeyPartial(Hex.DecodeStrict("43482D0750D4830AAAF578346288050EAE8ADF96DF66F243E73252114E432B448730517FD8726871508CAD7ECECFDB33120CA5558788B6C800"), 0));
}
public void TestEd448phConsistency()
{
byte[] sk = new byte[Ed448.SecretKeySize];
byte[] pk = new byte[Ed448.PublicKeySize];
byte[] ctx = new byte[Random.NextInt() & 7];
byte[] m = new byte[255];
byte[] ph = new byte[Ed448.PrehashSize];
byte[] sig1 = new byte[Ed448.SignatureSize];
byte[] sig2 = new byte[Ed448.SignatureSize];
Random.NextBytes(ctx);
Random.NextBytes(m);
for (int i = 0; i < 10; ++i)
{
Random.NextBytes(sk);
Ed448.GeneratePublicKey(sk, 0, pk, 0);
int mLen = Random.NextInt() & 255;
IXof prehash = Ed448.CreatePrehash();
prehash.BlockUpdate(m, 0, mLen);
prehash.DoFinal(ph, 0, ph.Length);
Ed448.SignPrehash(sk, 0, ctx, ph, 0, sig1, 0);
Ed448.SignPrehash(sk, 0, pk, 0, ctx, ph, 0, sig2, 0);
Assert.IsTrue(Arrays.AreEqual(sig1, sig2), "Ed448ph consistent signatures #" + i);
bool shouldVerify = Ed448.VerifyPrehash(sig1, 0, pk, 0, ctx, ph, 0);
Assert.IsTrue(shouldVerify, "Ed448ph consistent sign/verify #" + i);
sig1[Ed448.PublicKeySize - 1] ^= 0x80;
bool shouldNotVerify = Ed448.VerifyPrehash(sig1, 0, pk, 0, ctx, ph, 0);
Assert.IsFalse(shouldNotVerify, "Ed448ph consistent verification failure #" + i);
}
}
public void Sign(Ed448.Algorithm algorithm, Ed448PublicKeyParameters publicKey, byte[] ctx, byte[] msg, int msgOff, int msgLen,
byte[] sig, int sigOff)
{
byte[] pk = new byte[Ed448.PublicKeySize];
if (null == publicKey)
{
Ed448.GeneratePublicKey(data, 0, pk, 0);
}
else
{
publicKey.Encode(pk, 0);
}
switch (algorithm)
{
case Ed448.Algorithm.Ed448:
{
Ed448.Sign(data, 0, pk, 0, ctx, msg, msgOff, msgLen, sig, sigOff);
break;
}
case Ed448.Algorithm.Ed448ph:
{
if (Ed448.PrehashSize != msgLen)
{
throw new ArgumentException("msgLen");
}
Ed448.SignPrehash(data, 0, pk, 0, ctx, msg, msgOff, sig, sigOff);
break;
}
default:
{
throw new ArgumentException("algorithm");
}
}
}
private static void CheckEd448phVector(string sSK, string sPK, string sM, string sCTX, string sSig, string text)
{
byte[] sk = Hex.Decode(sSK);
byte[] pk = Hex.Decode(sPK);
byte[] pkGen = new byte[Ed448.PublicKeySize];
Ed448.GeneratePublicKey(sk, 0, pkGen, 0);
Assert.IsTrue(Arrays.AreEqual(pk, pkGen), text);
byte[] m = Hex.Decode(sM);
byte[] ctx = Hex.Decode(sCTX);
byte[] sig = Hex.Decode(sSig);
byte[] badsig = Arrays.Clone(sig);
badsig[Ed448.SignatureSize - 1] ^= 0x80;
byte[] sigGen = new byte[Ed448.SignatureSize];
{
IXof prehash = Ed448.CreatePrehash();
prehash.BlockUpdate(m, 0, m.Length);
byte[] ph = new byte[Ed448.PrehashSize];
prehash.DoFinal(ph, 0, ph.Length);
Ed448.SignPrehash(sk, 0, ctx, ph, 0, sigGen, 0);
Assert.IsTrue(Arrays.AreEqual(sig, sigGen), text);
Ed448.SignPrehash(sk, 0, pk, 0, ctx, ph, 0, sigGen, 0);
Assert.IsTrue(Arrays.AreEqual(sig, sigGen), text);
bool shouldVerify = Ed448.VerifyPrehash(sig, 0, pk, 0, ctx, ph, 0);
Assert.IsTrue(shouldVerify, text);
bool shouldNotVerify = Ed448.VerifyPrehash(badsig, 0, pk, 0, ctx, ph, 0);
Assert.IsFalse(shouldNotVerify, text);
}
{
IXof ph = Ed448.CreatePrehash();
ph.BlockUpdate(m, 0, m.Length);
Ed448.SignPrehash(sk, 0, ctx, ph, sigGen, 0);
Assert.IsTrue(Arrays.AreEqual(sig, sigGen), text);
}
{
IXof ph = Ed448.CreatePrehash();
ph.BlockUpdate(m, 0, m.Length);
Ed448.SignPrehash(sk, 0, pk, 0, ctx, ph, sigGen, 0);
Assert.IsTrue(Arrays.AreEqual(sig, sigGen), text);
}
{
IXof ph = Ed448.CreatePrehash();
ph.BlockUpdate(m, 0, m.Length);
bool shouldVerify = Ed448.VerifyPrehash(sig, 0, pk, 0, ctx, ph);
Assert.IsTrue(shouldVerify, text);
}
{
IXof ph = Ed448.CreatePrehash();
ph.BlockUpdate(m, 0, m.Length);
bool shouldNotVerify = Ed448.VerifyPrehash(badsig, 0, pk, 0, ctx, ph);
Assert.IsFalse(shouldNotVerify, text);
}
}
public Ed448PublicKeyParameters GeneratePublicKey()
{
byte[] publicKey = new byte[Ed448.PublicKeySize];
Ed448.GeneratePublicKey(data, 0, publicKey, 0);
return(new Ed448PublicKeyParameters(publicKey, 0));
}