Used to read PuTTY Private Key (.ppk) files
상속: KeyFormatter
예제 #1
0
        public void GetSSH2PublicKeyBlobTest()
        {
            byte[] actual, expected;
            PpkFormatter formatter = new PpkFormatter();
            ISshKey target;

            /* test RSA key */
            target = formatter.Deserialize(Resources.ssh2_rsa_no_passphrase_ppk);
            expected = Util.FromBase64(
              "AAAAB3NzaC1yc2EAAAABJQAAAIEAhWqdEs/lz1r4L8ZAAS76rX7hj3rrI/6FNlBw" +
              "6ERba2VFmn2AHxQwZmHHmqM+UtiY57angjD9fTbTzL74C0+f/NrRY+BYXf1cF+u5" +
              "XmjNKygrsIq3yPMZV4q8YcN/ls9COcynOQMIEmJF6Q0LD7Gt9Uv5yjqc2Ay7VVhG" +
              "qZNnIeE=");

            actual = target.GetPublicKeyBlob();
            Assert.That(expected, Is.EqualTo(actual));

            /* test DSA key */
            target = formatter.Deserialize(Resources.ssh2_dsa_no_passphrase_ppk);
            expected = Util.FromBase64(
                "AAAAB3NzaC1kc3MAAACBAMXDM56ty6fV+qDpMyZxobn5VB4L/E6zvOibUead6HBc" +
                "OHUibA97EKgooUbqJ9qFUOhhw8TaFtN0UtTLZoHjOWN3JdyugK+f2HYIxvhlvW60" +
                "8g0lfDU0G4KIXdZukTYm66C0jVSCIdHQ1Iz219JeaEZK00v6wEW7Pp7T7yE71W65" +
                "AAAAFQDcFrJ83lxI15fUnVl6TSYjB0H7IwAAAIAGatuDAwP1rkYqRH3MbwUTOpzr" +
                "k/qBYkWbM/8iJlYaWiHjl0rG0HxnwY8Dvb9Knk7Qp6KC8l58KRAiGMrOLBOfPntE" +
                "gejaXSejM6OARoOtt31IXfOMkbsjAFKFssN+RUDnTPvXPpcL5C3rO1Up4hO3FPqi" +
                "JQJpL50gTHnDG2Q4BgAAAIA7w6OX/G/pXHDU0M7xXtTN2SOhFQwP8+Tc6h9/Yw/w" +
                "M9zBXkqb5bdlqy9vRx72/1DXOjH08PIbvza7HfOLkhRri0TYBDJbufQOlK4vQPqF" +
                "0qhxkYfsgqrZBMBKbLKTZnNm+BW2dgu+QSud67b01IZPzS2i0Z4DgSja9vl3xong" +
                "Cw==");
            actual = target.GetPublicKeyBlob();
            Assert.That(expected, Is.EqualTo(actual));
        }
