Merge remote-tracking branch 'origin/release/1.3' into new-emoji-object-in-editor

2025-08-22 06:23:24 -07:00 · 2023-08-12 15:16:08 +02:00 · 2023-08-12 15:16:08 +02:00 · 2aa4da60f0
commit 2aa4da60f0
parent e9eabf966c a3e65fee6f
8 changed files with 592 additions and 420 deletions
--- a/installer/innosetup/setup.iss
+++ b/installer/innosetup/setup.iss
@ -190,6 +190,8 @@ Root: HKCU; Subkey: Software\Classes\.greenshot; ValueType: string; ValueName: "
 Root: HKCU; Subkey: Software\Classes\Greenshot; ValueType: string; ValueName: ""; ValueData: "Greenshot File"; Permissions: users-modify; Flags: uninsdeletevalue noerror; Check: IsRegularUser
 Root: HKCU; Subkey: Software\Classes\Greenshot\DefaultIcon; ValueType: string; ValueName: ""; ValueData: """{app}\Greenshot.EXE,0"""; Permissions: users-modify; Flags: uninsdeletevalue noerror; Check: IsRegularUser
 Root: HKCU; Subkey: Software\Classes\Greenshot\shell\open\command; ValueType: string; ValueName: ""; ValueData: """{app}\Greenshot.EXE"" --openfile ""%1"""; Permissions: users-modify; Flags: uninsdeletevalue noerror; Check: IsRegularUser
+; Disable the default PRTSCR Snipping Tool in Windows 11
+Root: HKCU; Subkey: Control Panel\Keyboard; ValueType: dword; ValueName: "PrintScreenKeyForSnippingEnabled"; ValueData: "0"; Flags: uninsdeletevalue; Check: ShouldDisableSnippingTool
 ; HKEY_LOCAL_MACHINE - for all users when admin
 Root: HKLM; Subkey: Software\Classes\.greenshot; ValueType: string; ValueName: ""; ValueData: "Greenshot"; Permissions: admins-modify; Flags: uninsdeletevalue noerror; Check: not IsRegularUser
 Root: HKLM; Subkey: Software\Classes\Greenshot; ValueType: string; ValueName: ""; ValueData: "Greenshot File"; Permissions: admins-modify; Flags: uninsdeletevalue noerror; Check: not IsRegularUser
@ -278,6 +280,7 @@ en.win10=Windows 10 plug-in
 en.UninstallIconDescription=Uninstall
 en.ShowLicense=Show license
 en.ShowReadme=Show Readme
+en.disablewin11snippingtool=Disable Win11 default PrtScr snipping tool

 de.confluence=Confluence Plug-in
 de.default=Standard installation
