public void CreateSignature(ApplicationArguments arguments) { ReadKeyFromFileCommand readPrivateKeyFromFile = fileCommandProvider.GetReadPrivateKeyFromFileCommand(arguments.PrivateKeyPath, arguments.Password); commandExecutor.Execute(readPrivateKeyFromFile); byte[] contentToSign; if (arguments.HasFileInput) { ReadFileCommand <byte[]> readFileToSign = fileCommandProvider.GetReadFileCommand <byte[]>(arguments.FileInput); commandExecutor.Execute(readFileToSign); contentToSign = readFileToSign.Result; } else { contentToSign = encoding.GetBytes(arguments.Input); } CreateSignatureCommand createSignature = signatureCommandProvider.GetCreateSignatureCommand(readPrivateKeyFromFile.Result, contentToSign); commandExecutor.Execute(createSignature); if (arguments.HasFileOutput) { WriteFileCommand <Signature> writeSignatureTofile = fileCommandProvider.GetWriteToFileCommand(createSignature.Result, arguments.FileOutput); commandExecutor.Execute(writeSignatureTofile); return; } WriteToStdOutCommand <Signature> writeSignatureToStdOut = fileCommandProvider.GetWriteToStdOutCommand <Signature>(createSignature.Result); commandExecutor.Execute(writeSignatureToStdOut); }
public void ShouldSetDerFormattedContentAsCommandResult(string content) { decoratedHandler.Setup(dh => dh.Execute(command)) .Callback <ReadKeyFromFileCommand>(c => c.FileContent = encoding.GetBytes(content)); decorator.Execute(command); Assert.AreEqual(resultingKey, command.Result); }
protected void SetupWithRsaKey() { keyPair = rsaKeyProvider.CreateKeyPair(2048); var privateRsaKey = keyPair.PrivateKey; privateKey = pkcs8PemFormatter.GetAsPem(privateRsaKey); file.Setup(f => f.ReadAllBytes("private.pem")) .Returns(encoding.GetBytes(privateKey)); }
public void ShouldSetResult() { var command = new ReadKeyFromFileCommand { FileContent = encoding.GetBytes("-----BEGIN EC PRIVATE KEY given content") }; decorator.Execute(command); Assert.AreEqual(convertedKey, command.Result); }
public void Execute(T command) { var base64Formatted = base64.ToBase64String(command.Out.Content); command.FileContent = encoding.GetBytes(base64Formatted); decoratedCommandHandler.Execute(command); }
public void Execute(T command) { if (command.ContentType == ContentType.OpenSsh) { string sshFormattedKey = sshFormattingProvider.GetAsOpenSshPublicKey(command.Out, "openssh-key"); command.FileContent = encoding.GetBytes(sshFormattedKey); } decoratedCommand.Execute(command); }
public void Execute(T command) { if (command.Out.CipherType == CipherType.Ec && command.ContentType == ContentType.Sec1) { string keyContent = formattingProvider.GetAsPem((IEcKey)command.Out); command.FileContent = encoding.GetBytes(keyContent); } decoratedCommand.Execute(command); }
public void Execute(T command) { if (command.ContentType == ContentType.Pem) { string pemFormatted = formattingProvider.GetAsPem(command.Out); command.FileContent = encoding.GetBytes(pemFormatted); } decoratedCommand.Execute(command); }
public void Setup() { encoding = new EncodingWrapper(); file = new Mock <FileWrapper>(); file.Setup(f => f.ReadAllBytes("fromFile")) .Returns(encoding.GetBytes("file content")); commandHandler = new ReadKeyFromFileCommandHandler(file.Object); command = new ReadKeyFromFileCommand { FilePath = "fromFile" }; commandHandler.Execute(command); }
public void Setup() { file = new Mock <FileWrapper>(); commandHandler = new WriteToFileCommandHandler <object>(file.Object); var encoding = new EncodingWrapper(); fileContent = encoding.GetBytes("barContent"); var command = new WriteFileCommand <object> { FilePath = "fooDestination", FileContent = fileContent }; commandHandler.Execute(command); }
public void Setup() { encoding = new EncodingWrapper(); decoratedHandler = new Mock <ICommandHandler <ReadKeyFromFileCommand> >(); formattingProvider = new Mock <ISshFormattingProvider>(); decorator = new SshReadFormattingDecorator <ReadKeyFromFileCommand>(decoratedHandler.Object, formattingProvider.Object, encoding); key = Mock.Of <IAsymmetricKey>(); command = new ReadKeyFromFileCommand(); decoratedHandler.Setup(dh => dh.Execute(command)) .Callback <ReadKeyFromFileCommand>(c => c.FileContent = encoding.GetBytes("foobar")); formattingProvider.Setup(fp => fp.IsSshKey("foobar")) .Returns(true); formattingProvider.Setup(fp => fp.GetAsDer("foobar")) .Returns(key); }
public string GetAsSsh2PublicKey(IAsymmetricKey key, string comment) { if (key.IsPrivateKey) { throw new InvalidOperationException("Private key cannot be formatted as SSH2 public key."); } int commentLength = encoding.GetBytes(comment).Length; if (commentLength > 1024) { throw new ArgumentException("Comment is too long."); } string contentLine; switch (key.CipherType) { case CipherType.Rsa: contentLine = sshKeyProvider.GetRsaPublicKeyContent(key); break; case CipherType.Dsa: contentLine = sshKeyProvider.GetDsaPublicKeyContent(key); break; case CipherType.Ec: VerifyEcCurve(key); contentLine = sshKeyProvider.GetEcPublicKeyContent(key); break; default: throw new InvalidOperationException("Cipher type not supported for SSH2 key."); } string content = ssh2ContentFormatter.FormatToSsh2KeyContentLength(contentLine); string formattedComment = ssh2ContentFormatter.FormatToSsh2HeaderLength(comment); return($"---- BEGIN SSH2 PUBLIC KEY ----{Environment.NewLine}" + $"Comment: {formattedComment + Environment.NewLine}" + $"{content + Environment.NewLine}" + "---- END SSH2 PUBLIC KEY ----"); }
public void ShouldInvokeDecoratedCommandWithPemFormattedContentWhenContentTypeIsPem() { var command = new WriteFileCommand <IAsymmetricKey> { Out = key, ContentType = ContentType.Pem }; decorator.Execute(command); decoratedCommand.Verify(d => d.Execute(It.Is <WriteFileCommand <IAsymmetricKey> >(k => k.FileContent.SequenceEqual(encoding.GetBytes("pemFormattedFoo"))))); }
public void ShouldInvokeDecoratedHandlerWithOpenSshKey() { command.ContentType = ContentType.OpenSsh; openSshPublicKeyDecorator.Execute(command); decoratedCommandHandler.Verify(d => d.Execute(It.Is <WriteFileCommand <IAsymmetricKey> >(c => c.FileContent.SequenceEqual(encoding.GetBytes("openSshFormattedKey"))))); }
public void ShouldSetFileContentWhenContentTypeIsSec1AndCipherTypeIsEc() { var command = new WriteFileCommand <IAsymmetricKey> { Out = key, ContentType = ContentType.Sec1 }; decorator.Execute(command); decoratedCommandHandler.Verify(d => d.Execute(It.Is <WriteFileCommand <IAsymmetricKey> >(k => k.FileContent.SequenceEqual(encoding.GetBytes("EcPem"))))); }
public string GetEcPublicKeyContent(IAsymmetricKey publicKey) { var ecKey = (IEcKey)publicKey; if (ecKey.IsCurve25519) { throw new InvalidOperationException("Curve25519 must be formatted in Edwards form when converted to Ssh key."); } var keyParameters = (ECPublicKeyParameters)PublicKeyFactory.CreateKey(publicKey.Content); string curve = sshSupportedCurves.Single(c => c.Contains(ecKey.Curve)).First(); byte[] identifier = encoding.GetBytes(sshCurveHeaders[curve]); byte[] header = encoding.GetBytes(sshCurveIdentifiers[curve]); byte[] q = keyParameters.Q.GetEncoded(false); using (var stream = new MemoryStream()) { stream.Write(LengthAsBytes(identifier.Length), 0, 4); stream.Write(identifier, 0, identifier.Length); stream.Write(LengthAsBytes(header.Length), 0, 4); stream.Write(header, 0, header.Length); stream.Write(LengthAsBytes(q.Length), 0, 4); stream.Write(q, 0, q.Length); return(base64.ToBase64String(stream.ToArray())); } }
public void ShouldSetFileContentToFromFileFieldOfGivenCommand() { Assert.AreEqual(encoding.GetBytes("file content"), command.FileContent); }