Merge branch 'feature/save-password' into devel

Core/RenderProfileSerialize.cs

@@ -28,7 +28,7 @@ public Type ConcreteType {
             }
         }
 
-        public StructuredText Serialize(object obj) {
+        public StructuredText Serialize(object obj, SerializationOptions options) {
             StructuredText storage = new StructuredText(typeof(RenderProfile).FullName);
             RenderProfile prof = (RenderProfile)obj;
             storage.Set("font-name", prof.FontName);

Core/Serialize.cs

@@ -39,16 +39,16 @@ public override void InitializePlugin(IPoderosaWorld poderosa) {
             _serviceElements.RegisterExtension(new RenderProfileSerializer());
         }
 
-        public StructuredText Serialize(object obj) {
-            return Serialize(obj.GetType(), obj);
+        public StructuredText Serialize(object obj, SerializationOptions options) {
+            return Serialize(obj.GetType(), obj, options);
         }
-        public StructuredText Serialize(Type type, object obj) {
+        public StructuredText Serialize(Type type, object obj, SerializationOptions options) {
             ISerializeServiceElement se = FindServiceElement(type.FullName
                 );
             if (se == null)
                 throw new ArgumentException("ISerializeServiceElement is not found for the class " + obj.GetType().FullName);
 
-            StructuredText t = se.Serialize(obj);
+            StructuredText t = se.Serialize(obj, options);
             return t;
         }
 

Core/SerializeEx.cs

@@ -17,13 +17,44 @@
 using System.Text;
 
 namespace Poderosa.Serializing {
+
+    /// <summary>
+    /// Type of password serialization
+    /// </summary>
+    public enum PasswordSerialization {
+        /// <summary>Don't serialize passwords</summary>
+        None,
+        /// <summary>Serialize passwords as plaintext</summary>
+        Plaintext,
+        /// <summary>Serialize passwords using simple encryption</summary>
+        Encrypted,
+    }
+
+    /// <summary>
+    /// Serialization options
+    /// </summary>
+    public class SerializationOptions {
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="passwordSerialization">Type of password serialization</param>
+        public SerializationOptions(PasswordSerialization passwordSerialization = PasswordSerialization.None) {
+            PasswordSerialization = passwordSerialization;
+        }
+
+        public PasswordSerialization PasswordSerialization {
+            get;
+            private set;
+        }
+    }
+
     /// <summary>
     /// 
     /// </summary>
     /// <exclude/>
     public interface ISerializeService {
-        StructuredText Serialize(object obj);
-        StructuredText Serialize(Type type, object obj); //型を明示
+        StructuredText Serialize(object obj, SerializationOptions options);
+        StructuredText Serialize(Type type, object obj, SerializationOptions options);
         object Deserialize(StructuredText node);
     }
 
@@ -41,7 +72,7 @@ public interface ISerializeServiceElement {
         Type ConcreteType {
             get;
         }
-        StructuredText Serialize(object obj);
+        StructuredText Serialize(object obj, SerializationOptions options);
         object Deserialize(StructuredText node);
     }
 }

Pipe/PipeTerminalParameterSerializer.cs

@@ -32,7 +32,7 @@ public Type ConcreteType {
             }
         }
 
-        public StructuredText Serialize(object obj) {
+        public StructuredText Serialize(object obj, SerializationOptions options) {
             PipeTerminalParameter tp = obj as PipeTerminalParameter;
             Debug.Assert(tp != null);
 

Pipe/PipeTerminalSettingsSerializer.cs

@@ -31,12 +31,12 @@ public Type ConcreteType {
             }
         }
 
-        public StructuredText Serialize(object obj) {
+        public StructuredText Serialize(object obj, SerializationOptions options) {
             PipeTerminalSettings ts = obj as PipeTerminalSettings;
             Debug.Assert(ts != null);
 
             StructuredText node = new StructuredText(this.ConcreteType.FullName);
-            node.AddChild(PipePlugin.Instance.SerializeService.Serialize(typeof(TerminalSettings), obj));
+            node.AddChild(PipePlugin.Instance.SerializeService.Serialize(typeof(TerminalSettings), obj, options));
 
             return node;
         }

Protocols/Protocols.csproj

@@ -75,6 +75,7 @@
     <Compile Include="ProtocolOptions.cs" />
     <Compile Include="ProtocolsEx.cs" />
     <Compile Include="ProtocolsPlugin.cs" />
+    <Compile Include="SimpleStringEncrypt.cs" />
     <Compile Include="socks.cs" />
     <Compile Include="SSH.cs" />
     <Compile Include="SSHSocket.cs" />

Protocols/SimpleStringEncrypt.cs

@@ -0,0 +1,97 @@
+// Copyright 2004-2017 The Poderosa Project.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Poderosa;
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Poderosa.Protocols {
+
+
+    /// <summary>
+    /// Simple string encyption with constant key.
+    /// </summary>
+    internal class SimpleStringEncrypt {
+
+        // Method : DES
+        //   Mode : CBC
+        //     IV : 91 7c 0b f1 7e 3e 7e 33
+        //    Key : 15 b1 84 59 15 60 29 32
+
+        private const string CIV = "kXwL8X4+fjM=";
+        private const string CKEY = "FbGEWRVgKTI=";
+
+        private SymmetricAlgorithm mCSP = new DESCryptoServiceProvider();
+
+        /// <summary>
+        /// Decrypt string.
+        /// </summary>
+        /// <param name="s">Base64-encoded encrypted data</param>
+        /// <returns>decrypted text or null if failed</returns>
+        public string DecryptString(string s) {
+            if (s == null)
+                return null;
+            if (s.Length == 0)
+                return null;
+
+            using (ICryptoTransform transform = this.mCSP.CreateDecryptor(Convert.FromBase64String(CKEY), Convert.FromBase64String(CIV))) {
+                try {
+                    byte[] buffer = Convert.FromBase64String(s);
+                    using (MemoryStream stream = new MemoryStream()) {
+                        using (CryptoStream stream2 = new CryptoStream(stream, transform, CryptoStreamMode.Write)) {
+                            stream2.Write(buffer, 0, buffer.Length);
+                            stream2.FlushFinalBlock();
+                            stream2.Close();
+                            return Encoding.UTF8.GetString(stream.ToArray());
+                        }
+                    }
+                }
+                catch (Exception exception) {
+                    RuntimeUtil.SilentReportException(exception);
+                    return null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Encrypt string.
+        /// </summary>
+        /// <param name="text">Text to encrypt</param>
+        /// <returns>Base64-encoded encrypted data or null if failed</returns>
+        public string EncryptString(string text) {
+            if (text == null)
+                return null;
+
+            try {
+                using (ICryptoTransform transform = this.mCSP.CreateEncryptor(Convert.FromBase64String(CKEY), Convert.FromBase64String(CIV))) {
+                    byte[] bytes = Encoding.UTF8.GetBytes(text);
+                    using (MemoryStream stream = new MemoryStream()) {
+                        using (CryptoStream stream2 = new CryptoStream(stream, transform, CryptoStreamMode.Write)) {
+                            stream2.Write(bytes, 0, bytes.Length);
+                            stream2.FlushFinalBlock();
+                            stream2.Close();
+                            return Convert.ToBase64String(stream.ToArray());
+                        }
+                    }
+                }
+            }
+            catch (Exception exception) {
+                RuntimeUtil.SilentReportException(exception);
+                return null;
+            }
+        }
+    }
+}