rucaptcha 2.5.5 → 3.0.0.beta1

data/ext/rucaptcha/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+edition = "2021"
+name = "rucaptcha"
+version = "3.0.0"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+image = "0.24.4"
+imageproc = "0.23.0"
+magnus = "0.3"
+rand = "0.8.5"
+rusttype = "0.9.2"

data/ext/rucaptcha/extconf.rb

@@ -1,2 +1,4 @@
 require "mkmf"
-create_makefile("rucaptcha/rucaptcha")
+require "rb_sys/mkmf"
+
+create_rust_makefile("rucaptcha/rucaptcha")

data/ext/rucaptcha/src/captcha.rs

@@ -0,0 +1,250 @@
+use image::{ImageBuffer, Rgb};
+use imageproc::drawing::{draw_cubic_bezier_curve_mut, draw_hollow_ellipse_mut, draw_text_mut};
+use imageproc::noise::{gaussian_noise_mut, salt_and_pepper_noise_mut};
+use rand::{thread_rng, Rng};
+use rusttype::{Font, Scale};
+use std::io::Cursor;
+
+static BASIC_CHAR: [char; 54] = [
+    '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'M',
+    'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
+    'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+];
+
+static FONT_BYTES1: &[u8; 145008] = include_bytes!("../fonts/FuzzyBubbles-Regular.ttf");
+static FONT_BYTES2: &[u8; 37792] = include_bytes!("../fonts/Handlee-Regular.ttf");
+
+static COLORS: [(u8, u8, u8); 10] = [
+    (204, 11, 143),
+    (124, 10, 190),
+    (87, 0, 200),
+    (61, 86, 168),
+    (63, 166, 126),
+    (69, 187, 48),
+    (105, 208, 3),
+    (160, 208, 3),
+    (216, 219, 2),
+    (50, 50, 50),
+];
+
+static SCALE_SM: u32 = 32;
+static SCALE_MD: u32 = 45;
+static SCALE_LG: u32 = 55;
+
+fn rand_num(len: usize) -> usize {
+    let mut rng = thread_rng();
+    rng.gen_range(0..=len)
+}
+
+fn get_captcha(len: usize) -> Vec<String> {
+    let mut res = vec![];
+    for _ in 0..len {
+        let rnd = rand_num(53);
+        res.push(BASIC_CHAR[rnd].to_string())
+    }
+    res
+}
+
+#[allow(unused)]
+fn get_color() -> Rgb<u8> {
+    let rnd = rand_num(COLORS.len());
+    let c = COLORS[rnd];
+    Rgb([c.0, c.1, c.2])
+}
+
+fn get_colors(num: usize) -> Vec<Rgb<u8>> {
+    let rnd = rand_num(COLORS.len());
+    let mut out = vec![];
+    for i in 0..num {
+        let c = COLORS[(rnd + i) % COLORS.len()];
+        out.push(Rgb([c.0, c.1, c.2]))
+    }
+
+    out
+}
+
+fn get_next(min: f32, max: u32) -> f32 {
+    min + rand_num(max as usize - min as usize) as f32
+}
+
+fn get_font() -> Font<'static> {
+    match rand_num(2) {
+        0 => Font::try_from_bytes(FONT_BYTES1).unwrap(),
+        1 => Font::try_from_bytes(FONT_BYTES2).unwrap(),
+        _ => Font::try_from_bytes(FONT_BYTES1).unwrap(),
+    }
+}
+
+fn get_image(width: usize, height: usize) -> ImageBuffer<Rgb<u8>, Vec<u8>> {
+    ImageBuffer::from_fn(width as u32, height as u32, |_, _| {
+        image::Rgb([255, 255, 255])
+    })
+}
+
+fn cyclic_write_character(res: &[String], image: &mut ImageBuffer<Rgb<u8>, Vec<u8>>) {
+    let c = (image.width() - 20) / res.len() as u32;
+    let y = image.height() / 3 - 15;
+
+    let h = image.height() as f32;
+
+    let scale = match res.len() {
+        1..=3 => SCALE_LG,
+        4..=5 => SCALE_MD,
+        _ => SCALE_SM,
+    } as f32;
+
+    let colors = get_colors(res.len());
+
+    let xscale = scale - rand_num((scale * 0.2) as usize) as f32;
+    let yscale = h as f32 - rand_num((h * 0.2) as usize) as f32;
+
+    for (i, _) in res.iter().enumerate() {
+        let text = &res[i];
+
+        let color = colors[i];
+        let font = get_font();
+        let line_color = colors[rand_num(colors.len() - 1)];
+
+        for j in 0..(rand_num(2) + 1) as i32 {
+            let offset = j * (rand_num(3) as i32 + 1);
+            draw_text_mut(
+                image,
+                color,
+                10 + offset + (i as u32 * c) as i32,
+                y as i32 as i32,
+                Scale {
+                    x: xscale + offset as f32,
+                    y: yscale as f32,
+                },
+                &font,
+                text,
+            );
+        }
+
+        draw_interference_line(1, image, line_color);
+        draw_interference_ellipse(1, image, line_color);
+    }
+}
+
+fn draw_interference_line(num: usize, image: &mut ImageBuffer<Rgb<u8>, Vec<u8>>, color: Rgb<u8>) {
+    for _ in 0..num {
+        let width = image.width();
+        let height = image.height();
+        let x1: f32 = 5.0;
+        let y1 = get_next(x1, height / 2);
+
+        let x2 = (width - 5) as f32;
+        let y2 = get_next(5.0, height - 5);
+
+        let ctrl_x = get_next((width / 6) as f32, width / 4 * 3);
+        let ctrl_y = get_next(x1, height - 5);
+
+        let ctrl_x2 = get_next((width / 4) as f32, width / 4 * 3);
+        let ctrl_y2 = get_next(x1, height - 5);
+        // Randomly draw bezier curves
+        draw_cubic_bezier_curve_mut(
+            image,
+            (x1, y1),
+            (x2, y2),
+            (ctrl_x, ctrl_y),
+            (ctrl_x2, ctrl_y2),
+            color,
+        );
+    }
+}
+
+fn draw_interference_ellipse(
+    num: usize,
+    image: &mut ImageBuffer<Rgb<u8>, Vec<u8>>,
+    color: Rgb<u8>,
+) {
+    for _ in 0..num {
+        let w = (10 + rand_num(10)) as i32;
+        let x = rand_num((image.width() - 25) as usize) as i32;
+        let y = rand_num((image.height() - 15) as usize) as i32;
+        draw_hollow_ellipse_mut(image, (x, y), w, w, color);
+    }
+}
+
+pub struct Captcha {
+    pub text: String,
+    pub image: Vec<u8>,
+}
+
+pub struct CaptchaBuilder {
+    length: usize,
+    width: usize,
+    height: usize,
+    complexity: usize,
+}
+
+impl CaptchaBuilder {
+    pub fn new() -> Self {
+        CaptchaBuilder {
+            length: 4,
+            width: 240,
+            height: 64,
+            complexity: 5,
+        }
+    }
+
+    pub fn length(mut self, length: usize) -> Self {
+        self.length = length;
+        self
+    }
+
+    // pub fn width(mut self, width: usize) -> Self {
+    //     self.width = width;
+    //     self
+    // }
+
+    // pub fn height(mut self, height: usize) -> Self {
+    //     self.height = height;
+    //     self
+    // }
+
+    pub fn complexity(mut self, complexity: usize) -> Self {
+        let mut complexity = complexity;
+        if complexity > 10 {
+            complexity = 10;
+        }
+        if complexity < 1 {
+            complexity = 1;
+        }
+        self.complexity = complexity;
+        self
+    }
+
+    pub fn build(self) -> Captcha {
+        // Generate an array of captcha characters
+        let res = get_captcha(self.length);
+
+        let text = res.join("");
+
+        // Create a white background image
+        let mut image = get_image(self.width, self.height);
+
+        // Loop to write the verification code string into the background image
+        cyclic_write_character(&res, &mut image);
+
+        gaussian_noise_mut(
+            &mut image,
+            (self.complexity - 1) as f64,
+            ((10 * self.complexity) - 10) as f64,
+            ((5 * self.complexity) - 5) as u64,
+        );
+
+        salt_and_pepper_noise_mut(
+            &mut image,
+            ((0.001 * self.complexity as f64) - 0.001) as f64,
+            (0.8 * self.complexity as f64) as u64,
+        );
+
+        let mut bytes: Vec<u8> = Vec::new();
+        image
+            .write_to(&mut Cursor::new(&mut bytes), image::ImageFormat::Png)
+            .unwrap();
+
+        Captcha { text, image: bytes }
+    }
+}

