public WarpTextDrawing(CaptchaOptions options)
: this(options.Width, options.Height,
options.Items[CaptchaOptionNames.Fonts] ?? CaptchaOptionDefaults.Fonts,
ColorHelper.Parse(options.Items[CaptchaOptionNames.TextColor] ?? CaptchaOptionDefaults.TextColor, Color.BlueViolet),
(FontWarpFactor)Enum.Parse(typeof(FontWarpFactor), options.Items[CaptchaOptionNames.FontWarp] ?? CaptchaOptionDefaults.FontWarp, true))
{
}
public CurveDrawing(CaptchaOptions options)
: this(options.Width, options.Height,
(NoiseLevel)Enum.Parse(typeof(NoiseLevel), options.Items[CaptchaOptionNames.CurveNoiseLevel]
?? options.Items[CaptchaOptionNames.NoiseLevel] ?? CaptchaOptionDefaults.CurveNoiseLevel, true),
ColorHelper.Parse(options.Items[CaptchaOptionNames.CurveNoiseColor]
?? options.Items[CaptchaOptionNames.NoiseColor] ?? CaptchaOptionDefaults.CurveNoiseColor, Color.Beige))
{
}
public DefaultTuringNumberProvider(CaptchaOptions options)
{
var items = options.Items;
m_characterGroup = items[CaptchaOptionNames.Chars] ?? CaptchaOptionDefaults.Chars;
m_max = NameValueCollectionHelper.ConvertToInt32(items, CaptchaOptionNames.MaxChars, CaptchaOptionDefaults.MaxChars);
m_min = NameValueCollectionHelper.ConvertToInt32(items, CaptchaOptionNames.MinChars, m_max);
}
public CaptchaStorageService(IDistributedCache distributedCache, IOptions <CaptchaOptions> captchaOptions)
{
_distributedCache = distributedCache;
_captchaOptions = captchaOptions?.Value;
_cacheOptions = new DistributedCacheEntryOptions
{
AbsoluteExpirationRelativeToNow = _captchaOptions.Timeout
};
}
public CaptchaGeneratorService(ICaptchaStorageService storage, IOptions <CaptchaOptions> captchaOptions,
IKeyGeneratorService key, IFontGeneratorService font, IEffectGeneratorService effect)
{
_storage = storage;
Options = captchaOptions?.Value;
_key = key;
_font = font;
_effect = effect;
}
/// <summary>
///
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public async Task <(int Code, byte[] Audio)> GenerateAsync(CaptchaOptions options)
{
await Task.FromResult(0);
var(equation, answer) = Arithmetic.Build(options);
var audio = Speech.Generate(equation.ToString(" "));
return(answer, audio);
}
/// <summary>
///
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public (string[] Equation, int Answer) Build(CaptchaOptions options)
{
var random = new Random();
int x, y, z;
var @operator = operators[random.Next(operators.Length)];
switch (@operator)
{
case "+":
x = random.Next(MaxWhenAddition);
y = random.Next(MaxWhenAddition);
z = x + y;
break;
case "-":
int tmp = MaxWhenSubtraction / 2;
x = random.Next(tmp, MaxWhenSubtraction);
y = random.Next(tmp);
z = x - y;
break;
case "×":
x = random.Next(MaxWhenMultiplication);
y = random.Next(MaxWhenMultiplication);
z = x * y;
break;
case "÷":
x = random.Next(1, MaxWhenDivision);
var divisors = x.Divisors();
y = divisors[random.Next(divisors.Count)];
z = x / y;
break;
default:
@operator = "+";
x = random.Next(MaxWhenAddition);
y = random.Next(MaxWhenAddition);
z = x + y;
break;
}
var equation = new List <string>
{
x.ToString(),
UseZhInsteadOfOperator ? options.ArithmeticOperatorsText[@operator] : @operator.ToString(),
y.ToString(),
UseZhInsteadOfOperator ? "等于" : "="
};
if (EndWithQuestion)
{
equation.Add("?");
}
return(equation.ToArray(), z);
}
/// <summary>
///
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public async Task <(int Code, Image Image)> GenerateAsync(CaptchaOptions options)
{
await Task.FromResult(0);
var(equation, answer) = Arithmetic.Build(options);
var image = Image.Generate(equation, options);
return(answer, image);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public async Task <(string Code, Image Image)> GenerateAsync(CaptchaOptions options)
{
await Task.FromResult(0);
var str = String.Build();
var image = Image.Generate(str.Select(_ => _.ToString()), options);
return(str, image);
}
/// <summary>
///
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public async Task <(string Code, byte[] Audio)> GenerateAsync(CaptchaOptions options)
{
await Task.FromResult(0);
var str = String.Build();
var audio = Speech.Generate(str);
return(str, audio);
}
/// <summary>
///
/// </summary>
public ExternalClient(ILogger <IExternalClient> logger, IHttpContextAccessor contextAccessor, IRedisCache redisCache, AppSettings appSettings, HttpClient httpClient, MapOptions mapOptions, CaptchaOptions captchaOptions)
{
_logger = logger;
_contextAccessor = contextAccessor;
_redisCache = redisCache;
_appSettings = appSettings;
_httpClient = httpClient;
_mapOptions = mapOptions;
_captchaOptions = captchaOptions;
}
public CaptchaCodeMain(
ICaptchaImageProvider captchaImageProvider,
ICaptchaStorageProvider captchaStorageProvider,
ICaptchaCodeGenerator captchaCodeGenerator,
IHttpContextAccessor httpContextAccessor,
CaptchaOptions captchaOptions)
{
_captchaImageProvider = captchaImageProvider;
_captchaStorageProvider = captchaStorageProvider;
_captchaCodeGenerator = captchaCodeGenerator;
_httpContextAccessor = httpContextAccessor;
_captchaOptions = captchaOptions;
}
public EffectGeneratorService(IOptions <EffectOptions> effectOptions, IOptions <CaptchaOptions> captchaOptions)
{
_effectOptions = effectOptions?.Value;
_captchaOptions = captchaOptions?.Value;
_effects = new List <IEffect>()
{
new BlobEffect(_captchaOptions),
new BoxEffect(_captchaOptions),
new LineEffect(_captchaOptions),
new NoiseEffect(_captchaOptions),
new WaveEffect(_captchaOptions),
new RippleEffect(_captchaOptions)
};
_effects = _effects.Where(e => _effectOptions.TryGetValue(e.GetType().Name, out bool enabled) ? enabled : false).ToList();
_effects.Sort((a, b) => a.Order.CompareTo(b.Order));
}
public ActionResult GetCaptcha()
{
CaptchaOptions co = new CaptchaOptions()
{
TextLength = 5,
Width = 160,
FontWarp = Level.High,
BackgroundNoise = Level.Low,
LineNoise = Level.High
};
Captcha captcha = new Captcha(co);
Session["captcha"] = captcha.Text;
byte[] res = null;
captcha.RenderImage(out res); // 渲染图片返回字节数组
return(File(res, "image/jpeg"));
}
public FileContentResult Captcha()
{
CaptchaOptions options = new CaptchaOptions
{
GaussianDeviation = 0.4,
Height = 35,
Background = NoiseLevel.Low,
Line = NoiseLevel.Low
};
using (ICapatcha capatch = new FluentCaptcha())
{
capatch.Options = options;
CaptchaResult captchaResult = capatch.DrawBackgroud().DrawLine().DrawText().Atomized().DrawBroder().DrawImage();
using (captchaResult)
{
MemoryStream ms = new MemoryStream();
captchaResult.Bitmap.Save(ms, ImageFormat.Gif);
Session["Captcha"] = captchaResult.Text;
return(File(ms.ToArray(), "image/gif"));
}
}
}
public RippleEffect(CaptchaOptions captchaOptions)
{
_captchaOptions = captchaOptions;
}
/// <summary>
///
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public async Task <(Point BlockPoint, Image OriginImage, Image BoardImage, Image BlockImage)> GenerateAsync(CaptchaOptions options)
{
await Task.FromResult(0);
var imageFile = Directory
.GetFiles(Path.Combine(options.RootDirectory, options.SliderCodeImageDir))
.RandomTake(1).SingleOrDefault();
using var imageOrigin = (Bitmap)Image.FromFile(imageFile).Resize(Width, Height, true, true);
var s = Math.Min(Width, Height) / 12;
var s_ = s / 2;
var s2 = s * 2;
var s3 = s * 3;
var s4 = s * 4;
var s5 = s * 5;
var random = new Random();
var x = random.Next(s, Width - s4);
var y = random.Next(s, Height - s5);
using var path = new GraphicsPath();
path.AddBezier(x + s, y + s, x + s_, y, x + s2 + s_, y, x + s2, y + s);
path.AddBezier(x + s2, y + s, x + s3, y + s, x + s3, y + s, x + s3, y + s2);
path.AddBezier(x + s3, y + s2, x + s2, y + s + s_, x + s2, y + s3 + s_, x + s3, y + s3);
path.AddBezier(x + s3, y + s3, x + s3, y + s4, x + s3, y + s4, x + s2, y + s4);
path.AddBezier(x + s2, y + s4, x + s2 + s_, y + s3, x + s_, y + s3, x + s, y + s4);
path.AddBezier(x + s, y + s4, x, y + s4, x, y + s4, x, y + s3);
path.AddBezier(x, y + s3, x + s, y + s3 + s_, x + s, y + s + s_, x, y + s2);
path.AddBezier(x, y + s2, x, y + s, x, y + s, x + s, y + s);
var b = path.GetBounds();
var left = (int)b.Left;
var top = (int)b.Top;
var width = (int)b.Width;
var height = (int)b.Height;
var imageBoard = (Bitmap)imageOrigin.Clone();
var imageBlock = new Bitmap(width, height);
for (int i = left; i < left + width; i++)
{
for (int j = top; j < top + height; j++)
{
if (path.IsVisible(i, j))
{
imageBoard.SetPixel(i, j, Color.FromArgb(64, imageOrigin.GetPixel(i, j)));
imageBlock.SetPixel(i - left, j - top, imageOrigin.GetPixel(i, j));
}
else
{
imageBlock.SetPixel(i - left, j - top, Color.Transparent);
}
}
}
return(new Point(x, y), (Image)imageOrigin.Clone(), imageBoard, imageBlock);
}
/// <summary>
///
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public async Task <(Point[] FontPoints, Image FontImage, Image BoardImage)> GenerateAsync(CaptchaOptions options)
{
await Task.FromResult(0);
var imageFile = Directory
.GetFiles(Path.Combine(options.RootDirectory, options.ClickCodeImageDir))
.RandomTake(1).SingleOrDefault();
using var imageOrigin = Image.FromFile(imageFile).Resize(Width, Height, true, true);
var strs = String.Split(new[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries);
var points = new List <Point>(strs.Length);
var imageFont = new Bitmap(FontSize / 2 * String.Length + (int)(FontSize / 2 * 1.5D), (int)(FontSize / 2 * 1.5D));
using var graphicsFont = Graphics.FromImage(imageFont);
graphicsFont.Clear(CaptchaHelper.RandomColor(false));
//绘制干扰线
for (int i = 0; i < 4; i++)
{
var random = new Random(Guid.NewGuid().GetHashCode());
var x = random.Next(imageFont.Width);
var y = random.Next(imageFont.Height);
var x1 = random.Next(imageFont.Width);
var y1 = random.Next(imageFont.Height);
var x2 = random.Next(imageFont.Width);
var y2 = random.Next(imageFont.Height);
var x3 = random.Next(imageFont.Width);
var y3 = random.Next(imageFont.Height);
using var pen = new Pen(CaptchaHelper.RandomColor(true));
graphicsFont.DrawBezier(pen, x, y, x1, y1, x2, y2, x3, y3);
}
var imageBoard = (Image)imageOrigin.Clone();
using var graphicsBoard = Graphics.FromImage(imageBoard);
//绘制文字
for (int i = 0; i < strs.Length; i++)
{
var item = strs[i];
var random = new Random(Guid.NewGuid().GetHashCode());
using var pen = new Pen(CaptchaHelper.RandomColor());
using var font1 = new Font(options.FontFamilies[random.Next(options.FontFamilies.Length)], FontSize / 2, options.FontStyles[random.Next(options.FontStyles.Length)]);
graphicsFont.DrawString(item, font1, pen.Brush, FontSize * i, 0);
var point = new Point(random.Next(0, Width - item.Length * FontSize - FontSize), random.Next(0, Height - FontSize - FontSize));
using var font2 = new Font(options.FontFamilies[random.Next(options.FontFamilies.Length)], FontSize, options.FontStyles[random.Next(options.FontStyles.Length)]);
graphicsBoard.DrawString(item, font2, pen.Brush, point);
points.Add(point);
}
return(points.ToArray(), imageFont, imageBoard);
}
public BlobEffect(CaptchaOptions captchaOptions)
{
_captchaOptions = captchaOptions;
}
public CaptchaService(IDistributedCache distributedCache,
IOptions <CaptchaOptions> captchaOptions)
{
_distributedCache = distributedCache;
_captchaOptions = captchaOptions?.Value;
}
public async Task ShouldReturnFalseWhenValidationLifeTimeElapsed()
{
var token = "token";
var validatorUrl = "uri";
uint tokenLifespanInMinutes = 10;
var captchaOptions = new CaptchaOptions
{
TokenLifespanInMinutes = tokenLifespanInMinutes,
ValidatorUrl = validatorUrl,
Secret = "secret"
};
var clientIP = "1.0.0.0";
var formContent = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("secret", captchaOptions.Secret),
new KeyValuePair <string, string>("response", token),
new KeyValuePair <string, string>("remoteip", clientIP)
});
_mock.Mock <IOptions <CaptchaOptions> >()
.SetupGet(instance => instance.Value)
.Returns(captchaOptions);
var now = new DateTime(2018, 1, 1);
var issuedTime = new DateTime(2018, 1, 1).AddMinutes(-tokenLifespanInMinutes).AddTicks(-1);
_mock.Mock <INowProvider>()
.Setup(instance => instance.Now())
.Returns(now);
var response = new
{
challenge_ts = issuedTime.ToUniversalTime(),
success = true
};
var httpResponse = new HttpResponseMessage
{
Content = new StringContent(JsonConvert.SerializeObject(response))
};
_mock.Mock <IHttpClientProvider>()
.Setup(instance => instance.PostAsync(
validatorUrl,
It.Is <FormUrlEncodedContent>(content => ContentAssert.IsEqual(formContent, content))))
.ReturnsAsync(httpResponse);
_mock.Mock <ConnectionInfo>()
.Setup(instance => instance.RemoteIpAddress)
.Returns(IPAddress.Parse(clientIP));
var connection = _mock.Mock <ConnectionInfo>().Object;
_mock.Mock <HttpContext>()
.Setup(instance => instance.Connection)
.Returns(connection);
var httpContext = _mock.Mock <HttpContext>().Object;
_mock.Mock <IHttpContextAccessor>()
.Setup(instance => instance.HttpContext)
.Returns(httpContext);
var service = _mock.Create <CaptchaValidationService>();
var actual = await service.IsValidAsync(token);
Assert.IsFalse(actual);
}
public WaveEffect(CaptchaOptions captchaOptions)
{
_captchaOptions = captchaOptions;
}
public KeyGeneratorService(IOptions <CaptchaOptions> captchaOptions)
{
_captchaOptions = captchaOptions?.Value;
}
public NoiseEffect(CaptchaOptions captchaOptions)
{
_captchaOptions = captchaOptions;
}
public CaptchaValidationService(ICaptchaStorageService storage, IOptions <CaptchaOptions> captchaOptions)
{
_storage = storage;
_captchaOptions = captchaOptions?.Value;
}
public CaptchaController(IOptions <CaptchaOptions> captchaOptions)
{
_captchaOptions = captchaOptions.Value;
}
public JpegImageCodecInfo(CaptchaOptions options)
: this(NameValueCollectionHelper.ConvertToInt32(options.Items, CaptchaOptionNames.EncoderQuality, CaptchaOptionDefaults.EncoderQuality))
{
}
public CaptchaInstrumentationProvider(CaptchaOptions options)
: this(options.Items[CaptchaOptionNames.InstrumentationCategory] ?? CaptchaOptionDefaults.InstrumentationCategory,
options.Items[CaptchaOptionNames.InstrumentationInstanceNameSuffix] ?? options.Path,
NameValueCollectionHelper.ConvertToBoolean(options.Items, CaptchaOptionNames.InstrumentationEnabled, CaptchaOptionDefaults.InstrumentationEnabled))
{
}
public DefaultVaryByCustomProvider(CaptchaOptions options)
: this(NameValueCollectionHelper.ConvertToInt32(options.Items,
CaptchaOptionNames.MaxVaryCacheSize,
CaptchaOptionDefaults.MaxVaryCacheSize))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="HCaptchaProvider" /> class.
/// </summary>
/// <param name="captchaApi">Contains an instance of the hCAPTCHA API implementation.</param>
/// <param name="captchaOptions">Contains an options accessor for the <see cref="CaptchaOptions" /> settings.</param>
public HCaptchaProvider(IHCaptchaApi captchaApi, CaptchaOptions captchaOptions)
{
this.captchaApi = captchaApi;
this.options = captchaOptions;
}
