滑块验证码

using XXX.Untils;
using XXX.Models;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Web;
using System.Web.SessionState;
namespace XXX.Service
{
    public class WaterMark : IHttpHandler, IRequiresSessionState  // 要使用session必须实现该接口,记得要导入System.Web.SessionState命名空间
    {
        private string _operType = string.Empty;
        private string _response = string.Empty;
        public void ProcessRequest(HttpContext context)
        {
            _operType = context.Request.QueryString.GetValues("Item")[0];
            switch (_operType)
            {
                case "SliderCaptcha":
                    SliderCaptcha(context);
                    break;
                case "CheckCaptcha":
                    CheckCaptcha(context);
                    break;
                default:
                    break;
            }
            context.Response.AddHeader("Access-Control-Allow-Origin", "*");
        }
        /// <summary>
        /// 滑动验证码
        /// </summary>
        /// <param name="context"></param>
        private void SliderCaptcha(HttpContext context)
        {
            string res = "";            
            try
            {
                Captcha64Model model = CaptchaHelp.GenerateBase64();
                CacheHelper.SetCache("sliderX", model.X);
                Hashtable ht = new Hashtable();
                ht.Add("background", model.Background);
                ht.Add("slider", model.Slide);
                ht.Add("sliderXXXXX", model.X);
                ArrayList eventList = new ArrayList();
                eventList.Add(ht);
                res = Dal.JsonHelp.ObjectToJson(eventList);
            }
            catch(Exception ex)
            {
                res = ex.Message;
            }
            context.Response.Write(res);
            context.Response.ContentType = "application/json;charset:utf-8";
        }
        private void CheckCaptcha(HttpContext context)
        {
            BaseResponse<string> baseResponse = new BaseResponse<string>();
            baseResponse.code = 999;
            string validate = Guid.NewGuid().ToString();
            try
            {
                int x = Convert.ToInt32(context.Request.QueryString["x"].ToString().Trim());
                var session = CacheHelper.GetCache("sliderX");
                if (session == null)
                {
                    baseResponse.msg = "请刷新验证码";
                    baseResponse.code = 500;
                    goto block;
                }
                string sliderXStr = session?.ToString();// as string
                int sliderX = Convert.ToInt32(sliderXStr);
                int difX = sliderX - x;
                if (difX >= 0 - SliderCaptchaConfig.blod && difX <= SliderCaptchaConfig.blod)
                {
                    context.Session["Validate"] = validate;
                    baseResponse.msg = "OK";
                    baseResponse.code = 200;
                    baseResponse.data = validate;
                }
                else
                {
                    session = null;
                    baseResponse.msg = "请正确拼合图像";
                    baseResponse.code = 500;
                }
            }
            catch (Exception ex)
            {
                baseResponse.msg = ex.Message;
            }
        block:
            _response = JsonHelp.ObjectToJson(baseResponse);
            context.Response.Write(_response);
            context.Response.ContentType = "application/json;charset:utf-8";
        }
        public bool IsReusable
        {
            get
            {
                return false;
            }
        }
    }
}

:::info 新建Captcha工具类

:::