@ -290,6 +293,7 @@ de.optimize=Optimierung der Leistung, kann etwas dauern.
 de.startgreenshot={#ExeName} starten
 de.startup={#ExeName} starten wenn Windows hochfährt
 de.win10=Windows 10 Plug-in
+de.disablewin11snippingtool=Deaktiviere das Standard Windows 11 Snipping Tool auf "Druck"

 es.confluence=Extensión para Confluence
 es.default=${default}
@ -491,6 +495,7 @@ Name: "compact"; Description: "{code:CompactInstall}"
 Name: "custom"; Description: "{code:CustomInstall}"; Flags: iscustom

 [Components]
+Name: "disablesnippingtool"; Description: {cm:disablewin11snippingtool}; Flags: disablenouninstallwarning; Types: default full custom; Check: IsWindows11OrNewer()
 Name: "greenshot"; Description: "Greenshot"; Types: default full compact custom; Flags: fixed
 ;Name: "plugins\networkimport"; Description: "Network Import Plugin"; Types: full
 Name: "plugins\box"; Description: {cm:box}; Types: full custom; Flags: disablenouninstallwarning
@ -540,6 +545,7 @@ Name: "languages\ukUA"; Description: {cm:ukUA}; Types: full custom; Flags: disab
 Name: "languages\viVN"; Description: {cm:viVN}; Types: full custom; Flags: disablenouninstallwarning; Check: hasLanguageGroup('e')
 Name: "languages\zhCN"; Description: {cm:zhCN}; Types: full custom; Flags: disablenouninstallwarning; Check: hasLanguageGroup('a')
 Name: "languages\zhTW"; Description: {cm:zhTW}; Types: full custom; Flags: disablenouninstallwarning; Check: hasLanguageGroup('9')
+
 [Code]
 // Do we have a regular user trying to install this?
 function IsRegularUser(): Boolean;
@ -754,6 +760,19 @@ begin
  Result := IsWindowsVersionOrNewer(10, 0);
 end;

+function IsWindows11OrNewer: Boolean;
+var
+  WindowsVersion: TWindowsVersion;
+begin
+  GetWindowsVersionEx(WindowsVersion);
+  Result := (WindowsVersion.Major >= 10) and (WindowsVersion.Build >= 22000);
+end;
+
+function ShouldDisableSnippingTool: Boolean;
+begin
+  Result := IsComponentSelected('disablesnippingtool');
+end;
+
 [Run]
 Filename: "{app}\{#ExeName}.exe"; Description: "{cm:startgreenshot}"; Parameters: "{code:GetParamsForGS}"; WorkingDir: "{app}"; Flags: nowait postinstall runasoriginaluser
 Filename: "https://getgreenshot.org/thank-you/?language={language}&version={#Version}"; Flags: shellexec runasoriginaluser
--- a/src/Greenshot.Editor/Drawing/FreehandContainer.cs
+++ b/src/Greenshot.Editor/Drawing/FreehandContainer.cs
@ -43,10 +43,12 @@ namespace Greenshot.Editor.Drawing
            0.5f, 0.25f, 0.75f
        };

-        [NonSerialized] private GraphicsPath freehandPath = new GraphicsPath();
-        private NativeRect myBounds = NativeRect.Empty;
-        private NativePoint lastMouse = NativePoint.Empty;
-        private readonly List<Point> capturePoints = new List<Point>();
+        [NonSerialized]
+        private GraphicsPath freehandPath = new GraphicsPath();
+
+        private Rectangle myBounds = NativeRect.Empty;
+        private Point lastMouse = NativePoint.Empty;
+        private List<Point> capturePoints = new List<Point>();
        private bool isRecalculated;

        /// <summary>
@ -319,5 +321,5 @@ namespace Greenshot.Editor.Drawing

            return returnValue;
        }
-    }
+   }
 }
