1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
using System;
using System.IO;
using Org.BouncyCastle.Math.EC.Rfc8032;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.Utilities;
using Org.BouncyCastle.Utilities.IO;
namespace Org.BouncyCastle.Crypto.Parameters
{
public sealed class Ed448PrivateKeyParameters
: AsymmetricKeyParameter
{
public static readonly int KeySize = Ed448.SecretKeySize;
public static readonly int SignatureSize = Ed448.SignatureSize;
private readonly byte[] data = new byte[KeySize];
private Ed448PublicKeyParameters cachedPublicKey;
public Ed448PrivateKeyParameters(SecureRandom random)
: base(true)
{
Ed448.GeneratePrivateKey(random, data);
}
public Ed448PrivateKeyParameters(byte[] buf)
: this(Validate(buf), 0)
{
}
public Ed448PrivateKeyParameters(byte[] buf, int off)
: base(true)
{
Array.Copy(buf, off, data, 0, KeySize);
}
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
public Ed448PrivateKeyParameters(ReadOnlySpan<byte> buf)
: base(true)
{
if (buf.Length != KeySize)
throw new ArgumentException("must have length " + KeySize, nameof(buf));
buf.CopyTo(data);
}
#endif
public Ed448PrivateKeyParameters(Stream input)
: base(true)
{
if (KeySize != Streams.ReadFully(input, data))
throw new EndOfStreamException("EOF encountered in middle of Ed448 private key");
}
public void Encode(byte[] buf, int off)
{
Array.Copy(data, 0, buf, off, KeySize);
}
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
public void Encode(Span<byte> buf)
{
data.CopyTo(buf);
}
#endif
public byte[] GetEncoded()
{
return Arrays.Clone(data);
}
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
internal ReadOnlySpan<byte> DataSpan => data;
internal ReadOnlyMemory<byte> DataMemory => data;
#endif
public Ed448PublicKeyParameters GeneratePublicKey()
{
lock (data)
{
if (null == cachedPublicKey)
{
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
cachedPublicKey = new Ed448PublicKeyParameters(Ed448.GeneratePublicKey(data));
#else
cachedPublicKey = new Ed448PublicKeyParameters(Ed448.GeneratePublicKey(data, 0));
#endif
}
return cachedPublicKey;
}
}
public void Sign(Ed448.Algorithm algorithm, byte[] ctx, byte[] msg, int msgOff, int msgLen,
byte[] sig, int sigOff)
{
Ed448PublicKeyParameters publicKey = GeneratePublicKey();
byte[] pk = new byte[Ed448.PublicKeySize];
publicKey.Encode(pk, 0);
switch (algorithm)
{
case Ed448.Algorithm.Ed448:
{
if (null == ctx)
throw new ArgumentNullException(nameof(ctx));
if (ctx.Length > 255)
throw new ArgumentOutOfRangeException(nameof(ctx));
Ed448.Sign(data, 0, pk, 0, ctx, msg, msgOff, msgLen, sig, sigOff);
break;
}
case Ed448.Algorithm.Ed448ph:
{
if (null == ctx)
throw new ArgumentNullException(nameof(ctx));
if (ctx.Length > 255)
throw new ArgumentOutOfRangeException(nameof(ctx));
if (Ed448.PrehashSize != msgLen)
throw new ArgumentOutOfRangeException(nameof(msgLen));
Ed448.SignPrehash(data, 0, pk, 0, ctx, msg, msgOff, sig, sigOff);
break;
}
default:
{
throw new ArgumentOutOfRangeException(nameof(algorithm));
}
}
}
private static byte[] Validate(byte[] buf)
{
if (buf.Length != KeySize)
throw new ArgumentException("must have length " + KeySize, nameof(buf));
return buf;
}
}
}
|