예제 #2
0
        public void EcdsaSigTest()
        {
            ISshKey target;

              PpkFormatter formatter = new PpkFormatter()
              {
            GetPassphraseCallbackMethod = _ =>
            {
              SecureString result = new SecureString();
              foreach (char c in "PageantSharp")
              {
            result.AppendChar(c);
              }
              return result;
            }
              };

              string[] keys = {
            "../../Resources/ecdsa-sha2-nistp256.ppk",
            "../../Resources/ecdsa-sha2-nistp256-no-passphrase.ppk",
            "../../Resources/ecdsa-sha2-nistp384.ppk",
            "../../Resources/ecdsa-sha2-nistp384-no-passphrase.ppk",
            "../../Resources/ecdsa-sha2-nistp521.ppk",
            "../../Resources/ecdsa-sha2-nistp521-no-passphrase.ppk"
              };
              string[] d = {
            "569f23328522cf93694b0cca6bafd7236cf8bea6a9aab098491e915b5d02f2e5",
            "9d4c19af9d289a8aa67d3b636504cd473e054be3373d334b5469e93e0a06be21",
            "200fcb19f9d72b2c0e163ff3869b05beda93536d862bedb5748ba2b6174d4af2aea731dfb8884ae956f4dcf7b138489d",
            "31a122fbf5c674ddbddbc03f96d4f26c534fd5df7eae896a8890c7bdd3de8c5324f06b1efe836870318f23c5a66a2495",
            "14904fd2a509104e86cd9247cf081088caffa124c263caf43ec7cdf5d6ee14a90" +
            "7de16d30561ed14155fbf651ecc5b66a7d329ffa949aa3dcbdd8efe9ea492a7001",
            "ef41441bc21c20ee38a8169855b618e5c76f34b067d8bbd85276de982aec60fc9" +
            "0114acad5fc599e83c8d6fc535fb36c5244908577b1138ff4eed7d7b6c9eb2d01"
              };
              for (int i = 0; i < keys.Length; ++i) {
            target = formatter.DeserializeFile(keys[i]);
            var priKeyParam = (ECPrivateKeyParameters) target.GetPrivateKeyParameters();
            Assert.That(priKeyParam.D.ToString(16), Is.EqualTo(d[i]));
              }
        }
예제 #3
0
        public void GetFingerprintTest()
        {
            var formatter1 = new Ssh1KeyFormatter();

            var rsaSsh1Target = formatter1.Deserialize(Resources.rsa1_1);
            var rsaSsh1ExpectedFingerprint = Resources.rsa1_1_fp.Trim();
            var rsaSsh1Actual = "MD5:" + rsaSsh1Target.GetMD5Fingerprint().ToHexString();
            Assert.That(rsaSsh1ExpectedFingerprint, Is.EqualTo(rsaSsh1Actual));

            var formatter2 = new PpkFormatter();

            var rsaTarget = formatter2.Deserialize(Resources.ssh2_rsa_no_passphrase_ppk);
            var rsaExpectedFingerprint = "57:95:98:7f:c2:4e:98:1d:b9:5b:45:fe:6d:a4:6b:17";
            var rsaActual = rsaTarget.GetMD5Fingerprint().ToHexString();
            Assert.That(rsaExpectedFingerprint, Is.EqualTo(rsaActual));

            var dsaTarget = formatter2.Deserialize(Resources.ssh2_dsa_no_passphrase_ppk);
            var dsaExpectedFingerprint = "4e:f1:fc:5d:80:5b:37:b6:13:67:ce:df:4e:83:7b:0b";
            var dsaActual = dsaTarget.GetMD5Fingerprint().ToHexString();
            Assert.That(dsaExpectedFingerprint, Is.EqualTo(dsaActual));
        }