--- a/src/Greenshot.Editor/Drawing/SpeechbubbleContainer.cs
+++ b/src/Greenshot.Editor/Drawing/SpeechbubbleContainer.cs
@ -39,10 +39,10 @@ namespace Greenshot.Editor.Drawing
    [Serializable]
    public class SpeechbubbleContainer : TextContainer
    {
-        private NativePoint _initialGripperPoint;
+        private Point _initialGripperPoint;

        // Only used for serializing the TargetGripper location
-        private NativePoint _storedTargetGripperLocation;
+        private Point _storedTargetGripperLocation;

        /// <summary>
        /// Store the current location of the target gripper
@ -120,7 +120,8 @@ namespace Greenshot.Editor.Drawing
            int xOffset = leftAligned ? -20 : 20;
            int yOffset = topAligned ? -20 : 20;

-            NativePoint newGripperLocation = _initialGripperPoint.Offset(xOffset, yOffset);
+            NativePoint initialGripperPoint = _initialGripperPoint;
+            NativePoint newGripperLocation = initialGripperPoint.Offset(xOffset, yOffset);

            if (TargetAdorner.Location != newGripperLocation)
            {
--- a/src/Greenshot.Editor/Drawing/Surface.cs
+++ b/src/Greenshot.Editor/Drawing/Surface.cs
@ -28,6 +28,7 @@ using System.Drawing.Imaging;
 using System.IO;
 using System.Linq;
 using System.Runtime.Serialization.Formatters.Binary;
+using System.ServiceModel.Security;
 using System.Windows.Forms;
 using Dapplo.Windows.Common.Extensions;
 using Dapplo.Windows.Common.Structs;
@ -41,6 +42,7 @@ using Greenshot.Base.Interfaces.Drawing.Adorners;
 using Greenshot.Editor.Configuration;
 using Greenshot.Editor.Drawing.Emoji;
 using Greenshot.Editor.Drawing.Fields;
+using Greenshot.Editor.Helpers;
 using Greenshot.Editor.Memento;
 using log4net;

@ -723,6 +725,7 @@ namespace Greenshot.Editor.Drawing
            try
            {
                BinaryFormatter binaryRead = new BinaryFormatter();
+                binaryRead.Binder = new BinaryFormatterHelper();
                IDrawableContainerList loadedElements = (IDrawableContainerList) binaryRead.Deserialize(streamRead);
                loadedElements.Parent = this;
                // Make sure the steplabels are sorted according to their number
@ -732,6 +735,10 @@ namespace Greenshot.Editor.Drawing
                SelectElements(loadedElements);
                FieldAggregator.BindElements(loadedElements);
            }
+            catch (SecurityAccessDeniedException)
+            {
+                throw;
+            }
            catch (Exception e)
            {
                LOG.Error("Error serializing elements from stream.", e);
--- a/src/Greenshot.Editor/Drawing/SvgContainer.cs
+++ b/src/Greenshot.Editor/Drawing/SvgContainer.cs
@ -21,6 +21,7 @@

 using System;
 using System.Drawing;
+using System.IO;
 using Dapplo.Windows.Common.Structs;
 using Greenshot.Base.Core;
 using Greenshot.Base.Interfaces;
@ -34,12 +35,30 @@ namespace Greenshot.Editor.Drawing
    [Serializable]
    public class SvgContainer : VectorGraphicsContainer
    {
-        private readonly SvgDocument _svgDocument;
+        private MemoryStream _svgContent;

-        public SvgContainer(SvgDocument svgDocument, ISurface parent) : base(parent)
+        [NonSerialized]
+        private SvgDocument _svgDocument;
+
+        public SvgContainer(Stream stream, ISurface parent) : base(parent)
        {
-            _svgDocument = svgDocument;
-            Size = new Size((int)svgDocument.Width, (int)svgDocument.Height);
+            _svgContent = new MemoryStream();
+            stream.CopyTo(_svgContent);
+            Init();
+            Size = new Size((int)_svgDocument.Width, (int)_svgDocument.Height);
+        }
+
+        protected override void Init()
+        {
+            base.Init();
+            // Do nothing when there is no content
+            if (_svgContent == null)
+            {
+                return;
+            }
+            _svgContent.Position = 0;
+
+            _svgDocument = SvgDocument.Open<SvgDocument>(_svgContent);
        }

        protected override Image ComputeBitmap()
--- a/src/Greenshot.Editor/Drawing/VectorGraphicsContainer.cs
+++ b/src/Greenshot.Editor/Drawing/VectorGraphicsContainer.cs
@ -47,7 +47,8 @@ namespace Greenshot.Editor.Drawing
        /// This is the cached version of the bitmap, pre-rendered to save performance
        /// Do not serialized, it can be rebuild with other information.
        /// </summary>
-        [NonSerialized] private Image _cachedImage;
+        [NonSerialized]
+        private Image _cachedImage;

        /// <summary>
        /// Constructor takes care of calling Init 
--- a/src/Greenshot.Editor/FileFormatHandlers/SvgFileFormatHandler.cs
+++ b/src/Greenshot.Editor/FileFormatHandlers/SvgFileFormatHandler.cs
@ -71,18 +71,18 @@ namespace Greenshot.Editor.FileFormatHandlers

        public override IEnumerable<IDrawableContainer> LoadDrawablesFromStream(Stream stream, string extension, ISurface parent = null)
        {
-            SvgDocument svgDocument = null;
+            SvgContainer svgContainer = null;
            try
            {
-                svgDocument = SvgDocument.Open<SvgDocument>(stream);
+                svgContainer = new SvgContainer(stream, parent);
            }
            catch (Exception ex)
            {
                Log.Error("Can't load SVG", ex);
            }
-            if (svgDocument != null)
+            if (svgContainer != null)
            {
-                yield return new SvgContainer(svgDocument, parent);
+                yield return svgContainer;
            }
        }
    }
--- a/src/Greenshot.Editor/Helpers/BinaryFormatterHelper.cs
+++ b/src/Greenshot.Editor/Helpers/BinaryFormatterHelper.cs
@ -0,0 +1,123 @@
+/*
+ * Greenshot - a free and open source screenshot tool
+ * Copyright (C) 2007-2021 Thomas Braun, Jens Klingen, Robin Krom
+ * 
+ * For more information see: https://getgreenshot.org/
+ * The Greenshot project is hosted on GitHub https://github.com/greenshot/greenshot
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 1 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.ServiceModel.Security;
+using Greenshot.Base.Interfaces.Drawing;
+using Greenshot.Editor.Drawing;
+using Greenshot.Editor.Drawing.Fields;
+using Greenshot.Editor.Drawing.Filters;
+using log4net;
+using static Greenshot.Editor.Drawing.FilterContainer;
+
+namespace Greenshot.Editor.Helpers
+{
+    /// <summary>
+    /// This helps to map the serialization of the old .greenshot file to the newer.
+    /// It also prevents misuse.
+    /// </summary>
+    internal class BinaryFormatterHelper : SerializationBinder
+    {
+        private static readonly ILog LOG = LogManager.GetLogger(typeof(BinaryFormatterHelper));
+        private static readonly IDictionary<string, Type> TypeMapper = new Dictionary<string, Type>
+        {
+            {"System.Guid",typeof(Guid) },
+            {"System.Drawing.Rectangle",typeof(System.Drawing.Rectangle) },
+            {"System.Drawing.Point",typeof(System.Drawing.Point) },
+            {"System.Drawing.Color",typeof(System.Drawing.Color) },
+            {"System.Drawing.Bitmap",typeof(System.Drawing.Bitmap) },
+            {"System.Drawing.Icon",typeof(System.Drawing.Icon) },
+            {"System.Drawing.Size",typeof(System.Drawing.Size) },
+            {"System.IO.MemoryStream",typeof(System.IO.MemoryStream) },
+            {"System.Drawing.StringAlignment",typeof(System.Drawing.StringAlignment) },
+            {"System.Collections.Generic.List`1[[Greenshot.Base.Interfaces.Drawing.IFieldHolder", typeof(List<IFieldHolder>)},
+            {"System.Collections.Generic.List`1[[Greenshot.Base.Interfaces.Drawing.IField", typeof(List<IField>)},
+            {"System.Collections.Generic.List`1[[System.Drawing.Point", typeof(List<System.Drawing.Point>)},
+            {"Greenshot.Editor.Drawing.ArrowContainer", typeof(ArrowContainer) },
+            {"Greenshot.Editor.Drawing.LineContainer", typeof(LineContainer) },
+            {"Greenshot.Editor.Drawing.TextContainer", typeof(TextContainer) },
+            {"Greenshot.Editor.Drawing.SpeechbubbleContainer", typeof(SpeechbubbleContainer) },
+            {"Greenshot.Editor.Drawing.RectangleContainer", typeof(RectangleContainer) },
+            {"Greenshot.Editor.Drawing.EllipseContainer", typeof(EllipseContainer) },
+            {"Greenshot.Editor.Drawing.FreehandContainer", typeof(FreehandContainer) },
+            {"Greenshot.Editor.Drawing.HighlightContainer", typeof(HighlightContainer) },
+            {"Greenshot.Editor.Drawing.IconContainer", typeof(IconContainer) },
+            {"Greenshot.Editor.Drawing.ObfuscateContainer", typeof(ObfuscateContainer) },
+            {"Greenshot.Editor.Drawing.StepLabelContainer", typeof(StepLabelContainer) },
+            {"Greenshot.Editor.Drawing.SvgContainer", typeof(SvgContainer) },
+            {"Greenshot.Editor.Drawing.VectorGraphicsContainer", typeof(VectorGraphicsContainer) },
+            {"Greenshot.Editor.Drawing.MetafileContainer", typeof(MetafileContainer) },
+            {"Greenshot.Editor.Drawing.ImageContainer", typeof(ImageContainer) },
+            {"Greenshot.Editor.Drawing.FilterContainer", typeof(FilterContainer) },
+            {"Greenshot.Editor.Drawing.DrawableContainer", typeof(DrawableContainer) },
+            {"Greenshot.Editor.Drawing.DrawableContainerList", typeof(DrawableContainerList) },
+            {"Greenshot.Editor.Drawing.CursorContainer", typeof(CursorContainer) },
+            {"Greenshot.Editor.Drawing.Filters.HighlightFilter", typeof(HighlightFilter) },
+            {"Greenshot.Editor.Drawing.Filters.GrayscaleFilter", typeof(GrayscaleFilter) },
+            {"Greenshot.Editor.Drawing.Filters.MagnifierFilter", typeof(MagnifierFilter) },
+            {"Greenshot.Editor.Drawing.Filters.BrightnessFilter", typeof(BrightnessFilter) },
+            {"Greenshot.Editor.Drawing.Filters.BlurFilter", typeof(BlurFilter) },
+            {"Greenshot.Editor.Drawing.Filters.PixelizationFilter", typeof(PixelizationFilter) },
+            {"Greenshot.Base.Interfaces.Drawing.IDrawableContainer", typeof(IDrawableContainer) },
+            {"Greenshot.Base.Interfaces.Drawing.EditStatus", typeof(EditStatus) },
+            {"Greenshot.Base.Interfaces.Drawing.IFieldHolder", typeof(IFieldHolder) },
+            {"Greenshot.Base.Interfaces.Drawing.IField", typeof(IField) },
+            {"Greenshot.Base.Interfaces.Drawing.FieldFlag", typeof(FieldFlag) },
+            {"Greenshot.Editor.Drawing.Fields.Field", typeof(Field) },
+            {"Greenshot.Editor.Drawing.Fields.FieldType", typeof(FieldType) },
+            {"Greenshot.Editor.Drawing.FilterContainer+PreparedFilter", typeof(PreparedFilter) },
+        };
+
+        /// <summary>
+        /// Do the type mapping
+        /// </summary>
+        /// <param name="assemblyName">Assembly for the type that was serialized</param>
+        /// <param name="typeName">Type that was serialized</param>
+        /// <returns>Type which was mapped</returns>
+        /// <exception cref="SecurityAccessDeniedException">If something smells fishy</exception>
+        public override Type BindToType(string assemblyName, string typeName)
+        {
+            if (string.IsNullOrEmpty(typeName))
+            {
+                return null;
+            }
+            var typeNameCommaLocation = typeName.IndexOf(",");
+            var comparingTypeName = typeName.Substring(0, typeNameCommaLocation > 0 ? typeNameCommaLocation : typeName.Length);
+
+            // Correct wrong types
+            comparingTypeName = comparingTypeName.Replace("Greenshot.Drawing", "Greenshot.Editor.Drawing");
+            comparingTypeName = comparingTypeName.Replace("Greenshot.Plugin.Drawing", "Greenshot.Base.Interfaces.Drawing");
+            comparingTypeName = comparingTypeName.Replace("GreenshotPlugin.Interfaces.Drawing", "Greenshot.Base.Interfaces.Drawing");
+            comparingTypeName = comparingTypeName.Replace("Greenshot.Drawing.Fields", "Greenshot.Editor.Drawing.Fields");
+            comparingTypeName = comparingTypeName.Replace("Greenshot.Drawing.Filters", "Greenshot.Editor.Drawing.Filters");
+
+            if (TypeMapper.TryGetValue(comparingTypeName, out var returnType))
+            {
+                LOG.Info($"Mapped {assemblyName} - {typeName} to {returnType.FullName}");
+                return returnType;
+            }
+            LOG.Warn($"Unexpected Greenshot type in .greenshot file detected, maybe vulnerability attack created with ysoserial? Suspicious type: {assemblyName} - {typeName}");
+            throw new SecurityAccessDeniedException($"Suspicious type in .greenshot file: {assemblyName} - {typeName}");
+        }
+    }
+}