public IAsymmetricKey GetKeyFromSsh(string sshKeyContent)
{
byte[] content = base64.FromBase64String(sshKeyContent);
string headerContent;
using (var stream = new MemoryStream(content))
{
byte[] header = ReadNextContent(stream);
headerContent = encoding.GetString(header);
}
switch (headerContent)
{
case "ssh-rsa":
return(GetPublicRsaKey(content));
case "ssh-dss":
return(GetPublicDsaKey(content));
case "ecdsa-sha2-nistp256":
case "ecdsa-sha2-nistp384":
case "ecdsa-sha2-nistp521":
return(GetPublicEcKey(content, headerContent));
default:
throw new ArgumentException("SSH key type not supported or the key is corrupt.");
}
}
public void VerifySignature(string signatureFileName = "", string content = "")
{
Container container = ContainerProvider.GetContainer();
var signatureProvider = container.GetInstance <SignatureProvider>();
byte[] encodedSignatureFile = string.IsNullOrEmpty(signatureFileName) ? encoding.GetBytes(consoleOutput.Single()) : fileOutput[signatureFileName];
string encodedSignature = encoding.GetString(encodedSignatureFile);
byte[] signedData = string.IsNullOrEmpty(content) ? fileContent : encoding.GetBytes(content);
var signature = new Signature
{
Content = Convert.FromBase64String(encodedSignature),
SignedData = signedData
};
Assert.IsTrue(signatureProvider.VerifySignature(keyPair.PublicKey, signature));
}
public void Execute(T command)
{
decoratedHandler.Execute(command);
string keyContent = encoding.GetString(command.FileContent);
if (!keyContent.StartsWith("-----BEGIN P", StringComparison.InvariantCulture) &&
!keyContent.StartsWith("-----BEGIN ENCRYPTED", StringComparison.InvariantCulture))
{
return;
}
command.Result = formattingProvider.GetAsDer(keyContent);
command.OriginalContentType = ContentType.Pem;
}
public void Execute(T command)
{
decoratedCommand.Execute(command);
if (command.Result != null)
{
return;
}
string decodedContent = encoding.GetString(command.FileContent);
if (!sshFormattingProvider.IsSshKey(decodedContent))
{
return;
}
command.Result = sshFormattingProvider.GetAsDer(decodedContent);
}
public void Execute(T command)
{
decoratedCommandHandler.Execute(command);
if (command.Result != null)
{
return;
}
string keyContent = encoding.GetString(command.FileContent);
if (!keyContent.StartsWith("-----BEGIN EC PRIVATE KEY", StringComparison.InvariantCulture))
{
return;
}
command.Result = pemFormatter.GetAsDer(keyContent);
command.OriginalContentType = ContentType.Sec1;
}
public void VerifySignature(ApplicationArguments arguments)
{
ReadKeyFromFileCommand readPublicKeyFromFile = fileCommandProvider.GetReadPublicKeyFromFileCommand(arguments.PublicKeyPath);
commandExecutor.Execute(readPublicKeyFromFile);
byte[] contentToVerify;
if (arguments.HasFileInput)
{
ReadFileCommand <byte[]> readFileToVerify = fileCommandProvider.GetReadFileCommand <byte[]>(arguments.FileInput);
commandExecutor.Execute(readFileToVerify);
contentToVerify = readFileToVerify.Result;
}
else
{
contentToVerify = encoding.GetBytes(arguments.Input);
}
byte[] signatureToVerify;
if (base64.IsBase64(arguments.Signature))
{
signatureToVerify = base64.FromBase64String(arguments.Signature);
}
else
{
ReadFileCommand <byte[]> readSignatureToVerify = fileCommandProvider.GetReadFileCommand <byte[]>(arguments.Signature);
commandExecutor.Execute(readSignatureToVerify);
string base64Signature = encoding.GetString(readSignatureToVerify.Result);
signatureToVerify = base64.FromBase64String(base64Signature);
}
VerifySignatureCommand verifySignature = signatureCommandProvider.GetVerifySignatureCommand(readPublicKeyFromFile.Result, contentToVerify, signatureToVerify);
commandExecutor.Execute(verifySignature);
}