data/ext/rucaptcha/src/lib.rs

@@ -0,0 +1,18 @@
+use magnus::{define_class, function, Error, Object};
+
+mod captcha;
+
+pub fn create(len: usize, difficulty: usize) -> (String, Vec<u8>) {
+    let c = captcha::CaptchaBuilder::new();
+    let out = c.complexity(difficulty).length(len).build();
+
+    (out.text, out.image)
+}
+
+#[magnus::init]
+fn init() -> Result<(), Error> {
+    let class = define_class("RuCaptchaCore", Default::default())?;
+    class.define_singleton_method("create", function!(create, 2))?;
+
+    Ok(())
+}

data/lib/rucaptcha/configuration.rb

@@ -5,14 +5,10 @@ module RuCaptcha
     attr_accessor :cache_store
     # rucaptcha expire time, default 2 minutes
     attr_accessor :expires_in
-    # Color style, default: :colorful, allows: [:colorful, :black_white]
-    attr_accessor :style
     # Chars length: default 5, allows: [3..7]
     attr_accessor :length
-    # strikethrough, default: true
-    attr_accessor :strikethrough
-    # outline style for hard mode, default: false
-    attr_accessor :outline
+    # Hard mode, default: 5, allows: [1..10]
+    attr_accessor :difficulty
     # skip_cache_store_check, default: false
     attr_accessor :skip_cache_store_check
   end

