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
144
145
146
147
148
149
150
151
|
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 Ed25519PrivateKeyParameters
: AsymmetricKeyParameter
{
public static readonly int KeySize = Ed25519.SecretKeySize;
public static readonly int SignatureSize = Ed25519.SignatureSize;
private readonly byte[] data = new byte[KeySize];
private Ed25519PublicKeyParameters cachedPublicKey;
public Ed25519PrivateKeyParameters(SecureRandom random)
: base(true)
{
Ed25519.GeneratePrivateKey(random, data);
}
public Ed25519PrivateKeyParameters(byte[] buf)
: this(Validate(buf), 0)
{
}
public Ed25519PrivateKeyParameters(byte[] buf, int off)
: base(true)
{
Array.Copy(buf, off, data, 0, KeySize);
}
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
public Ed25519PrivateKeyParameters(ReadOnlySpan<byte> buf)
: base(true)
{
if (buf.Length != KeySize)
throw new ArgumentException("must have length " + KeySize, nameof(buf));
buf.CopyTo(data);
}
#endif
public Ed25519PrivateKeyParameters(Stream input)
: base(true)
{
if (KeySize != Streams.ReadFully(input, data))
throw new EndOfStreamException("EOF encountered in middle of Ed25519 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 Ed25519PublicKeyParameters GeneratePublicKey()
{
lock (data)
{
if (null == cachedPublicKey)
{
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
cachedPublicKey = new Ed25519PublicKeyParameters(Ed25519.GeneratePublicKey(data));
#else
cachedPublicKey = new Ed25519PublicKeyParameters(Ed25519.GeneratePublicKey(data, 0));
#endif
}
return cachedPublicKey;
}
}
public void Sign(Ed25519.Algorithm algorithm, byte[] ctx, byte[] msg, int msgOff, int msgLen,
byte[] sig, int sigOff)
{
Ed25519PublicKeyParameters publicKey = GeneratePublicKey();
byte[] pk = new byte[Ed25519.PublicKeySize];
publicKey.Encode(pk, 0);
switch (algorithm)
{
case Ed25519.Algorithm.Ed25519:
{
if (null != ctx)
throw new ArgumentOutOfRangeException(nameof(ctx));
Ed25519.Sign(data, 0, pk, 0, msg, msgOff, msgLen, sig, sigOff);
break;
}
case Ed25519.Algorithm.Ed25519ctx:
{
if (null == ctx)
throw new ArgumentNullException(nameof(ctx));
if (ctx.Length > 255)
throw new ArgumentOutOfRangeException(nameof(ctx));
Ed25519.Sign(data, 0, pk, 0, ctx, msg, msgOff, msgLen, sig, sigOff);
break;
}
case Ed25519.Algorithm.Ed25519ph:
{
if (null == ctx)
throw new ArgumentNullException(nameof(ctx));
if (ctx.Length > 255)
throw new ArgumentOutOfRangeException(nameof(ctx));
if (Ed25519.PrehashSize != msgLen)
throw new ArgumentOutOfRangeException(nameof(msgLen));
Ed25519.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;
}
}
}
|