예제 #4
0
        public void PpkFileParseDataTest()
        {
            ISshKey target;

              PpkFormatter.WarnOldFileFormatCallback warnOldFileNotExpected = delegate()
              {
            Assert.Fail("Warn old file format was not expected");
              };
              bool warnCallbackCalled; // set to false before calling warnOldFileExpceted
              PpkFormatter.WarnOldFileFormatCallback warnOldFileExpected = delegate()
              {
            warnCallbackCalled = true;
              };

              string passphrase = "PageantSharp";
              PpkFormatter.GetPassphraseCallback getPassphrase = delegate(string comment)
              {
            SecureString result = new SecureString();
            foreach (char c in passphrase) {
              result.AppendChar(c);
            }
            return result;
              };

              PpkFormatter.GetPassphraseCallback getBadPassphrase = delegate(string comment)
              {
            SecureString result = new SecureString();
            foreach (char c in "badword") {
              result.AppendChar(c);
            }
            return result;
              };

              int expectedKeySize = 1024; // all test keys

              //      string expectedSsh2RsaPublicKeyAlgorithm = PpkFile.PublicKeyAlgorithms.ssh_rsa;
              //      string expectedSsh2RsaWithoutPassPublicKeyString =
              //        "AAAAB3NzaC1yc2EAAAABJQAAAIEAhWqdEs/lz1r4L8ZAAS76rX7hj3rrI/6FNlBw" +
              //        "6ERba2VFmn2AHxQwZmHHmqM+UtiY57angjD9fTbTzL74C0+f/NrRY+BYXf1cF+u5" +
              //        "XmjNKygrsIq3yPMZV4q8YcN/ls9COcynOQMIEmJF6Q0LD7Gt9Uv5yjqc2Ay7VVhG" +
              //        "qZNnIeE=";
              //      string expectedSsh2RsaWithPassPublicKeyString =
              //        "AAAAB3NzaC1yc2EAAAABJQAAAIEAvpwLqhmHYAipvnbQeFEzC7kSTdOCpH5XP9rT" +
              //        "lwScQ5n6Br1DDGIg7tSOBCbralX+0U7NClrcUkueydXRqXEf1rX26o4EcrZ+v1z/" +
              //        "pgu7dbOyHKK0LczCx/IHBm8jrpzrJeB0rg+0ym7XgEcGYgdRj7wFo93PEtx1T4kF" +
              //        "gNLsE3k=";
              //      string expectedSsh2RsaWithoutPassComment = "PageantSharp test: SSH2-RSA, no passphrase";
              string expectedSsh2RsaWithPassComment = "PageantSharp test: SSH2-RSA, with passphrase";
              //      string expectedSsh2RsaWithoutPassPrivateKeyString =
              //        "AAAAgCQO+gUVmA6HSf8S/IqywEqQ/rEoI+A285IjlCMZZNDq8DeXimlDug3VPN2v" +
              //        "lE29/8/sLUXIDSjCtciiUOB2Ypb5Y7AtjDDGg4Yk4v034Mxp0Db6ygDrBuSXbV1U" +
              //        "JzjiDmJOOXgrVLzqc1BZCxVEnzC3fj4GiqQnN1Do3urPatgNAAAAQQDLKWiXIxVj" +
              //        "CoNhzkJqgz0vTIBAaCDJNy9geibZRCHhcQqVk3jN6TscxKhhRYsbEAsTfUPiIPGF" +
              //        "HQaRkd1mwT4dAAAAQQCoHYkHFPqIniQ0oz/ivWAK9mTdl3GRFXP5+mGZQ+9DAl0V" +
              //        "pYOUy7XiCcqVgukYt0+Rj9QNFIcpuAnPfAD6APeVAAAAQClZDkpDCyJX88Vgw7e/" +
              //        "/gbuTJuPv/UGyHI/SSgZcPUBbgmfyj19puHF66+8LTc9unnBF0JyaH9k0dUycFue" +
              //        "LbE=";
              //      string expectedSsh2RsaWithPassDecryptedPrivateKeyString =
              //        "AAAAgE1GLj4KWXn1rJlSwzeyN0nxFUIlUKONKkpRy2a8rg2RczMqIhnG6sGwHeYB" +
              //        "8LxoDVvGABj0ZyhIK53u5kuckF1DiWEcq3IwGIIZqR6JOwMucjbV1pvvzTz3QpUE" +
              //        "fJ+Hj4tHaI7A124D0b/paUmBxOUgeVYXuMls5GZbcl2ApKNdAAAAQQDkXflDxnVr" +
              //        "EXrXAjK+kug3PDdGOPLVPTQRDGwNbuHhSXdVTKAsBdfp9LJZqDzW4LnWhjebeGbj" +
              //        "Kr1ef2VU7cn1AAAAQQDVrHk2uTj27Iwkj31P/WOBXCrmnQ+oAspL3uaJ1rqxg9+F" +
              //        "rq3Dva/y7n0UBRqJ8Y+mdkKQW6oO0usEsEXrVxz1AAAAQF3U8ibnexxDTxhUZdw5" +
              //        "4nzukrnamPWqbZf2RyvQAMA0vw6uW1YNcN6qJxAkt7K5rLg9fsV2ft1FFBcPy+C+" +
              //        "BDw=";
              string expectedSsh2RsaWithoutPassPrivateMACString =
            "77bfa6dc141ed17e4c850d3a95cd6f4ec89cd86b";
              string oldFileFormatSsh2RsaWithoutPassPrivateMACString =
            "dc54d9b526e6d5aeb4832811f2b825e735b218f7";
              //      string expectedSsh2RsaWithPassPrivateMACString =
              //        "e71a6a7b6271875a8264d9d8995f7c81508d6a6c";

              string expectedSsh2DsaWithPassComment = "PageantSharp SSH2-DSA, with passphrase";
              //      string expectedSsh2DsaPrivateKey = "AAAAFQCMF35lBnFwFWyl40y0wTf4lfdhNQ==";

              PpkFormatter formatter = new PpkFormatter();

              /* test for successful method call */
              formatter.GetPassphraseCallbackMethod = getPassphrase;
              formatter.WarnOldFileFormatCallbackMethod = warnOldFileNotExpected;
              target = formatter.DeserializeFile("../../Resources/ssh2-rsa.ppk");
              Assert.AreEqual(expectedSsh2RsaWithPassComment, target.Comment);
              Assert.AreEqual(expectedKeySize, target.Size);
              Assert.That(target.Version, Is.EqualTo(SshVersion.SSH2));

              /* read file to string for modification by subsequent tests */
              byte[] fileData = File.ReadAllBytes("../../Resources/ssh2-rsa-no-passphrase.ppk");
              string withoutPassFileContents;
              byte[] modifiedFileContents;
              MemoryStream modifiedFileContentsStream;
              withoutPassFileContents = Encoding.UTF8.GetString(fileData);

              /* test bad file version */
              modifiedFileContents =
            Encoding.UTF8.GetBytes(withoutPassFileContents.Replace("2", "3"));
              modifiedFileContentsStream = new MemoryStream(modifiedFileContents);
              formatter.GetPassphraseCallbackMethod = null;
              formatter.WarnOldFileFormatCallbackMethod = warnOldFileNotExpected;
              try {
            target = (ISshKey)formatter.Deserialize(modifiedFileContentsStream);
            Assert.Fail("Exception did not occur");
              } catch (Exception ex) {
            Assert.IsInstanceOf<PpkFormatterException>(ex);
            Assert.AreEqual(PpkFormatterException.PpkErrorType.FileVersion,
              ((PpkFormatterException)ex).PpkError);
              }

              /* test bad public key encryption algorithm */
              modifiedFileContents =
            Encoding.UTF8.GetBytes(withoutPassFileContents.Replace("ssh-rsa", "xyz"));
              modifiedFileContentsStream = new MemoryStream(modifiedFileContents);
              formatter.GetPassphraseCallbackMethod = null;
              formatter.WarnOldFileFormatCallbackMethod = warnOldFileNotExpected;
              try {
            target = (ISshKey)formatter.Deserialize(modifiedFileContentsStream);
            Assert.Fail("Exception did not occur");
              } catch (Exception ex) {
            Assert.IsInstanceOf<PpkFormatterException>(ex);
            Assert.AreEqual(PpkFormatterException.PpkErrorType.PublicKeyEncryption,
              ((PpkFormatterException)ex).PpkError);
              }

              /* test bad private key encryption algorithm */
              modifiedFileContents = Encoding.UTF8.GetBytes(withoutPassFileContents.Replace("none", "xyz"));
              modifiedFileContentsStream = new MemoryStream(modifiedFileContents);
              formatter.GetPassphraseCallbackMethod = null;
              formatter.WarnOldFileFormatCallbackMethod = warnOldFileNotExpected;
              try {
            target = (ISshKey)formatter.Deserialize(modifiedFileContentsStream);
            Assert.Fail("Exception did not occur");
              } catch (Exception ex) {
            Assert.IsInstanceOf<PpkFormatterException>(ex);
            Assert.AreEqual(PpkFormatterException.PpkErrorType.PrivateKeyEncryption,
              ((PpkFormatterException)ex).PpkError);
              }

              /* test bad file integrity */
              modifiedFileContents =
            Encoding.UTF8.GetBytes(withoutPassFileContents.Replace("no passphrase", "xyz"));
              modifiedFileContentsStream = new MemoryStream(modifiedFileContents);
              formatter.GetPassphraseCallbackMethod = null;
              formatter.WarnOldFileFormatCallbackMethod = warnOldFileNotExpected;
              try {
            target = (ISshKey)formatter.Deserialize(modifiedFileContentsStream);
            Assert.Fail("Exception did not occur");
              } catch (Exception ex) {
            Assert.IsInstanceOf<PpkFormatterException>(ex);
            Assert.AreEqual(PpkFormatterException.PpkErrorType.FileCorrupt,
              ((PpkFormatterException)ex).PpkError);
              }

              /* test bad passphrase */
              fileData = File.ReadAllBytes("../../Resources/ssh2-rsa.ppk");
              modifiedFileContentsStream = new MemoryStream(fileData);
              formatter.GetPassphraseCallbackMethod = null;
              formatter.WarnOldFileFormatCallbackMethod = warnOldFileNotExpected;
              try {
            target = (ISshKey)formatter.Deserialize(modifiedFileContentsStream);
            Assert.Fail("Exception did not occur");
              } catch (Exception ex) {
            Assert.IsInstanceOf<CallbackNullException>(ex);
              }
              fileData = File.ReadAllBytes("../../Resources/ssh2-rsa.ppk");
              modifiedFileContentsStream = new MemoryStream(fileData);
              formatter.GetPassphraseCallbackMethod = getBadPassphrase;
              formatter.WarnOldFileFormatCallbackMethod = warnOldFileNotExpected;
              try {
            target = (ISshKey)formatter.Deserialize(modifiedFileContentsStream);
            Assert.Fail("Exception did not occur");
              } catch (Exception ex) {
            Assert.IsInstanceOf<PpkFormatterException>(ex);
            Assert.AreEqual(PpkFormatterException.PpkErrorType.BadPassphrase,
              ((PpkFormatterException)ex).PpkError);
              }

              /* test old file format */
              modifiedFileContents = Encoding.UTF8.GetBytes(withoutPassFileContents
            .Replace("PuTTY-User-Key-File-2", "PuTTY-User-Key-File-1")
            .Replace("Private-MAC", "Private-Hash")
            .Replace(expectedSsh2RsaWithoutPassPrivateMACString,
               oldFileFormatSsh2RsaWithoutPassPrivateMACString));
              modifiedFileContentsStream = new MemoryStream(modifiedFileContents);
              formatter.GetPassphraseCallbackMethod = null;
              formatter.WarnOldFileFormatCallbackMethod = warnOldFileExpected;
              try {
            warnCallbackCalled = false;
            target = (ISshKey)formatter.Deserialize(modifiedFileContentsStream);
            Assert.IsTrue(warnCallbackCalled);
              } catch (Exception ex) {
            Assert.Fail(ex.ToString());
              }

              /* test reading bad file */
              fileData = File.ReadAllBytes("../../Resources/emptyFile.ppk");
              modifiedFileContentsStream = new MemoryStream(fileData);
              formatter.GetPassphraseCallbackMethod = null;
              formatter.WarnOldFileFormatCallbackMethod = warnOldFileNotExpected;
              try {
            target = (ISshKey)formatter.Deserialize(modifiedFileContentsStream);
              } catch (Exception ex) {
            Assert.IsInstanceOf<PpkFormatterException>(ex);
            Assert.AreEqual(PpkFormatterException.PpkErrorType.FileFormat,
              ((PpkFormatterException)ex).PpkError);
              }

              /* test reading SSH2-DSA files */
              fileData = File.ReadAllBytes("../../Resources/ssh2-dsa.ppk");
              modifiedFileContentsStream = new MemoryStream(fileData);
              formatter.GetPassphraseCallbackMethod = getPassphrase;
              formatter.WarnOldFileFormatCallbackMethod = warnOldFileNotExpected;
              target = (ISshKey)formatter.Deserialize(modifiedFileContentsStream);
              Assert.AreEqual(expectedSsh2DsaWithPassComment, target.Comment);
              Assert.AreEqual(expectedKeySize, target.Size);

              /* test ECDSA and ED25519 keys */

              string[] keys = {
            "../../Resources/ecdsa-sha2-nistp256.ppk", "../../Resources/ecdsa-sha2-nistp256-no-passphrase.ppk",
            "../../Resources/ecdsa-sha2-nistp384.ppk", "../../Resources/ecdsa-sha2-nistp384-no-passphrase.ppk",
            "../../Resources/ecdsa-sha2-nistp521.ppk", "../../Resources/ecdsa-sha2-nistp521-no-passphrase.ppk",
            "../../Resources/ssh2-ed25519.ppk", "../../Resources/ssh2-ed25519-no-passphrase.ppk"
              };
              string[] fps = {
            "7c:7b:9b:45:ca:dd:d5:d3:9f:25:e7:68:ec:13:7d:79", "80:a9:6e:a1:e4:70:b7:85:ac:e5:df:06:19:95:ce:7d",
            "13:cc:91:2a:1c:d4:e9:38:cc:df:49:a1:23:fa:38:f2", "e4:c5:a0:c6:b0:b9:fc:9f:0c:7b:6d:98:70:ce:7a:1c",
            "21:17:40:2e:2a:16:03:f3:ca:79:a2:73:23:f5:ea:d1", "ae:a0:a6:e0:6e:2a:1c:c0:fa:2e:3d:47:15:b3:2b:cb",
            "5a:b8:a8:f7:1f:06:d6:3b:30:60:a6:41:a0:1f:88:e5", "e4:41:53:cb:04:83:13:b3:58:98:ac:a7:c5:c8:0c:00"
              };
              PublicKeyAlgorithm[] algs = {
            PublicKeyAlgorithm.ECDSA_SHA2_NISTP256, PublicKeyAlgorithm.ECDSA_SHA2_NISTP256,
            PublicKeyAlgorithm.ECDSA_SHA2_NISTP384, PublicKeyAlgorithm.ECDSA_SHA2_NISTP384,
            PublicKeyAlgorithm.ECDSA_SHA2_NISTP521, PublicKeyAlgorithm.ECDSA_SHA2_NISTP521,
            PublicKeyAlgorithm.ED25519, PublicKeyAlgorithm.ED25519
              };
              string[] comments = {
            "PageantSharp ecdsa-sha2-nistp256, with passphrase", "PageantSharp ecdsa-sha2-nistp256, no passphrase",
            "PageantSharp ecdsa-sha2-nistp384, with passphrase", "PageantSharp ecdsa-sha2-nistp384, no passphrase",
            "PageantSharp ecdsa-sha2-nistp521, with passphrase", "PageantSharp ecdsa-sha2-nistp521, no passphrase",
            "PageantSharp ssh2-ed25519, with passphrase", "PageantSharp ssh2-ed25519, no passphrase"
              };
              int[] sizes = { 256, 256, 384, 384, 521, 521, 256, 256 };
              formatter.GetPassphraseCallbackMethod = getPassphrase;
              formatter.WarnOldFileFormatCallbackMethod = warnOldFileNotExpected;
              for (int i = 0; i < keys.Length; ++i) {
            target = (ISshKey) formatter.DeserializeFile(keys[i]);
            Assert.That(target.Size, Is.EqualTo(sizes[i]));
            Assert.That(target.Algorithm, Is.EqualTo(algs[i]));
            Assert.That(target.GetMD5Fingerprint().ToHexString(), Is.EqualTo(fps[i]));
            Assert.That(target.Comment, Is.EqualTo(comments[i]));
              }
        }
