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 WriteFileCommand_Verify_1() { Mock <IIrbisConnection> mock = GetConnectionMock(); IIrbisConnection connection = mock.Object; WriteFileCommand command = new WriteFileCommand(connection); Assert.IsFalse(command.Verify(false)); }
public void WriteFileCommand_Construciton_1() { Mock <IIrbisConnection> mock = GetConnectionMock(); IIrbisConnection connection = mock.Object; WriteFileCommand command = new WriteFileCommand(connection); Assert.AreSame(connection, command.Connection); }
public void ShouldExecuteDecoratedCommandHandler() { var command = new WriteFileCommand <IAsymmetricKey> { ContentType = ContentType.Sec1 }; decorator.Execute(command); decoratedCommandHandler.Verify(ch => ch.Execute(command)); }
public void Setup() { decoratedHandler = new Mock <ICommandHandler <WriteFileCommand <IAsymmetricKey> > >(); decorator = new WriteKeyToFilePathValidationDecorator <WriteFileCommand <IAsymmetricKey> >(decoratedHandler.Object); command = new WriteFileCommand <IAsymmetricKey> { Out = Mock.Of <IAsymmetricKey>() }; }
public void ShouldThrowWhenEncryptionIsAppliedToSec1Key() { var command = new WriteFileCommand <IAsymmetricKey> { ContentType = ContentType.Sec1, EncryptionType = EncryptionType.Pkcs }; Assert.Throws <InvalidOperationException>(() => decorator.Execute(command)); }
public void ShouldThrowWhenSec1IsAppliedForNonEcKey() { key = Mock.Of <IEcKey>(k => k.CipherType == CipherType.Rsa); var command = new WriteFileCommand <IAsymmetricKey> { Out = key, ContentType = ContentType.Sec1 }; Assert.Throws <InvalidOperationException>(() => decorator.Execute(command)); }
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 void ShouldInvokeDecoratedCommandWithEmptyContentWhenContentTypeIsNotPem() { var command = new WriteFileCommand <IAsymmetricKey> { Out = key, ContentType = ContentType.Der }; decorator.Execute(command); decoratedCommand.Verify(d => d.Execute(It.Is <WriteFileCommand <IAsymmetricKey> >(k => k.FileContent == null))); }
public void ShouldNotSetFileContentWhenContentTypeIsNotPem() { var command = new WriteFileCommand <IAsymmetricKey> { Out = key, ContentType = ContentType.Ssh2 }; decorator.Execute(command); decoratedCommandHandler.Verify(d => d.Execute(It.Is <WriteFileCommand <IAsymmetricKey> >(k => k.FileContent == null))); }
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 ShouldInvokeDecoratedCommandWithKeyContentWhenContentTypeIsNotSpecified() { var command = new WriteFileCommand <IAsymmetricKey> { Out = key, ContentType = ContentType.NotSpecified }; decorator.Execute(command); decoratedCommand.Verify(d => d.Execute(It.Is <WriteFileCommand <IAsymmetricKey> >(k => k.FileContent.SequenceEqual(keyContent)))); }
public void Setup() { privateKey = Mock.Of <IAsymmetricKey>(k => k.IsPrivateKey); encryptedPrivateKey = Mock.Of <IAsymmetricKey>(k => k.IsPrivateKey && k.IsEncrypted); keyEncryptionProvider.Setup(kep => kep.EncryptPrivateKey(privateKey, "fooPassword", EncryptionType.Aes)) .Returns(encryptedPrivateKey); command = Mock.Of <WriteFileCommand <IAsymmetricKey> >(c => c.EncryptionType == EncryptionType.Aes && c.Password == "fooPassword" && c.Out == privateKey); }
public void ShouldNotSetFileContentWhenCipherTypeIsNotEc() { key = Mock.Of <IEcKey>(k => k.CipherType == CipherType.Rsa); 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 == null))); }
public void ShouldExecuteDecoratedCommandHandler() { key = Mock.Of <IEcKey>(k => k.CipherType == CipherType.Ec); var command = new WriteFileCommand <IAsymmetricKey> { Out = key, ContentType = ContentType.Sec1 }; decorator.Execute(command); decoratedCommandHandler.Verify(ch => ch.Execute(command)); }
public void ShouldSetSec1FormattedPrivateKeyContentToCommand() { var key = Mock.Of <IEcKey>(k => k.CipherType == CipherType.Ec && k.IsPrivateKey); var command = new WriteFileCommand <IAsymmetricKey> { Out = key, ContentType = ContentType.Sec1 }; decorator.Execute(command); decoratedCommandHandler.Verify(dc => dc.Execute(It.Is <WriteFileCommand <IAsymmetricKey> >(c => c.Out == formattedKey))); }
public void ShouldNotSetSec1ContentWhenContentTypeIsNotSec1() { var key = Mock.Of <IAsymmetricKey>(k => k.CipherType == CipherType.Ec && k.IsPrivateKey); var command = new WriteFileCommand <IAsymmetricKey> { Out = key, ContentType = ContentType.Pem }; decorator.Execute(command); decoratedCommandHandler.Verify(dc => dc.Execute(It.Is <WriteFileCommand <IAsymmetricKey> >(c => c.Out == key))); }
public void WriteFile(TsFile file) { var astPayload = JsonConvert.SerializeObject(file.Statements.ToArray()); var command = new WriteFileCommand() { AstPayload = astPayload, FileName = file.FileName, Path = file.Path }; this.ExecuteCommand(command); }
public void SetupSshWriteFormattingDecoratorTest() { decoratedCommandHandler = new Mock <ICommandHandler <WriteFileCommand <IAsymmetricKey> > >(); formattingProvider = new Mock <ISshFormattingProvider>(); encoding = new EncodingWrapper(); openSshPublicKeyDecorator = new OpenSshPublicKeyWriteFormattingDecorator <WriteFileCommand <IAsymmetricKey> >(decoratedCommandHandler.Object, formattingProvider.Object, encoding); key = Mock.Of <IAsymmetricKey>(k => k.Content == new byte[] { 0x07 }); command = new WriteFileCommand <IAsymmetricKey> { Out = key }; formattingProvider.Setup(fp => fp.GetAsOpenSshPublicKey(key, "openssh-key")).Returns("openSshFormattedKey"); }
public void SetupSshWriteFormattingDecoratorTest() { decoratedCommandHandler = new Mock <ICommandHandler <WriteFileCommand <IAsymmetricKeyPair> > >(); formattingProvider = new Mock <ISshFormattingProvider>(); encoding = new EncodingWrapper(); openSshPrivateKeyDecorator = new OpenSshPrivateKeyWriteFormattingDecorator <WriteFileCommand <IAsymmetricKeyPair> >(decoratedCommandHandler.Object, formattingProvider.Object, encoding); keyPair = Mock.Of <IAsymmetricKeyPair>(); command = new WriteFileCommand <IAsymmetricKeyPair> { Out = keyPair }; formattingProvider.Setup(fp => fp.GetAsOpenSshPrivateKey(keyPair, "openssh-key")).Returns("openSshFormattedKey"); }
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 CreateKeyPair(ApplicationArguments arguments) { ICreateAsymmetricKeyCommand createKeyCommand; switch (arguments.KeyType) { case CipherType.Rsa: createKeyCommand = keyCommandProvider.GetCreateKeyCommand <RsaKey>(arguments.KeySize); break; case CipherType.Dsa: createKeyCommand = keyCommandProvider.GetCreateKeyCommand <DsaKey>(arguments.KeySize); break; case CipherType.Ec: createKeyCommand = keyCommandProvider.GetCreateKeyCommand <EcKey>(arguments.Curve); break; case CipherType.ElGamal: createKeyCommand = keyCommandProvider.GetCreateKeyCommand <ElGamalKey>(arguments.KeySize, arguments.UseRfc3526Prime); break; default: throw new ArgumentException("Key type not supported."); } commandExecutor.Execute(createKeyCommand); if (createKeyCommand.Curve == "curve25519" && arguments.ContentType == ContentType.OpenSsh) { WriteFileCommand <IAsymmetricKeyPair> writeOpenSshCurve25519PrivateKey = fileCommandProvider.GetWriteToFileCommand <IAsymmetricKeyPair>(createKeyCommand.Result, arguments.PrivateKeyPath, arguments.ContentType, arguments.EncryptionType, arguments.Password); WriteFileCommand <IAsymmetricKey> writeOpenSshCurve25519PublicKey = fileCommandProvider.GetWriteKeyToFileCommand(createKeyCommand.Result.PrivateKey, arguments.PublicKeyPath, arguments.ContentType); commandExecutor.Execute(writeOpenSshCurve25519PrivateKey); commandExecutor.Execute(writeOpenSshCurve25519PublicKey); return; } WriteFileCommand <IAsymmetricKey> writePublicKeyToFile = fileCommandProvider.GetWriteKeyToFileCommand(createKeyCommand.Result.PublicKey, arguments.PublicKeyPath, arguments.ContentType); commandExecutor.Execute(writePublicKeyToFile); WriteFileCommand <IAsymmetricKey> writePrivateKeyToFile = fileCommandProvider.GetWriteKeyToFileCommand(createKeyCommand.Result.PrivateKey, arguments.PrivateKeyPath, arguments.ContentType, arguments.EncryptionType, arguments.Password); commandExecutor.Execute(writePrivateKeyToFile); }
public void Setup() { decoratedCommandHandler = new Mock <ICommandHandler <WriteFileCommand <Signature> > >(); base64 = new Base64Wrapper(); decorator = new WriteToFileBase64FormattingDecorator <WriteFileCommand <Signature> >(decoratedCommandHandler.Object, base64, new EncodingWrapper()); signature = new Signature { Content = Encoding.Default.GetBytes("foobar") }; command = new WriteFileCommand <Signature> { Out = signature }; decorator.Execute(command); }
private void ConvertKey(ReadKeyFromFileCommand readKeyFromFile, ApplicationArguments arguments) { commandExecutor.Execute(readKeyFromFile); string fileExtension = arguments.ContentType .ToString() .ToLower(); if (readKeyFromFile.OriginalContentType == arguments.ContentType) { throw new InvalidOperationException($"The given key {readKeyFromFile.FilePath} is already in {fileExtension} format."); } if (arguments.IsContentTypeSsh && readKeyFromFile.Result.IsPrivateKey) { throw new InvalidOperationException("Private key cannot be converted to SSH format."); } string keyPath = $"{readKeyFromFile.FilePath}.{fileExtension}"; WriteFileCommand <IAsymmetricKey> writeKeyToFile = fileCommandProvider.GetWriteKeyToFileCommand(readKeyFromFile.Result, keyPath, arguments.ContentType, readKeyFromFile.OriginalEncryptionType, arguments.Password); commandExecutor.Execute(writeKeyToFile); }
static void Main(string[] args) { var fileSystemReceiver = FileSystemReceiverUtil.GetFileSystemReceiver(); var openFileCommand = new OpenFileCommand(fileSystemReceiver); var closeFileCommand = new CloseFileCommand(fileSystemReceiver); var readFileCommand = new ReadFileCommand(fileSystemReceiver); var writeFileCommand = new WriteFileCommand(fileSystemReceiver); var invoker = new FileInvoker(); invoker.Execute(openFileCommand); invoker.Execute(closeFileCommand); invoker.Execute(new ICommand[] { openFileCommand, readFileCommand, writeFileCommand, closeFileCommand }); Console.Read(); }
static void CommandTest() { //Creating the receiver object IFileSystemReceiver fs = FileSystemReceiverUtil.getUnderlyingFileSystem(); //creating command and associating with receiver OpenFileCommand openFileCommand = new OpenFileCommand(fs); //Creating invoker and associating with Command FileInvoker file = new FileInvoker(openFileCommand); //perform action on invoker object file.execute(); WriteFileCommand writeFileCommand = new WriteFileCommand(fs); file = new FileInvoker(writeFileCommand); file.execute(); CloseFileCommand closeFileCommand = new CloseFileCommand(fs); file = new FileInvoker(closeFileCommand); file.execute(); }
public void ShouldNotMapPrivateKeyContentTypeToPemWhenContentIsOpenSshAndPrivateKeyIsCurve25519() { key = Mock.Of <IEcKey>(k => k.IsPrivateKey && k.CipherType == CipherType.Ec && k.IsCurve25519); result = provider.GetWriteKeyToFileCommand(key, "key", ContentType.OpenSsh); Assert.AreEqual(ContentType.OpenSsh, result.ContentType); }
public void ShouldMapPrivateKeyContentTypeToPemWhenContentTypeForPublicKeyIsSec1() { key = Mock.Of <IAsymmetricKey>(k => !k.IsPrivateKey); result = provider.GetWriteKeyToFileCommand(key, "key", ContentType.Sec1); Assert.AreEqual(ContentType.Pem, result.ContentType); }
public void ShouldMapPrivateKeyContentTypeToPemWhenContentIsOpenSshAndPrivateKeyIsNotEcKey() { key = Mock.Of <IAsymmetricKey>(k => k.IsPrivateKey && k.CipherType == CipherType.Rsa); result = provider.GetWriteKeyToFileCommand(key, "key", ContentType.OpenSsh); Assert.AreEqual(ContentType.Pem, result.ContentType); }
public void Setup() { signature = Mock.Of <Signature>(); result = provider.GetWriteToFileCommand(signature, "signedfile.extension", ContentType.Der, EncryptionType.Pkcs, "foopassword"); }