data/lib/rucaptcha/controller_helpers.rb

@@ -6,19 +6,24 @@ module RuCaptcha
       helper_method :verify_rucaptcha?
     end
 
+    def rucaptcha_session_id
+      cookies[:_rucaptcha_session_id]
+    end
+
     # session key of rucaptcha
     def rucaptcha_sesion_key_key
-      session_id = session.respond_to?(:id) ? session.id : session[:session_id]
-      warning_when_session_invalid if session_id.blank?
+      warning_when_session_invalid if rucaptcha_session_id.blank?
 
       # With https://github.com/rack/rack/commit/7fecaee81f59926b6e1913511c90650e76673b38
       # to protected session_id into secret
-      session_id_digest = Digest::SHA256.hexdigest(session_id.inspect)
+      session_id_digest = Digest::SHA256.hexdigest(rucaptcha_session_id.inspect)
       ["rucaptcha-session", session_id_digest].join(":")
     end
 
     # Generate a new Captcha
     def generate_rucaptcha
+      generate_rucaptcha_session_id
+
       res = RuCaptcha.generate
       session_val = {
         code: res[0],
@@ -67,6 +72,15 @@ module RuCaptcha
 
     private
 
+    def generate_rucaptcha_session_id
+      return if rucaptcha_session_id.present?
+
+      cookies[:_rucaptcha_session_id] = {
+        value: SecureRandom.hex(16),
+        expires: 1.day
+      }
+    end
+
     def add_rucaptcha_validation_error
       if defined?(resource) && resource && resource.respond_to?(:errors)
         resource.errors.add(:base, t("rucaptcha.invalid"))

data/lib/rucaptcha/version.rb

@@ -1,3 +1,3 @@
 module RuCaptcha
-  VERSION = "2.5.5"
+  VERSION = "3.0.0.beta1"
 end

data/lib/rucaptcha/view_helpers.rb

@@ -1,19 +1,20 @@
 module RuCaptcha
   module ViewHelpers
     def rucaptcha_input_tag(opts = {})
-      opts[:name]           = "_rucaptcha"
-      opts[:type]           = "text"
-      opts[:autocorrect]    = "off"
+      opts[:name] = "_rucaptcha"
+      opts[:type] = "text"
+      opts[:autocorrect] = "off"
       opts[:autocapitalize] = "off"
-      opts[:pattern]        = "[a-zA-Z]*"
-      opts[:autocomplete]   = "off"
-      opts[:maxlength]      = RuCaptcha.config.length
+      opts[:pattern] = "[a-zA-Z0-9]*"
+      opts[:autocomplete] = "off"
+      opts[:maxlength] = RuCaptcha.config.length
       tag(:input, opts)
     end
 
     def rucaptcha_image_tag(opts = {})
+      @rucaptcha_image_tag__image_path_in_this_request ||= "#{ru_captcha.root_path}?t=#{Time.now.strftime('%s%L')}"
       opts[:class] = opts[:class] || "rucaptcha-image"
-      opts[:src] = ru_captcha.root_path
+      opts[:src] = @rucaptcha_image_tag__image_path_in_this_request
       opts[:onclick] = "this.src = '#{ru_captcha.root_path}?t=' + Date.now();"
       tag(:img, opts)
     end

data/lib/rucaptcha.rb

@@ -1,7 +1,15 @@
 require "rails"
 require "action_controller"
 require "active_support/all"
-require "rucaptcha/rucaptcha"
+
+begin
+  # load the precompiled extension file
+  ruby_version = /(\d+\.\d+)/.match(::RUBY_VERSION)
+  require_relative "rucaptcha/#{ruby_version}/rucaptcha"
+rescue LoadError
+  require "rucaptcha/rucaptcha"
+end
+
 require "rucaptcha/version"
 require "rucaptcha/configuration"
 require "rucaptcha/controller_helpers"
@@ -16,11 +24,9 @@ module RuCaptcha
       return @config if defined?(@config)
 
       @config = Configuration.new
-      @config.style         = :colorful
-      @config.length        = 5
-      @config.strikethrough = true
-      @config.outline       = false
-      @config.expires_in    = 2.minutes
+      @config.length = 5
+      @config.difficulty = 3
+      @config.expires_in = 2.minutes
       @config.skip_cache_store_check = false
 
       @config.cache_store = if Rails.application
@@ -37,14 +43,12 @@ module RuCaptcha
     end
 
     def generate
-      style = config.style == :colorful ? 1 : 0
       length = config.length
 
       raise RuCaptcha::Errors::Configuration, "length config error, value must in 3..7" unless length.in?(3..7)
 
-      strikethrough = config.strikethrough ? 1 : 0
-      outline = config.outline ? 1 : 0
-      create(style, length, strikethrough, outline)
+      result = RuCaptchaCore.create(length, config.difficulty || 5)
+      [result[0], result[1].pack("c*")]
     end
 
     def check_cache_store!

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rucaptcha
 version: !ruby/object:Gem::Version
-  version: 2.5.5
+  version: 3.0.0.beta1
 platform: ruby
 authors:
 - Jason Lee
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-27 00:00:00.000000000 Z
+date: 2022-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
-  name: rake-compiler
+  name: rb_sys
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
-  type: :development
+        version: 0.9.18
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: 0.9.18
 description:
 email: huacnlee@gmail.com
 executables: []
@@ -45,18 +45,13 @@ extensions:
 - ext/rucaptcha/extconf.rb
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
 - README.md
-- app/controllers/ru_captcha/captcha_controller.rb
-- config/locales/rucaptcha.en.yml
-- config/locales/rucaptcha.pt-BR.yml
-- config/locales/rucaptcha.zh-CN.yml
-- config/locales/rucaptcha.zh-TW.yml
-- config/routes.rb
-- ext/rucaptcha/colors.h
+- Rakefile
+- ext/rucaptcha/Cargo.lock
+- ext/rucaptcha/Cargo.toml
 - ext/rucaptcha/extconf.rb
-- ext/rucaptcha/font.h
-- ext/rucaptcha/rucaptcha.c
+- ext/rucaptcha/src/captcha.rs
+- ext/rucaptcha/src/lib.rs
 - lib/rucaptcha.rb
 - lib/rucaptcha/cache.rb
 - lib/rucaptcha/configuration.rb
@@ -77,16 +72,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.4.0.dev
 signing_key:
 specification_version: 4
-summary: This is a Captcha gem for Rails Applications. It drawing captcha image with
-  C code so it no dependencies.
+summary: Captcha Gem for Rails, which generates captcha image by Rust.
 test_files: []