public void InitializedTest5()
{
try
{
ServiceLocatorWrapper.Reset();
_unityServiceLocator = new UnityServiceLocator(
new UnityContainer()
/*.RegisterInstance<string>(Algorithms.Hash.ResolveName, "SHA1")*/
/*.RegisterType<HashAlgorithm, SHA512Cng>()*/);
ServiceLocator.SetLocatorProvider(() => _unityServiceLocator);
var target = new HashAlgorithmFactory();
target.Initialize("SHA384");
var hasher = target.Create();
Assert.IsNotNull(hasher);
Assert.IsInstanceOfType(hasher, typeof(SHA384));
}
finally
{
CleanupTest();
}
}
/// <summary>
/// Hashes the specified data bytes.
/// </summary>
/// <param name="hashBytes">Data to hash.</param>
/// <returns>
/// Hashed bytes
/// </returns>
protected override byte[] Hash(byte[] hashBytes)
{
using (var sha256 = HashAlgorithmFactory.CreateSHA256())
{
return(sha256.ComputeHash(hashBytes));
}
}
public void InitializedWithAlgorithmFromDITest()
{
try
{
InitializeHashAlgorithmTest();
var target = new HashAlgorithmFactory();
target.Initialize();
var hasher1 = target.Create();
Assert.IsNotNull(hasher1);
var hasher2 = target.Create();
Assert.IsNotNull(hasher2);
Assert.IsFalse(object.ReferenceEquals(hasher1, hasher2));
Assert.IsInstanceOfType(hasher1, typeof(MD5));
Assert.IsInstanceOfType(hasher2, typeof(MD5));
}
finally
{
CleanupTest();
}
}
/// <summary>
/// Hashes the specified data bytes.
/// </summary>
/// <param name="hashData">The hash data.</param>
/// <returns>
/// Hashed bytes
/// </returns>
protected virtual byte[] Hash(byte[] hashData)
{
using (var sha1 = HashAlgorithmFactory.CreateSHA1())
{
return(sha1.ComputeHash(hashData, 0, hashData.Length));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="KeyExchangeInitMessage"/> class.
/// </summary>
public KeyExchangeInitMessage()
{
var cookie = new byte[16];
HashAlgorithmFactory.GenerateRandom(cookie);
Cookie = cookie;
}
protected override void ProcessRecordInEH()
{
string encodingName = EncodingName;
if (string.IsNullOrWhiteSpace(encodingName))
{
encodingName = EncodingFactory.EncodingNames.UTF8;
}
Encoding encoding = EncodingFactory.Get(encodingName);
if (encoding == null)
{
throw new PSArgumentException(string.Format("Unsupported encoding: {0}", encodingName));
}
HashAlgorithm algorithm = HashAlgorithmFactory.Create(Algorithm);
if (algorithm == null)
{
throw new PSArgumentException(string.Format("Unsupported algorithm: {0}", Algorithm));
}
byte[] hashBuffer = HashGenerator.ComputeStringHash(InputObject, algorithm, encoding);
HashResult result = new HashResult()
{
Algorithm = Algorithm,
Hash = hashBuffer.ToHex(),
HashBuffer = hashBuffer,
};
WriteObject(result);
}
/// <summary>
/// 取得雜湊結果
/// </summary>
/// <param name="data">要雜湊的資料</param>
/// <returns>雜湊完畢的字串</returns>
public string GetHash(string data)
{
using (var shaM = HashAlgorithmFactory.GetInstance(HashType))
{
var byteData = Encoding.UTF8.GetBytes(data);
return(ConvertToText(shaM.ComputeHash(byteData)));
}
}
public override string GetAlgorithmName(IComponentContext ctx)
{
var hash = HashAlgorithmFactory.GetHash(ctx, HeaderHasher);
if (hash.GetType() == typeof(DigestReverser))
{
return(((DigestReverser)hash).Upstream.GetType().Name.ToLower());
}
return(hash.GetType().Name.ToLower());
}
protected override void SetupCrypto()
{
coinbaseHasher = HashAlgorithmFactory.GetHash(ctx, coin.CoinbaseHasher);
headerHasher = HashAlgorithmFactory.GetHash(ctx, coin.HeaderHasher);
blockHasher = !isPoS?
HashAlgorithmFactory.GetHash(ctx, coin.BlockHasher) :
(HashAlgorithmFactory.GetHash(ctx, coin.CoinbaseHasher ?? coin.BlockHasher));
ShareMultiplier = coin.ShareMultiplier;
}
public void ShouldGenerateRandomSequenceOfValues()
{
var dataLength = new Random().Next(1, 100);
var dataA = new byte[dataLength];
var dataB = new byte[dataLength];
HashAlgorithmFactory.GenerateRandom(dataA);
HashAlgorithmFactory.GenerateRandom(dataB);
Assert.IsFalse(dataA.SequenceEqual(dataB));
}
public void HashAlgorithmFactoryTest1()
{
var algorithm = HashAlgorithmFactory.Create("md5");
Assert.Equal(typeof(System.Security.Cryptography.MD5CryptoServiceProvider), algorithm.GetType());
algorithm = HashAlgorithmFactory.Create("MD5");
Assert.Equal(typeof(System.Security.Cryptography.MD5CryptoServiceProvider), algorithm.GetType());
algorithm = HashAlgorithmFactory.Create("foo");
Assert.Null(algorithm);
Assert.Throws <ArgumentException>(() => { HashAlgorithmFactory.Create(""); });
}
public void UninitializedTest()
{
try
{
var target = new HashAlgorithmFactory();
target.Create();
}
finally
{
CleanupTest();
}
}
public BitcoinTemplate()
{
coinbaseHasherValue = new Lazy <IHashAlgorithm>(() =>
HashAlgorithmFactory.GetHash(ComponentContext, CoinbaseHasher));
headerHasherValue = new Lazy <IHashAlgorithm>(() =>
HashAlgorithmFactory.GetHash(ComponentContext, HeaderHasher));
blockHasherValue = new Lazy <IHashAlgorithm>(() =>
HashAlgorithmFactory.GetHash(ComponentContext, BlockHasher));
posBlockHasherValue = new Lazy <IHashAlgorithm>(() =>
HashAlgorithmFactory.GetHash(ComponentContext, PoSBlockHasher));
}
public void InitializedWithBadNameTest()
{
try
{
InitializeHashNameTest("MD5");
var target = new HashAlgorithmFactory();
target.Initialize("SHA123");
}
finally
{
CleanupTest();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HostKeyEventArgs"/> class.
/// </summary>
/// <param name="host">The host.</param>
public HostKeyEventArgs(KeyHostAlgorithm host)
{
CanTrust = true; // Set default value
HostKey = host.Data;
HostKeyName = host.Name;
KeyLength = host.Key.KeyLength;
using (var md5 = HashAlgorithmFactory.CreateMD5())
{
FingerPrint = md5.ComputeHash(host.Data);
}
}
public void ShouldThrowArgumentNullExceptionWhenDataIsNull()
{
const byte[] data = null;
try
{
HashAlgorithmFactory.GenerateRandom(data);
Assert.Fail();
}
catch (ArgumentNullException ex)
{
Assert.IsNull(ex.InnerException);
Assert.AreEqual("data", ex.ParamName);
}
}
public async Task EnsureHeader(HttpRequestMessage request, SigningSettings signingSettings, DateTimeOffset timeOfSigning)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (signingSettings == null)
{
throw new ArgumentNullException(nameof(signingSettings));
}
if (!request.Method.SupportsBody())
{
return;
}
if (string.IsNullOrEmpty(signingSettings.DigestHashAlgorithm.Name))
{
return;
}
if (request.Headers.Contains("Digest"))
{
return;
}
if (request.Content == null)
{
request.Headers.Add("Digest", string.Empty);
return;
}
var bodyBytes = await request.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
using (var hashAlgorithm = HashAlgorithmFactory.Create(signingSettings.DigestHashAlgorithm)) {
if (hashAlgorithm == null)
{
throw new NotSupportedException($"The specified hash algorithm ({signingSettings.DigestHashAlgorithm.Name}) for digest is currently not supported.");
}
var payloadBytes = hashAlgorithm.ComputeHash(bodyBytes);
var digest = _base64Converter.ToBase64(payloadBytes);
var digestAlgorithmName = Constants.DigestHashAlgorithmNames[signingSettings.DigestHashAlgorithm.Name];
request.Headers.Add("Digest", $"{digestAlgorithmName}={digest}");
}
}
public BitcoinTemplate()
{
coinbaseHasherValue = new Lazy <IHashAlgorithm>(() =>
{
if (CoinbaseHasher == null)
{
return(null);
}
return(HashAlgorithmFactory.GetHash(ComponentContext, CoinbaseHasher));
});
headerHasherValue = new Lazy <IHashAlgorithm>(() =>
{
if (HeaderHasher == null)
{
return(null);
}
return(HashAlgorithmFactory.GetHash(ComponentContext, HeaderHasher));
});
blockHasherValue = new Lazy <IHashAlgorithm>(() =>
{
if (BlockHasher == null)
{
return(null);
}
return(HashAlgorithmFactory.GetHash(ComponentContext, BlockHasher));
});
posBlockHasherValue = new Lazy <IHashAlgorithm>(() =>
{
if (PoSBlockHasher == null)
{
return(null);
}
return(HashAlgorithmFactory.GetHash(ComponentContext, PoSBlockHasher));
});
}
public void InitializedWithGoodNameTest()
{
try
{
InitializeHashNameTest("MD5");
var target = new HashAlgorithmFactory();
target.Initialize("SHA1");
var hasher1 = target.Create();
Assert.IsNotNull(hasher1);
Assert.AreEqual("SHA1", target.HashAlgorithmName);
var hasher2 = target.Create();
Assert.IsNotNull(hasher2);
Assert.AreNotEqual(hasher1, hasher2);
}
finally
{
CleanupTest();
}
}
new static public Bkdr Create(string hashName)
{
return((Bkdr)HashAlgorithmFactory.Create(hashName));
}
internal byte[] GetPacket(byte paddingMultiplier, Compressor compressor)
{
const int outboundPacketSequenceSize = 4;
var messageLength = BufferCapacity;
SshDataStream sshDataStream;
if (messageLength == -1 || compressor != null)
{
sshDataStream = new SshDataStream(DefaultCapacity);
// skip:
// * 4 bytes for the outbound packet sequence
// * 4 bytes for the packet data length
// * one byte for the packet padding length
sshDataStream.Seek(outboundPacketSequenceSize + 4 + 1, SeekOrigin.Begin);
if (compressor != null)
{
// obtain uncompressed message payload
var uncompressedDataStream = new SshDataStream(messageLength != -1 ? messageLength : DefaultCapacity);
WriteBytes(uncompressedDataStream);
// compress message payload
var compressedMessageData = compressor.Compress(uncompressedDataStream.ToArray());
// add compressed message payload
sshDataStream.Write(compressedMessageData, 0, compressedMessageData.Length);
}
else
{
// add message payload
WriteBytes(sshDataStream);
}
messageLength = (int)sshDataStream.Length - (outboundPacketSequenceSize + 4 + 1);
var packetLength = messageLength + 4 + 1;
// determine the padding length
var paddingLength = GetPaddingLength(paddingMultiplier, packetLength);
// add padding bytes
var paddingBytes = new byte[paddingLength];
HashAlgorithmFactory.GenerateRandom(paddingBytes);
sshDataStream.Write(paddingBytes, 0, paddingLength);
var packetDataLength = GetPacketDataLength(messageLength, paddingLength);
// skip bytes for outbound packet sequence
sshDataStream.Seek(outboundPacketSequenceSize, SeekOrigin.Begin);
// add packet data length
sshDataStream.Write(packetDataLength.GetBytes(), 0, 4);
// add packet padding length
sshDataStream.WriteByte(paddingLength);
}
else
{
var packetLength = messageLength + 4 + 1;
// determine the padding length
var paddingLength = GetPaddingLength(paddingMultiplier, packetLength);
var packetDataLength = GetPacketDataLength(messageLength, paddingLength);
// lets construct an SSH data stream of the exact size required
sshDataStream = new SshDataStream(packetLength + paddingLength + outboundPacketSequenceSize);
// skip bytes for outbound packet sequenceSize
sshDataStream.Seek(outboundPacketSequenceSize, SeekOrigin.Begin);
// add packet data length
sshDataStream.Write(packetDataLength.GetBytes(), 0, 4);
// add packet padding length
sshDataStream.WriteByte(paddingLength);
// add message payload
WriteBytes(sshDataStream);
// add padding bytes
var paddingBytes = new byte[paddingLength];
HashAlgorithmFactory.GenerateRandom(paddingBytes);
sshDataStream.Write(paddingBytes, 0, paddingLength);
}
return(sshDataStream.ToArray());
}
public override SignatureVerificationFailure VerifySync(HttpRequestForSigning signedRequest, Signature signature, Client client)
{
if (signature.Headers.Contains(HeaderName.PredefinedHeaderNames.Digest) &&
!signedRequest.Headers.Contains(HeaderName.PredefinedHeaderNames.Digest))
{
return(SignatureVerificationFailure.HeaderMissing($"The {HeaderName.PredefinedHeaderNames.Digest} header is indicated as part of the signature, but it is not included in the request."));
}
if (!signedRequest.Headers.Contains(HeaderName.PredefinedHeaderNames.Digest))
{
_logger?.LogDebug("{0} header verification is not required, because it is not present in the request to verify.", HeaderName.PredefinedHeaderNames.Digest);
return(null);
}
if (signedRequest.Body == null)
{
return(SignatureVerificationFailure.InvalidDigestHeader($"The {HeaderName.PredefinedHeaderNames.Digest} header verification failed. The request has no body."));
}
var digestHeaderValue = signedRequest.Headers.GetValues(HeaderName.PredefinedHeaderNames.Digest).FirstOrDefault();
var digestParams = new List <string>();
if (!string.IsNullOrEmpty(digestHeaderValue))
{
var separatorIndex = digestHeaderValue.IndexOf('=');
if (separatorIndex < 0 || separatorIndex >= digestHeaderValue.Length - 1)
{
digestParams.Add(digestHeaderValue);
}
else
{
digestParams.Add(digestHeaderValue.Substring(0, separatorIndex));
digestParams.Add(digestHeaderValue.Substring(separatorIndex + 1));
}
}
if (digestParams.Count < 2)
{
return(SignatureVerificationFailure.InvalidDigestHeader($"The {HeaderName.PredefinedHeaderNames.Digest} request header is invalid."));
}
if (!Constants.DigestHashAlgorithms.TryGetValue(digestParams[0], out var digestAlgorithmName))
{
return(SignatureVerificationFailure.InvalidDigestHeader($"The {HeaderName.PredefinedHeaderNames.Digest} algorithm name ({digestParams[0] ?? "[null]"}) is invalid."));
}
using (var hashAlgorithm = HashAlgorithmFactory.Create(new HashAlgorithmName(digestAlgorithmName))) {
if (hashAlgorithm == null)
{
return(SignatureVerificationFailure.InvalidDigestHeader($"The {HeaderName.PredefinedHeaderNames.Digest} algorithm name ({digestParams[0] ?? "[null]"}) is currently not supported."));
}
var payloadBytes = hashAlgorithm.ComputeHash(signedRequest.Body);
var calculatedDigest = _base64Converter.ToBase64(payloadBytes);
var receivedDigest = digestParams[1];
if (calculatedDigest != receivedDigest)
{
return(SignatureVerificationFailure.InvalidDigestHeader("The digest header verification failed."));
}
}
return(null);
}
public void Test_HMac_Sha256_96_Connection()
{
var connectionInfo = new PasswordConnectionInfo(Resources.HOST, int.Parse(Resources.PORT), Resources.USERNAME, Resources.PASSWORD);
connectionInfo.HmacAlgorithms.Clear();
connectionInfo.HmacAlgorithms.Add("hmac-sha2-256-96", new HashInfo(32 * 8, (key) => HashAlgorithmFactory.CreateHMACSHA256(key, 96)));
using (var client = new SshClient(connectionInfo))
{
client.Connect();
client.Disconnect();
}
}
new static public APHash Create(string hashName)
{
return((APHash)HashAlgorithmFactory.Create(hashName));
}
public static new Fnv1a64 Create(string hashName)
{
return((Fnv1a64)HashAlgorithmFactory.Create(hashName));
}
public static new Joaat Create(string hashName)
{
return((Joaat)HashAlgorithmFactory.Create(hashName));
}
/// <summary>
/// Initializes a new instance of the <see cref="ConnectionInfo" /> class.
/// </summary>
/// <param name="host">Connection host.</param>
/// <param name="port">Connection port.</param>
/// <param name="username">Connection username.</param>
/// <param name="proxyType">Type of the proxy.</param>
/// <param name="proxyHost">The proxy host.</param>
/// <param name="proxyPort">The proxy port.</param>
/// <param name="proxyUsername">The proxy username.</param>
/// <param name="proxyPassword">The proxy password.</param>
/// <param name="authenticationMethods">The authentication methods.</param>
/// <exception cref="ArgumentNullException"><paramref name="host"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException"><paramref name="username" /> is null, a zero-length string or contains only whitespace characters.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="port" /> is not within <see cref="F:System.Net.IPEndPoint.MinPort" /> and <see cref="F:System.Net.IPEndPoint.MaxPort" />.</exception>
/// <exception cref="ArgumentNullException"><paramref name="proxyType"/> is not <see cref="ProxyTypes.None"/> and <paramref name="proxyHost" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="proxyType"/> is not <see cref="ProxyTypes.None"/> and <paramref name="proxyPort" /> is not within <see cref="F:System.Net.IPEndPoint.MinPort" /> and <see cref="F:System.Net.IPEndPoint.MaxPort" />.</exception>
/// <exception cref="ArgumentNullException"><paramref name="authenticationMethods"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">No <paramref name="authenticationMethods"/> specified.</exception>
public ConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword, params AuthenticationMethod[] authenticationMethods)
{
if (host == null)
{
throw new ArgumentNullException("host");
}
port.ValidatePort("port");
if (username == null)
{
throw new ArgumentNullException("username");
}
if (username.All(char.IsWhiteSpace))
{
throw new ArgumentException("Cannot be empty or contain only whitespace.", "username");
}
if (proxyType != ProxyTypes.None)
{
if (proxyHost == null)
{
throw new ArgumentNullException("proxyHost");
}
proxyPort.ValidatePort("proxyPort");
}
if (authenticationMethods == null)
{
throw new ArgumentNullException("authenticationMethods");
}
if (authenticationMethods.Length == 0)
{
throw new ArgumentException("At least one authentication method should be specified.", "authenticationMethods");
}
// Set default connection values
Timeout = TimeSpan.FromSeconds(30);
RetryAttempts = 10;
MaxSessions = 10;
Encoding = Encoding.UTF8;
KeyExchangeAlgorithms = new Dictionary <string, Type>
{
{ "diffie-hellman-group-exchange-sha256", typeof(KeyExchangeDiffieHellmanGroupExchangeSha256) },
{ "diffie-hellman-group-exchange-sha1", typeof(KeyExchangeDiffieHellmanGroupExchangeSha1) },
{ "diffie-hellman-group14-sha1", typeof(KeyExchangeDiffieHellmanGroup14Sha1) },
{ "diffie-hellman-group1-sha1", typeof(KeyExchangeDiffieHellmanGroup1Sha1) },
//{"ecdh-sha2-nistp256", typeof(KeyExchangeEllipticCurveDiffieHellman)},
//{"ecdh-sha2-nistp256", typeof(...)},
//{"ecdh-sha2-nistp384", typeof(...)},
//{"ecdh-sha2-nistp521", typeof(...)},
//"gss-group1-sha1-toWM5Slw5Ew8Mqkay+al2g==" - WinSSHD
//"gss-gex-sha1-toWM5Slw5Ew8Mqkay+al2g==" - WinSSHD
};
Encryptions = new Dictionary <string, CipherInfo>
{
{ "aes256-ctr", new CipherInfo(256, (key, iv) => new AesCipher(key, new CtrCipherMode(iv), null)) },
{ "3des-cbc", new CipherInfo(192, (key, iv) => new TripleDesCipher(key, new CbcCipherMode(iv), null)) },
{ "aes128-cbc", new CipherInfo(128, (key, iv) => new AesCipher(key, new CbcCipherMode(iv), null)) },
{ "aes192-cbc", new CipherInfo(192, (key, iv) => new AesCipher(key, new CbcCipherMode(iv), null)) },
{ "aes256-cbc", new CipherInfo(256, (key, iv) => new AesCipher(key, new CbcCipherMode(iv), null)) },
{ "blowfish-cbc", new CipherInfo(128, (key, iv) => new BlowfishCipher(key, new CbcCipherMode(iv), null)) },
{ "twofish-cbc", new CipherInfo(256, (key, iv) => new TwofishCipher(key, new CbcCipherMode(iv), null)) },
{ "twofish192-cbc", new CipherInfo(192, (key, iv) => new TwofishCipher(key, new CbcCipherMode(iv), null)) },
{ "twofish128-cbc", new CipherInfo(128, (key, iv) => new TwofishCipher(key, new CbcCipherMode(iv), null)) },
{ "twofish256-cbc", new CipherInfo(256, (key, iv) => new TwofishCipher(key, new CbcCipherMode(iv), null)) },
////{"serpent256-cbc", typeof(CipherSerpent256CBC)},
////{"serpent192-cbc", typeof(...)},
////{"serpent128-cbc", typeof(...)},
{ "arcfour", new CipherInfo(128, (key, iv) => new Arc4Cipher(key, false)) },
{ "arcfour128", new CipherInfo(128, (key, iv) => new Arc4Cipher(key, true)) },
{ "arcfour256", new CipherInfo(256, (key, iv) => new Arc4Cipher(key, true)) },
////{"idea-cbc", typeof(...)},
{ "cast128-cbc", new CipherInfo(128, (key, iv) => new CastCipher(key, new CbcCipherMode(iv), null)) },
////{"*****@*****.**", typeof(...)},
{ "aes128-ctr", new CipherInfo(128, (key, iv) => new AesCipher(key, new CtrCipherMode(iv), null)) },
{ "aes192-ctr", new CipherInfo(192, (key, iv) => new AesCipher(key, new CtrCipherMode(iv), null)) },
};
HmacAlgorithms = new Dictionary <string, HashInfo>
{
{ "hmac-md5", new HashInfo(16 * 8, HashAlgorithmFactory.CreateHMACMD5) },
{ "hmac-md5-96", new HashInfo(16 * 8, key => HashAlgorithmFactory.CreateHMACMD5(key, 96)) },
{ "hmac-sha1", new HashInfo(20 * 8, HashAlgorithmFactory.CreateHMACSHA1) },
{ "hmac-sha1-96", new HashInfo(20 * 8, key => HashAlgorithmFactory.CreateHMACSHA1(key, 96)) },
{ "hmac-sha2-256", new HashInfo(32 * 8, HashAlgorithmFactory.CreateHMACSHA256) },
{ "hmac-sha2-256-96", new HashInfo(32 * 8, key => HashAlgorithmFactory.CreateHMACSHA256(key, 96)) },
{ "hmac-sha2-512", new HashInfo(64 * 8, HashAlgorithmFactory.CreateHMACSHA512) },
{ "hmac-sha2-512-96", new HashInfo(64 * 8, key => HashAlgorithmFactory.CreateHMACSHA512(key, 96)) },
//{"*****@*****.**", typeof(HMacSha1)},
{ "hmac-ripemd160", new HashInfo(160, HashAlgorithmFactory.CreateHMACRIPEMD160) },
{ "*****@*****.**", new HashInfo(160, HashAlgorithmFactory.CreateHMACRIPEMD160) },
//{"none", typeof(...)},
};
HostKeyAlgorithms = new Dictionary <string, Func <byte[], KeyHostAlgorithm> >
{
{ "ssh-rsa", data => new KeyHostAlgorithm("ssh-rsa", new RsaKey(), data) },
{ "ssh-dss", data => new KeyHostAlgorithm("ssh-dss", new DsaKey(), data) },
//{"ecdsa-sha2-nistp256 "}
//{"x509v3-sign-rsa", () => { ... },
//{"x509v3-sign-dss", () => { ... },
//{"spki-sign-rsa", () => { ... },
//{"spki-sign-dss", () => { ... },
//{"pgp-sign-rsa", () => { ... },
//{"pgp-sign-dss", () => { ... },
};
CompressionAlgorithms = new Dictionary <string, Type>
{
//{"*****@*****.**", typeof(ZlibOpenSsh)},
//{"zlib", typeof(Zlib)},
{ "none", null },
};
ChannelRequests = new Dictionary <string, RequestInfo>
{
{ EnvironmentVariableRequestInfo.Name, new EnvironmentVariableRequestInfo() },
{ ExecRequestInfo.Name, new ExecRequestInfo() },
{ ExitSignalRequestInfo.Name, new ExitSignalRequestInfo() },
{ ExitStatusRequestInfo.Name, new ExitStatusRequestInfo() },
{ PseudoTerminalRequestInfo.Name, new PseudoTerminalRequestInfo() },
{ ShellRequestInfo.Name, new ShellRequestInfo() },
{ SignalRequestInfo.Name, new SignalRequestInfo() },
{ SubsystemRequestInfo.Name, new SubsystemRequestInfo() },
{ WindowChangeRequestInfo.Name, new WindowChangeRequestInfo() },
{ X11ForwardingRequestInfo.Name, new X11ForwardingRequestInfo() },
{ XonXoffRequestInfo.Name, new XonXoffRequestInfo() },
{ EndOfWriteRequestInfo.Name, new EndOfWriteRequestInfo() },
{ KeepAliveRequestInfo.Name, new KeepAliveRequestInfo() },
};
Host = host;
Port = port;
Username = username;
ProxyType = proxyType;
ProxyHost = proxyHost;
ProxyPort = proxyPort;
ProxyUsername = proxyUsername;
ProxyPassword = proxyPassword;
AuthenticationMethods = authenticationMethods;
}
new static public Dek Create(string hashName)
{
return((Dek)HashAlgorithmFactory.Create(hashName));
}
public static new Sdbm Create(string hashName)
{
return((Sdbm)HashAlgorithmFactory.Create(hashName));
}
public static new Adler32 Create(string hashName)
{
return((Adler32)HashAlgorithmFactory.Create(hashName));
}