dlech.SshAgentLib.BlobParser.ReadSsh2PublicKeyData C# (CSharp) Метод

        public AsymmetricKeyParameter ReadSsh2PublicKeyData()
        {
            var algorithm = Encoding.UTF8.GetString(ReadBlob());

              switch (algorithm) {
            case PublicKeyAlgorithmExt.ALGORITHM_RSA_KEY:
              var rsaN = new BigInteger(1, ReadBlob()); // modulus
              var rsaE = new BigInteger(1, ReadBlob()); // exponent
              if (rsaN.BitLength < rsaE.BitLength) {
            // In some cases, the modulus is first. We can always tell because
            // it is significantly larget than the exponent.
            return new RsaKeyParameters(false, rsaE, rsaN);
              }
              return new RsaKeyParameters(false, rsaN, rsaE);

            case PublicKeyAlgorithmExt.ALGORITHM_DSA_KEY:
              var dsaP = new BigInteger(1, ReadBlob());
              var dsaQ = new BigInteger(1, ReadBlob());
              var dsaG = new BigInteger(1, ReadBlob());
              var dsaY = new BigInteger(1, ReadBlob()); // public key

              var dsaParams = new DsaParameters(dsaP, dsaQ, dsaG);
              return new DsaPublicKeyParameters(dsaY, dsaParams);

            case PublicKeyAlgorithmExt.ALGORITHM_ECDSA_SHA2_NISTP256_KEY:
            case PublicKeyAlgorithmExt.ALGORITHM_ECDSA_SHA2_NISTP384_KEY:
            case PublicKeyAlgorithmExt.ALGORITHM_ECDSA_SHA2_NISTP521_KEY:

              var ecdsaCurveName = ReadString();
              var ecdsaPublicKey = ReadBlob();

              switch (ecdsaCurveName) {
            case PublicKeyAlgorithmExt.EC_ALGORITHM_NISTP256:
              ecdsaCurveName = "secp256r1";
              break;
            case PublicKeyAlgorithmExt.EC_ALGORITHM_NISTP384:
              ecdsaCurveName = "secp384r1";
              break;
            case PublicKeyAlgorithmExt.EC_ALGORITHM_NISTP521:
              ecdsaCurveName = "secp521r1";
              break;
            default:
              throw new Exception("Unsupported EC algorithm: " + ecdsaCurveName);
              }
              var ecdsaX9Params = SecNamedCurves.GetByName(ecdsaCurveName);
              var ecdsaDomainParams = new ECDomainParameters(ecdsaX9Params.Curve,
            ecdsaX9Params.G, ecdsaX9Params.N, ecdsaX9Params.H);
              var ecdsaPoint = ecdsaX9Params.Curve.DecodePoint(ecdsaPublicKey);
              return new ECPublicKeyParameters(ecdsaPoint, ecdsaDomainParams);

            case PublicKeyAlgorithmExt.ALGORITHM_ED25519:
            var ed25519PublicKey = ReadBlob();
            return new Ed25519PublicKeyParameter(ed25519PublicKey);

            default:
              // unsupported encryption algorithm
              throw new Exception("Unsupported algorithm");
              }
        }

        public override object Deserialize(Stream stream)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }
            using (var reader = new StreamReader(stream)) {
                var line = reader.ReadLine();
                line = line.Trim();
                var algoName = new string(line.TakeWhile(c => !char.IsWhiteSpace(c)).ToArray());
                line = line.Substring(algoName.Length).Trim();
                var data = new string(line.TakeWhile(c => !char.IsWhiteSpace(c)).ToArray());
                line = line.Substring(data.Length).Trim();
                var comment = line;

                PublicKeyAlgorithm algo;
                if (!TryParsePublicKeyAlgorithm(algoName, out algo))
                {
                    var message = string.Format("Unknown algorithm: {0}", algoName);
                    throw new KeyFormatterException(message);
                }

                var parser = new BlobParser(Util.FromBase64(data));
                OpensshCertificate cert;
                var publicKeyParams = parser.ReadSsh2PublicKeyData(out cert);
                var key             = new SshKey(SshVersion.SSH2, publicKeyParams, null, comment, cert);
                return(key);
            }
        }