using XXX.Models;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Net;
using System.Web;
namespace XXX
{
    public class CaptchaHelp
    {
        public static Captcha64Model GenerateBase64()
        {
            CaptchaModel model = CaptchaHelp.Generate();
            if (model != null)
            {
                return new Captcha64Model()
                {
                    X = model.X,
                    Y = model.Y,
                    Background = ImageToBase64(model.Background, ImageFormat.Jpeg),
                    Slide = ImageToBase64(model.Slide, ImageFormat.Png)
                };
            }
            else
            {
                return null;
            }
        }
        /// <summary>
        /// 生成验证码
        /// </summary>
        /// <returns></returns>
        public static CaptchaModel Generate()
        {
            Bitmap image = BgImage();
            if (image != null)
            {
                int l = SliderCaptchaConfig.l;
                int d = SliderCaptchaConfig.d;
                int width = image.Width;
                int height = image.Height;
                int x = RandomNext(width / 3, width - d - l - 10);//初始x
                int y = RandomNext(10 + d, height - l - 10); ;//初始y
                GraphicsPath path = GetSliderPath(x, y);
                Graphics g = GetGraphics(image);
                //水印
                if (SliderCaptchaConfig.showWatermark)
                {
                    Font font = new Font("宋体", 12, FontStyle.Bold);
                    SizeF size = g.MeasureString(SliderCaptchaConfig.watermarkText, font);
                    Point Plogo = new Point((int)(width - size.Width - 5), (int)(height - size.Height - 5));
                    Color color = image.GetPixel(Plogo.X, Plogo.Y);
                    SolidBrush bru = new SolidBrush(AntiColor(color));
                    g.DrawString(SliderCaptchaConfig.watermarkText, font, bru, Plogo);
                }
                Pen pen = new Pen(Color.FromArgb(200, 255, 255, 255), 2);
                g.DrawPath(pen, path);
                Image slider = CaptureSlider(image, path, x, width, height);
                SolidBrush brush = new SolidBrush(Color.FromArgb(100, 255, 255, 255));
                g.FillPath(brush, path);
                g.Save();
                g.Dispose();
                return new CaptchaModel()
                {
                    X = x,
                    Y = y,
                    Background = image,
                    Slide = slider
                };
            }
            return null;
        }
        /// <summary>
        /// 获取图片Graphics
        /// </summary>
        /// <param name="image"></param>
        /// <returns></returns>
        private static Graphics GetGraphics(Image image)
        {
            Graphics g = Graphics.FromImage(image);
            g.SmoothingMode = SmoothingMode.HighQuality;
            g.CompositingQuality = CompositingQuality.HighQuality;
            g.InterpolationMode = InterpolationMode.High;
            return g;
        }
        /// <summary>
        /// 获取滑块path
        /// </summary>
        private static GraphicsPath GetSliderPath(int x, int y)
        {
            int l = SliderCaptchaConfig.l;
            int r = SliderCaptchaConfig.r;
            int b = SliderCaptchaConfig.b;
            int c = SliderCaptchaConfig.c;
            int d = SliderCaptchaConfig.d;
            int blod = SliderCaptchaConfig.blod;
            GraphicsPath path = new GraphicsPath(FillMode.Winding);
            Point Pa = new Point(x, y);
            Point Pb = new Point(x + l / 2 - b, y - c + blod);
            Point Pd = new Point(x + l, y);
            Point Pe = new Point(Pd.X + c - blod, y + l / 2 - b);
            Point Pg = new Point(Pd.X, y + l);
            Point Ph = new Point(x, y + l);
            Point Pj = new Point(x + c - blod, Pe.Y);
            path.AddLine(Pa, Pb);
            path.AddArc(x + l / 2 - r, y - d, d, d, 130f, 280f);
            path.AddLines(new Point[] { Pd, Pe });
            path.AddArc(x + l, y + l / 2 - r, d, d, 220f, 280f);
            path.AddLines(new Point[] { Pg, Ph });
            path.AddArc(x, y + l / 2 - r, d, d, 140f, -280f);
            path.AddLine(Pj, Pa);
            return path;
        }
        /// <summary>
        /// 获取滑块区域
        /// </summary>
        /// <param name="image"></param>
        /// <param name="path"></param>
        /// <param name="x"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <returns></returns>
        private static Image CaptureSlider(Image image, GraphicsPath path, int x, int width, int height)
        {
            Bitmap concave = new Bitmap(image.Width, image.Height);
            Graphics g = GetGraphics(concave);
            TextureBrush brush = new TextureBrush(image);
            g.Clear(Color.Transparent);
            g.FillPath(brush, path);
            g.Dispose();
            return CaptureImage(concave, x, height);
        }
        /// <summary>
        /// 裁剪图片
        /// </summary>
        /// <param name="fromImage"></param>
        /// <param name="offsetX"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <returns></returns>
        private static Image CaptureImage(Image fromImage, int offsetX, int height)
        {
            int width = SliderCaptchaConfig.l + SliderCaptchaConfig.d + SliderCaptchaConfig.blod;
            Bitmap bitmap = new Bitmap(width, height);
            Graphics g = GetGraphics(bitmap);
            g.DrawImage(fromImage, 0, 0, new Rectangle(offsetX, 0, width, height), GraphicsUnit.Pixel);
            g.Dispose();
            return bitmap;
        }
        /// <summary>
        /// 生成随机数
        /// </summary>
        /// <param name="min"></param>
        /// <param name="max"></param>
        /// <returns></returns>
        private static int RandomNext(int min, int max)
        {
            Random random = new Random(Guid.NewGuid().GetHashCode());
            return random.Next(min, max);
        }
        /// <summary>
        /// 取反色
        /// </summary>
        /// <param name="color"></param>
        /// <returns></returns>
        public static Color AntiColor(Color color)
        {
            if (color.R > 128 && color.G > 128 && color.B > 128)
            {
                return Color.Black;
            }
            else
            {
                return Color.White;
            }
        }
        /// <summary>
        /// 获取背景图
        /// </summary>
        /// <returns></returns>
        private static Bitmap BgImage()
        {
            WebClient web = new WebClient();
            int num = RandomNext(1, 10);
            string url =  string.Format(@"D:\web\LinkinWeb\Content\img\captcha\{0}.jpg",num);
            //System.Web.Hosting.HostingEnvironment.MapPath($"/Content/img/captcha/{num}.jpg");
            Bitmap bitmap = new Bitmap(url);
            return bitmap;
        }
        public static Bitmap ChangeImagSize(System.Drawing.Image imgToResize, Size size)
        {
            //获取图片宽度
            int sourceWidth = imgToResize.Width;
            //获取图片高度
            int sourceHeight = imgToResize.Height;
            float nPercent = 0;
            float nPercentW = 0;
            float nPercentH = 0;
            //计算宽度的缩放比例
            nPercentW = ((float)size.Width / (float)sourceWidth);
            //计算高度的缩放比例
            nPercentH = ((float)size.Height / (float)sourceHeight);
            if (nPercentH < nPercentW)
                nPercent = nPercentH;
            else
                nPercent = nPercentW;
            //期望的宽度
            int destWidth = (int)(sourceWidth * nPercent);
            //期望的高度
            int destHeight = (int)(sourceHeight * nPercent);
            Bitmap b = new Bitmap(destWidth, destHeight);
            return b;
        }
        /// <summary>
        /// base64转图片
        /// </summary>
        /// <param name="base64string"></param>
        /// <returns></returns>
        public static Bitmap Base64ToImage(string base64string)
        {
            byte[] b = Convert.FromBase64String(base64string);
            MemoryStream ms = new MemoryStream(b);
            Bitmap bitmap = new Bitmap(ms);
            return bitmap;
        }
        /// <summary>
        /// 图片转base64
        /// </summary>
        /// <param name="image"></param>
        /// <returns></returns>
        public static string ImageToBase64(Image image, ImageFormat format)
        {
            if (image == null) return string.Empty;
            string strbaser64 = "";
            try
            {
                string head = "";
                string formatName = NameFromGuid(format);
                head = $"data:image/{formatName.ToLower()};base64,";
                MemoryStream ms = new MemoryStream();
                image.Save(ms, format);
                byte[] arr = new byte[ms.Length];
                ms.Position = 0;
                ms.Read(arr, 0, (int)ms.Length);
                ms.Close();
                strbaser64 = head + Convert.ToBase64String(arr);
            }
            catch (Exception)
            {
                throw new Exception("Something wrong during convert!");
            }
            return strbaser64;
        }
        private static Dictionary<string, string> Formats = new Dictionary<string, string>() {
                            {"b96b3caa-0728-11d3-9d7b-0000f81ef32e","MemoryBmp"},
                            {"b96b3cab-0728-11d3-9d7b-0000f81ef32e","Bmp"},
                            {"b96b3cac-0728-11d3-9d7b-0000f81ef32e","Emf"},
                            {"b96b3cad-0728-11d3-9d7b-0000f81ef32e","Wmf"},
                            {"b96b3cae-0728-11d3-9d7b-0000f81ef32e","Jpeg"},
                            {"b96b3caf-0728-11d3-9d7b-0000f81ef32e","Png"},
                            {"b96b3cb0-0728-11d3-9d7b-0000f81ef32e","Gif"},
                            {"b96b3cb1-0728-11d3-9d7b-0000f81ef32e","Tiff"},
                            {"b96b3cb2-0728-11d3-9d7b-0000f81ef32e","Exif"},
                            {"b96b3cb5-0728-11d3-9d7b-0000f81ef32e","Icon"}
        };
        public static ImageFormat FormatFromGuid(ImageFormat format)
        {
            return FormatFromGuid(format.Guid);
        }
        public static ImageFormat FormatFromGuid(Guid guid)
        {
            return FormatFromGuid(guid.ToString());
        }
        public static ImageFormat FormatFromGuid(string guid)
        {
            if (Formats.ContainsKey(guid))
            {
                string name = Formats[guid];
                ImageFormat format = null;
                switch (name)
                {
                    case "MemoryBmp":
                        format = ImageFormat.MemoryBmp;
                        break;
                    case "Bmp":
                        format = ImageFormat.Bmp;
                        break;
                    case "Emf":
                        format = ImageFormat.Emf;
                        break;
                    case "Wmf":
                        format = ImageFormat.Wmf;
                        break;
                    case "Gif":
                        format = ImageFormat.Gif;
                        break;
                    case "Jpeg":
                        format = ImageFormat.Jpeg;
                        break;
                    case "Png":
                        format = ImageFormat.Png;
                        break;
                    case "Tiff":
                        format = ImageFormat.Tiff;
                        break;
                    case "Exif":
                        format = ImageFormat.Exif;
                        break;
                    case "Icon":
                        format = ImageFormat.Icon;
                        break;
                }
                return format;
            }
            else
            {
                return null;
            }
        }
        public static string NameFromGuid(ImageFormat format)
        {
            return NameFromGuid(format.Guid);
        }
        public static string NameFromGuid(Guid guid)
        {
            return NameFromGuid(guid.ToString());
        }
        public static string NameFromGuid(string guid)
        {
            if (Formats.ContainsKey(guid))
            {
                return Formats[guid];
            }
            else
            {
                return string.Empty;
            }
        }
    }
}

:::info 新建

:::

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
namespace XXX.Models
{
    public class SliderCaptchaConfig
    {
        private static string strwatermarkText = System.Configuration.ConfigurationManager.AppSettings["watermarkText"];
        /// <summary>
        /// 矩形宽
        /// </summary>
        public static int l = 42;
        /// <summary>
        /// 圆形半径
        /// </summary>
        public static int r = 9;
        /// <summary>
        /// 圆形直径
        /// </summary>
        public static int d = r * 2;
        /// <summary>
        /// 计算圆形与矩形交接三角形边
        /// </summary>
        public static int a = (int)(r * Math.Sin(Math.PI * (50 / 180f)));
        public static int b = (int)(r * Math.Cos(Math.PI * (50 / 180f)));
        public static int c = r - a;
        /// <summary>
        /// 滑块边框
        /// </summary>
        public static int blod = 2;
        /// <summary>
        /// 水印
        /// </summary>
        public static string watermarkText = strwatermarkText;
        /// <summary>
        /// 是否显示水印
        /// </summary>
        public static bool showWatermark = true;
    }
}