protected override void OnLoad(SshDataWorker reader)
{
ReasonCode = (DisconnectReason)reader.ReadUInt32();
Description = reader.ReadString(Encoding.UTF8);
if (reader.DataAvailable >= 4)
Language = reader.ReadString(Encoding.UTF8);
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write(RecipientChannel);
writer.Write(SenderChannel);
writer.Write(InitialWindowSize);
writer.Write(MaximumPacketSize);
}
protected override void OnLoad(SshDataWorker reader)
{
ChannelType = reader.ReadString(Encoding.ASCII);
SenderChannel = reader.ReadUInt32();
InitialWindowSize = reader.ReadUInt32();
MaximumPacketSize = reader.ReadUInt32();
}
protected override void OnLoad(SshDataWorker reader)
{
base.OnLoad(reader);
if (ChannelType != "session")
throw new ArgumentException(string.Format("Channel type {0} is not valid.", ChannelType));
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write(RecipientChannel);
writer.Write((uint)ReasonCode);
writer.Write(Description, Encoding.ASCII);
writer.Write(Language ?? "en", Encoding.ASCII);
}
protected override void OnGetPacket(SshDataWorker writer)
{
RequestType = "exit-status";
WantReply = false;
base.OnGetPacket(writer);
writer.Write(ExitStatus);
}
public override byte[] CreateKeyAndCertificatesData()
{
using (var worker = new SshDataWorker())
{
var args = _algorithm.ExportParameters(false);
worker.Write(this.Name, Encoding.ASCII);
worker.WriteMpint(args.Exponent);
worker.WriteMpint(args.Modulus);
return worker.ToByteArray();
}
}
public byte[] GetSignature(byte[] signatureData)
{
Contract.Requires(signatureData != null);
using (var worker = new SshDataWorker(signatureData))
{
if (worker.ReadString(Encoding.ASCII) != this.Name)
throw new CryptographicException("Signature was not created with this algorithm.");
var signature = worker.ReadBinary();
return signature;
}
}
public override void LoadKeyAndCertificatesData(byte[] data)
{
using (var worker = new SshDataWorker(data))
{
if (worker.ReadString(Encoding.ASCII) != this.Name)
throw new CryptographicException("Key and certificates were not created with this algorithm.");
var args = new RSAParameters();
args.Exponent = worker.ReadMpint();
args.Modulus = worker.ReadMpint();
_algorithm.ImportParameters(args);
}
}
public byte[] CreateSignatureData(byte[] data)
{
Contract.Requires(data != null);
using (var worker = new SshDataWorker())
{
var signature = SignData(data);
worker.Write(this.Name, Encoding.ASCII);
worker.WriteBinary(signature);
return worker.ToByteArray();
}
}
protected override void OnLoad(SshDataWorker reader)
{
Cookie = reader.ReadBinary(16);
KeyExchangeAlgorithms = reader.ReadString(Encoding.ASCII).Split(',');
ServerHostKeyAlgorithms = reader.ReadString(Encoding.ASCII).Split(',');
EncryptionAlgorithmsClientToServer = reader.ReadString(Encoding.ASCII).Split(',');
EncryptionAlgorithmsServerToClient = reader.ReadString(Encoding.ASCII).Split(',');
MacAlgorithmsClientToServer = reader.ReadString(Encoding.ASCII).Split(',');
MacAlgorithmsServerToClient = reader.ReadString(Encoding.ASCII).Split(',');
CompressionAlgorithmsClientToServer = reader.ReadString(Encoding.ASCII).Split(',');
CompressionAlgorithmsServerToClient = reader.ReadString(Encoding.ASCII).Split(',');
LanguagesClientToServer = reader.ReadString(Encoding.ASCII).Split(',');
LanguagesServerToClient = reader.ReadString(Encoding.ASCII).Split(',');
FirstKexPacketFollows = reader.ReadBoolean();
Reserved = reader.ReadUInt32();
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write(Cookie);
writer.Write(string.Join(",", KeyExchangeAlgorithms), Encoding.ASCII);
writer.Write(string.Join(",", ServerHostKeyAlgorithms), Encoding.ASCII);
writer.Write(string.Join(",", EncryptionAlgorithmsClientToServer), Encoding.ASCII);
writer.Write(string.Join(",", EncryptionAlgorithmsServerToClient), Encoding.ASCII);
writer.Write(string.Join(",", MacAlgorithmsClientToServer), Encoding.ASCII);
writer.Write(string.Join(",", MacAlgorithmsServerToClient), Encoding.ASCII);
writer.Write(string.Join(",", CompressionAlgorithmsClientToServer), Encoding.ASCII);
writer.Write(string.Join(",", CompressionAlgorithmsServerToClient), Encoding.ASCII);
writer.Write(string.Join(",", LanguagesClientToServer), Encoding.ASCII);
writer.Write(string.Join(",", LanguagesServerToClient), Encoding.ASCII);
writer.Write(FirstKexPacketFollows);
writer.Write(Reserved);
}
private void HandleMessage(PublicKeyRequestMessage message)
{
if (Session._publicKeyAlgorithms.ContainsKey(message.KeyAlgorithmName))
{
if (!message.HasSignature)
{
_session.SendMessage(new PublicKeyOkMessage { KeyAlgorithmName = message.KeyAlgorithmName, PublicKey = message.PublicKey });
return;
}
var keyAlg = Session._publicKeyAlgorithms[message.KeyAlgorithmName](null);
keyAlg.LoadKeyAndCertificatesData(message.PublicKey);
var sig = keyAlg.GetSignature(message.Signature);
var verifed = false;
using (var worker = new SshDataWorker())
{
worker.WriteBinary(_session.SessionId);
worker.Write(message.PayloadWithoutSignature);
verifed = keyAlg.VerifyData(worker.ToByteArray(), sig);
}
var args = new UserauthArgs(message.KeyAlgorithmName, keyAlg.GetFingerprint(), message.PublicKey);
if (verifed && Userauth != null)
{
Userauth(this, args);
verifed = args.Result;
}
if (verifed)
{
_session.RegisterService(message.ServiceName, args);
if (Succeed != null)
Succeed(this, message.ServiceName);
_session.SendMessage(new SuccessMessage());
return;
}
else
{
_session.SendMessage(new FailureMessage());
throw new SshConnectionException("Authentication fail.", DisconnectReason.NoMoreAuthMethodsAvailable);
}
}
_session.SendMessage(new FailureMessage());
}
protected override void OnLoad(SshDataWorker reader)
{
base.OnLoad(reader);
if (MethodName != "publickey")
throw new ArgumentException(string.Format("Method name {0} is not valid.", MethodName));
HasSignature = reader.ReadBoolean();
KeyAlgorithmName = reader.ReadString(Encoding.ASCII);
PublicKey = reader.ReadBinary();
if (HasSignature)
{
Signature = reader.ReadBinary();
PayloadWithoutSignature = RawBytes.Take(RawBytes.Length - Signature.Length - 5).ToArray();
}
}
protected override void OnLoad(SshDataWorker reader)
{
ServiceName = reader.ReadString(Encoding.ASCII);
}
protected override void OnLoad(SshDataWorker reader)
{
base.OnLoad(reader);
Command = reader.ReadString(Encoding.ASCII);
}
protected override void OnLoad(SshDataWorker reader)
{
E = reader.ReadMpint();
}
protected override void OnLoad(SshDataWorker reader)
{
RecipientChannel = reader.ReadUInt32();
BytesToAdd = reader.ReadUInt32();
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write(this.RecipientChannel);
writer.WriteBinary(this.Data);
}
protected override void OnLoad(SshDataWorker reader)
{
base.OnLoad(reader);
reader.ReadBoolean();
this.Password = reader.ReadString(Encoding.UTF8);
}
protected override void OnGetPacket(SshDataWorker writer)
{
}
protected override void OnLoad(SshDataWorker reader)
{
RecipientChannel = reader.ReadUInt32();
RequestType = reader.ReadString(Encoding.ASCII);
WantReply = reader.ReadBoolean();
}
protected override void OnLoad(SshDataWorker reader)
{
Username = reader.ReadString(Encoding.UTF8);
ServiceName = reader.ReadString(Encoding.ASCII);
MethodName = reader.ReadString(Encoding.ASCII);
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write(RecipientChannel);
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write(KeyAlgorithmName, Encoding.ASCII);
writer.WriteBinary(PublicKey);
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write(ServiceName, Encoding.ASCII);
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write(MessageNumber);
writer.Write(SequenceNumber);
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write(ServiceName, Encoding.ASCII);
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write(RecipientChannel);
writer.Write(RequestType, Encoding.ASCII);
writer.Write(WantReply);
}
protected override void OnLoad(SshDataWorker reader)
{
}
protected override void OnLoad(SshDataWorker reader)
{
RecipientChannel = reader.ReadUInt32();
}
protected override void OnLoad(SshDataWorker reader)
{
this.RecipientChannel = reader.ReadUInt32();
this.Data = reader.ReadBinary();
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write("publickey", Encoding.ASCII); // only accept public key
writer.Write(false);
}
protected override void OnLoad(SshDataWorker reader)
{
RecipientChannel = reader.ReadUInt32();
Data = reader.ReadBinary();
}
protected override void OnLoad(SshDataWorker reader)
{
this.RequestType = reader.ReadString(Encoding.UTF8);
this.WantReply = reader.ReadBoolean();
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write(RecipientChannel);
writer.WriteBinary(Data);
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write(RecipientChannel);
writer.Write(BytesToAdd);
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write(MessageNumber);
writer.Write(SequenceNumber);
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.WriteBinary(HostKey);
writer.WriteMpint(F);
writer.WriteBinary(Signature);
}
protected override void OnLoad(SshDataWorker reader)
{
}
protected override void OnGetPacket(SshDataWorker writer)
{
}
protected override void OnGetPacket(SshDataWorker writer)
{
writer.Write((uint)this.ReasonCode);
writer.Write(this.Description, Encoding.UTF8);
writer.Write(this.Language ?? "en", Encoding.UTF8);
}
