trevor/SuperVPN
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init commit

Browse Source
This commit is contained in:
Andrey K. Choi
2025-10-09 09:57:24 +09:00
commit 4d551bd74f
6636 changed files with 1218703 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

233
output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Security/PublicKeyFactory.cs Normal file
View File

@@ -0,0 +1,233 @@
using System;
using System.IO;
using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Asn1.CryptoPro;
using Org.BouncyCastle.Asn1.EdEC;
using Org.BouncyCastle.Asn1.Oiw;
using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.Rosstandart;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Asn1.X9;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Math;
using Org.BouncyCastle.Math.EC;
namespace Org.BouncyCastle.Security;
public sealed class PublicKeyFactory
{
private PublicKeyFactory()
{
}
public static AsymmetricKeyParameter CreateKey(byte[] keyInfoData)
{
return CreateKey(SubjectPublicKeyInfo.GetInstance(Asn1Object.FromByteArray(keyInfoData)));
}
public static AsymmetricKeyParameter CreateKey(Stream inStr)
{
return CreateKey(SubjectPublicKeyInfo.GetInstance(Asn1Object.FromStream(inStr)));
}
public static AsymmetricKeyParameter CreateKey(SubjectPublicKeyInfo keyInfo)
{
AlgorithmIdentifier algorithmID = keyInfo.AlgorithmID;
DerObjectIdentifier algorithm = algorithmID.Algorithm;
if (algorithm.Equals(PkcsObjectIdentifiers.RsaEncryption) || algorithm.Equals(X509ObjectIdentifiers.IdEARsa) || algorithm.Equals(PkcsObjectIdentifiers.IdRsassaPss) || algorithm.Equals(PkcsObjectIdentifiers.IdRsaesOaep))
{
RsaPublicKeyStructure instance = RsaPublicKeyStructure.GetInstance(keyInfo.GetPublicKey());
return new RsaKeyParameters(isPrivate: false, instance.Modulus, instance.PublicExponent);
}
if (algorithm.Equals(X9ObjectIdentifiers.DHPublicNumber))
{
Asn1Sequence instance2 = Asn1Sequence.GetInstance(algorithmID.Parameters.ToAsn1Object());
DHPublicKey instance3 = DHPublicKey.GetInstance(keyInfo.GetPublicKey());
BigInteger value = instance3.Y.Value;
if (IsPkcsDHParam(instance2))
{
return ReadPkcsDHParam(algorithm, value, instance2);
}
DHDomainParameters instance4 = DHDomainParameters.GetInstance(instance2);
BigInteger value2 = instance4.P.Value;
BigInteger value3 = instance4.G.Value;
BigInteger value4 = instance4.Q.Value;
BigInteger j = null;
if (instance4.J != null)
{
j = instance4.J.Value;
}
DHValidationParameters validation = null;
DHValidationParms validationParms = instance4.ValidationParms;
if (validationParms != null)
{
byte[] bytes = validationParms.Seed.GetBytes();
BigInteger value5 = validationParms.PgenCounter.Value;
validation = new DHValidationParameters(bytes, value5.IntValue);
}
return new DHPublicKeyParameters(value, new DHParameters(value2, value3, value4, j, validation));
}
if (algorithm.Equals(PkcsObjectIdentifiers.DhKeyAgreement))
{
Asn1Sequence instance5 = Asn1Sequence.GetInstance(algorithmID.Parameters.ToAsn1Object());
DerInteger derInteger = (DerInteger)keyInfo.GetPublicKey();
return ReadPkcsDHParam(algorithm, derInteger.Value, instance5);
}
if (algorithm.Equals(OiwObjectIdentifiers.ElGamalAlgorithm))
{
ElGamalParameter elGamalParameter = new ElGamalParameter(Asn1Sequence.GetInstance(algorithmID.Parameters.ToAsn1Object()));
DerInteger derInteger2 = (DerInteger)keyInfo.GetPublicKey();
return new ElGamalPublicKeyParameters(derInteger2.Value, new ElGamalParameters(elGamalParameter.P, elGamalParameter.G));
}
if (algorithm.Equals(X9ObjectIdentifiers.IdDsa) || algorithm.Equals(OiwObjectIdentifiers.DsaWithSha1))
{
DerInteger derInteger3 = (DerInteger)keyInfo.GetPublicKey();
Asn1Encodable parameters = algorithmID.Parameters;
DsaParameters parameters2 = null;
if (parameters != null)
{
DsaParameter instance6 = DsaParameter.GetInstance(parameters.ToAsn1Object());
parameters2 = new DsaParameters(instance6.P, instance6.Q, instance6.G);
}
return new DsaPublicKeyParameters(derInteger3.Value, parameters2);
}
if (algorithm.Equals(X9ObjectIdentifiers.IdECPublicKey))
{
X962Parameters x962Parameters = new X962Parameters(algorithmID.Parameters.ToAsn1Object());
X9ECParameters x9ECParameters = ((!x962Parameters.IsNamedCurve) ? new X9ECParameters((Asn1Sequence)x962Parameters.Parameters) : ECKeyPairGenerator.FindECCurveByOid((DerObjectIdentifier)x962Parameters.Parameters));
Asn1OctetString s = new DerOctetString(keyInfo.PublicKeyData.GetBytes());
X9ECPoint x9ECPoint = new X9ECPoint(x9ECParameters.Curve, s);
ECPoint point = x9ECPoint.Point;
if (x962Parameters.IsNamedCurve)
{
return new ECPublicKeyParameters("EC", point, (DerObjectIdentifier)x962Parameters.Parameters);
}
ECDomainParameters parameters3 = new ECDomainParameters(x9ECParameters.Curve, x9ECParameters.G, x9ECParameters.N, x9ECParameters.H, x9ECParameters.GetSeed());
return new ECPublicKeyParameters(point, parameters3);
}
if (algorithm.Equals(CryptoProObjectIdentifiers.GostR3410x2001))
{
Gost3410PublicKeyAlgParameters gost3410PublicKeyAlgParameters = new Gost3410PublicKeyAlgParameters((Asn1Sequence)algorithmID.Parameters);
Asn1OctetString asn1OctetString;
try
{
asn1OctetString = (Asn1OctetString)keyInfo.GetPublicKey();
}
catch (IOException)
{
throw new ArgumentException("invalid info structure in GOST3410 public key");
}
byte[] octets = asn1OctetString.GetOctets();
byte[] array = new byte[32];
byte[] array2 = new byte[32];
for (int i = 0; i != array2.Length; i++)
{
array[i] = octets[31 - i];
}
for (int k = 0; k != array.Length; k++)
{
array2[k] = octets[63 - k];
}
ECDomainParameters byOid = ECGost3410NamedCurves.GetByOid(gost3410PublicKeyAlgParameters.PublicKeyParamSet);
if (byOid == null)
{
return null;
}
ECPoint q = byOid.Curve.CreatePoint(new BigInteger(1, array), new BigInteger(1, array2));
return new ECPublicKeyParameters("ECGOST3410", q, gost3410PublicKeyAlgParameters.PublicKeyParamSet);
}
if (algorithm.Equals(CryptoProObjectIdentifiers.GostR3410x94))
{
Gost3410PublicKeyAlgParameters gost3410PublicKeyAlgParameters2 = new Gost3410PublicKeyAlgParameters((Asn1Sequence)algorithmID.Parameters);
DerOctetString derOctetString;
try
{
derOctetString = (DerOctetString)keyInfo.GetPublicKey();
}
catch (IOException)
{
throw new ArgumentException("invalid info structure in GOST3410 public key");
}
byte[] octets2 = derOctetString.GetOctets();
byte[] array3 = new byte[octets2.Length];
for (int l = 0; l != octets2.Length; l++)
{
array3[l] = octets2[octets2.Length - 1 - l];
}
BigInteger y = new BigInteger(1, array3);
return new Gost3410PublicKeyParameters(y, gost3410PublicKeyAlgParameters2.PublicKeyParamSet);
}
if (algorithm.Equals(EdECObjectIdentifiers.id_X25519))
{
return new X25519PublicKeyParameters(GetRawKey(keyInfo, X25519PublicKeyParameters.KeySize), 0);
}
if (algorithm.Equals(EdECObjectIdentifiers.id_X448))
{
return new X448PublicKeyParameters(GetRawKey(keyInfo, X448PublicKeyParameters.KeySize), 0);
}
if (algorithm.Equals(EdECObjectIdentifiers.id_Ed25519))
{
return new Ed25519PublicKeyParameters(GetRawKey(keyInfo, Ed25519PublicKeyParameters.KeySize), 0);
}
if (algorithm.Equals(EdECObjectIdentifiers.id_Ed448))
{
return new Ed448PublicKeyParameters(GetRawKey(keyInfo, Ed448PublicKeyParameters.KeySize), 0);
}
if (algorithm.Equals(RosstandartObjectIdentifiers.id_tc26_gost_3410_12_256) || algorithm.Equals(RosstandartObjectIdentifiers.id_tc26_gost_3410_12_512))
{
byte[] str = ((DerOctetString)Asn1Object.FromByteArray(keyInfo.PublicKeyData.GetOctets())).str;
int num = 32;
if (algorithm.Equals(RosstandartObjectIdentifiers.id_tc26_gost_3410_12_512))
{
num = 64;
}
int num2 = 2 * num;
byte[] array4 = new byte[1 + num2];
array4[0] = 4;
for (int m = 1; m <= num; m++)
{
array4[m] = str[num - m];
array4[m + num] = str[num2 - m];
}
Gost3410PublicKeyAlgParameters instance7 = Gost3410PublicKeyAlgParameters.GetInstance(keyInfo.AlgorithmID.Parameters);
ECGost3410Parameters eCGost3410Parameters = new ECGost3410Parameters(new ECNamedDomainParameters(instance7.PublicKeyParamSet, ECGost3410NamedCurves.GetByOid(instance7.PublicKeyParamSet)), instance7.PublicKeyParamSet, instance7.DigestParamSet, instance7.EncryptionParamSet);
return new ECPublicKeyParameters(eCGost3410Parameters.Curve.DecodePoint(array4), eCGost3410Parameters);
}
throw new SecurityUtilityException("algorithm identifier in public key not recognised: " + algorithm);
}
private static byte[] GetRawKey(SubjectPublicKeyInfo keyInfo, int expectedSize)
{
byte[] octets = keyInfo.PublicKeyData.GetOctets();
if (expectedSize != octets.Length)
{
throw new SecurityUtilityException("public key encoding has incorrect length");
}
return octets;
}
private static bool IsPkcsDHParam(Asn1Sequence seq)
{
if (seq.Count == 2)
{
return true;
}
if (seq.Count > 3)
{
return false;
}
DerInteger instance = DerInteger.GetInstance(seq[2]);
DerInteger instance2 = DerInteger.GetInstance(seq[0]);
return instance.Value.CompareTo(BigInteger.ValueOf(instance2.Value.BitLength)) <= 0;
}
private static DHPublicKeyParameters ReadPkcsDHParam(DerObjectIdentifier algOid, BigInteger y, Asn1Sequence seq)
{
DHParameter dHParameter = new DHParameter(seq);
int l = dHParameter.L?.IntValue ?? 0;
DHParameters parameters = new DHParameters(dHParameter.P, dHParameter.G, null, l);
return new DHPublicKeyParameters(y, parameters, algOid);
}
}