예제 #5
0
        public void PpkDeserializeNonAsciiPassphraseTest()
        {
            ISshKey key;
              PpkFormatter formatter = new PpkFormatter();
              formatter.WarnOldFileFormatCallbackMethod = delegate()
              {
            Assert.Fail("Warn old file format was not expected");
              };

              string passphrase = "Ŧéşť";
              formatter.GetPassphraseCallbackMethod = delegate(string comment)
              {
            SecureString result = new SecureString();
            foreach (char c in passphrase) {
              result.AppendChar(c);
            }
            return result;
              };

              string expectedComment = "rsa-key-20120818";

              /* test for successful method call */
              key = formatter.DeserializeFile(
            "../../Resources/ssh2-rsa-non-ascii-passphrase.ppk");
              Assert.AreEqual(expectedComment, key.Comment);
        }
예제 #6
0
        public void Ed25519SigTest()
        {
            ISshKey target;

              PpkFormatter formatter = new PpkFormatter() { GetPassphraseCallbackMethod = _ =>
            {
              SecureString result = new SecureString();
              foreach (char c in "PageantSharp")
              {
            result.AppendChar(c);
              }
              return result;
            }
              };
              string[] keys = {
            "../../Resources/ssh2-ed25519.ppk",
            "../../Resources/ssh2-ed25519-no-passphrase.ppk"
              };
              string[] sig = {
            "01:38:67:b5:b9:cc:a6:a9:9c:cd:38:76:0d:81:66:45:cf:ed:a3:ec:55:ad:" +
            "40:36:01:ca:13:77:3c:41:4e:8e:49:3d:d6:e5:d9:9c:b1:1f:24:de:a9:4c:" +
            "a5:bd:3c:08:0a:10:f5:25:c0:ef:bd:4b:4f:17:e2:54:fe:13:ac:74",
            "01:08:c6:d4:1b:3e:51:9c:39:3f:7c:25:a4:fb:13:0f:3c:74:69:67:df:e3:" +
            "bf:e4:06:fc:4a:1b:da:e3:0b:1f:5d:df:37:6a:d1:1d:b3:31:39:60:20:61:" +
            "b7:ac:bd:a1:e4:39:fc:b1:b0:a3:4c:9c:8c:02:f2:e1:2d:1c:9e:c8"
              };
              for (int i = 0; i < keys.Length; ++i)
              {
            target = (ISshKey)formatter.DeserializeFile(keys[i]);
            Assert.That(((Ed25519PrivateKeyParameter)target.GetPrivateKeyParameters()).Signature.ToHexString(),
            Is.EqualTo(sig[i]), keys[i]);
              }
        }
예제 #7
0
  public static bool TryParseVersion(
this string aString, ref PpkFormatter.Version aVersion)
  {
      switch (aString) {
      case "1":
        aVersion = PpkFormatter.Version.V1;
        return true;
      case "2":
        aVersion = PpkFormatter.Version.V2;
        return true;
      default:
        return false;
        }
  }
예제 #8
0
   public static bool TryParsePrivateKeyAlgorithm(this string aString,
 ref PpkFormatter.PrivateKeyAlgorithm aAlgorithm)
   {
       switch (aString) {
       case PpkFormatter.ALGORITHM_NONE:
         aAlgorithm = PpkFormatter.PrivateKeyAlgorithm.None;
         return true;
       case PpkFormatter.ALGORITHM_AES256_CBC:
         aAlgorithm = PpkFormatter.PrivateKeyAlgorithm.AES256_CBC;
         return true;
       default:
         return false;
         }
   }