rucaptcha 3.0.0-arm64-darwin

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

@@ -0,0 +1,4 @@
+require "mkmf"
+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(3) + 1) as i32 {
+            let offset = j * (rand_num(2) 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: 300,
+            height: 100,
+            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/cache.rb

@@ -0,0 +1,12 @@
+require "fileutils"
+
+module RuCaptcha
+  class << self
+    def cache
+      return @cache if defined? @cache
+
+      @cache = ActiveSupport::Cache.lookup_store(RuCaptcha.config.cache_store)
+      @cache
+    end
+  end
+end

data/lib/rucaptcha/configuration.rb

@@ -0,0 +1,15 @@
+module RuCaptcha
+  class Configuration
+    # Store Captcha code where, this config more like Rails config.cache_store
+    # default: Rails application config.cache_store
+    attr_accessor :cache_store
+    # rucaptcha expire time, default 2 minutes
+    attr_accessor :expires_in
+    # Chars length: default 5, allows: [3..7]
+    attr_accessor :length
+    # Hard mode, default: 5, allows: [1..10]
+    attr_accessor :difficulty
+    # skip_cache_store_check, default: false
+    attr_accessor :skip_cache_store_check
+  end
+end

data/lib/rucaptcha/controller_helpers.rb

@@ -0,0 +1,100 @@
+module RuCaptcha
+  module ControllerHelpers
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :verify_rucaptcha?
+    end
+
+    def rucaptcha_session_id
+      cookies[:_rucaptcha_session_id]
+    end
+
+    # session key of rucaptcha
+    def rucaptcha_sesion_key_key
+      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(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],
+        time: Time.now.to_i
+      }
+      RuCaptcha.cache.write(rucaptcha_sesion_key_key, session_val, expires_in: RuCaptcha.config.expires_in)
+      res[1]
+    end
+
+    # Verify captcha code
+    #
+    # params:
+    # resource - [optional] a ActiveModel object, if given will add validation error message to object.
+    # :keep_session - if true, RuCaptcha will not delete the captcha code session.
+    # :captcha - if given, the value of it will be used to verify the captcha,
+    #            if do not give or blank, the value of params[:_rucaptcha] will be used to verify the captcha
+    #
+    # exmaples:
+    #
+    #   verify_rucaptcha?
+    #   verify_rucaptcha?(user, keep_session: true)
+    #   verify_rucaptcha?(nil, keep_session: true)
+    #   verify_rucaptcha?(nil, captcha: params[:user][:captcha])
+    #
+    def verify_rucaptcha?(_resource = nil, opts = {})
+      opts ||= {}
+
+      store_info = RuCaptcha.cache.read(rucaptcha_sesion_key_key)
+      # make sure move used key
+      RuCaptcha.cache.delete(rucaptcha_sesion_key_key) unless opts[:keep_session]
+
+      # Make sure session exist
+      return add_rucaptcha_validation_error if store_info.blank?
+
+      # Make sure not expire
+      return add_rucaptcha_validation_error if (Time.now.to_i - store_info[:time]) > RuCaptcha.config.expires_in
+
+      # Make sure parama have captcha
+      captcha = (opts[:captcha] || params[:_rucaptcha] || "").downcase.strip
+      return add_rucaptcha_validation_error if captcha.blank?
+
+      return add_rucaptcha_validation_error if captcha != store_info[:code]
+
+      true
+    end
+
+    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"))
+      end
+      false
+    end
+
+    def warning_when_session_invalid
+      return unless Rails.env.development?
+
+      Rails.logger.warn "
+        WARNING! The session.id is blank, RuCaptcha can't work properly, please keep session available.
+        More details about this: https://github.com/huacnlee/rucaptcha/pull/66
+      "
+    end
+  end
+end

data/lib/rucaptcha/engine.rb

@@ -0,0 +1,15 @@
+module RuCaptcha
+  class Engine < ::Rails::Engine
+    isolate_namespace RuCaptcha
+
+    initializer "rucaptcha.init" do |app|
+      # https://github.com/rails/rails/blob/3-2-stable/actionpack/lib/action_dispatch/routing/route_set.rb#L268
+      # `app.routes.prepend` start from Rails 3.2 - 5.0
+      app.routes.prepend do
+        mount RuCaptcha::Engine => "/rucaptcha"
+      end
+
+      RuCaptcha.check_cache_store! unless RuCaptcha.config.skip_cache_store_check
+    end
+  end
+end

data/lib/rucaptcha/errors/configuration.rb

@@ -0,0 +1,5 @@
+module RuCaptcha
+  module Errors
+    class Configuration < StandardError; end
+  end
+end

data/lib/rucaptcha/version.rb

@@ -0,0 +1,3 @@
+module RuCaptcha
+  VERSION = "3.0.0"
+end

data/lib/rucaptcha/view_helpers.rb

@@ -0,0 +1,22 @@
+module RuCaptcha
+  module ViewHelpers
+    def rucaptcha_input_tag(opts = {})
+      opts[:name] = "_rucaptcha"
+      opts[:type] = "text"
+      opts[:autocorrect] = "off"
+      opts[:autocapitalize] = "off"
+      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] = @rucaptcha_image_tag__image_path_in_this_request
+      opts[:onclick] = "this.src = '#{ru_captcha.root_path}?t=' + Date.now();"
+      tag(:img, opts)
+    end
+  end
+end

data/lib/rucaptcha.rb

@@ -0,0 +1,83 @@
+require "rails"
+require "action_controller"
+require "active_support/all"
+
+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"
+require "rucaptcha/view_helpers"
+require "rucaptcha/cache"
+require "rucaptcha/engine"
+require "rucaptcha/errors/configuration"
+
+module RuCaptcha
+  class << self
+    def config
+      return @config if defined?(@config)
+
+      @config = Configuration.new
+      @config.length = 5
+      @config.difficulty = 3
+      @config.expires_in = 2.minutes
+      @config.skip_cache_store_check = false
+
+      @config.cache_store = if Rails.application
+                              Rails.application.config.cache_store
+                            else
+                              :mem_cache_store
+                            end
+      @config.cache_store
+      @config
+    end
+
+    def configure(&block)
+      config.instance_exec(&block)
+    end
+
+    def generate
+      length = config.length
+
+      raise RuCaptcha::Errors::Configuration, "length config error, value must in 3..7" unless length.in?(3..7)
+
+      result = RuCaptchaCore.create(length, config.difficulty || 5)
+      [result[0].downcase, result[1].pack("c*")]
+    end
+
+    def check_cache_store!
+      cache_store = RuCaptcha.config.cache_store
+      store_name = cache_store.is_a?(Array) ? cache_store.first : cache_store
+      if %i[memory_store null_store file_store].include?(store_name)
+        RuCaptcha.config.cache_store = [:file_store, Rails.root.join("tmp/cache/rucaptcha/session")]
+
+        puts "
+
+  RuCaptcha's cache_store requirements are stored across processes and machines,
+  such as :mem_cache_store, :redis_store, or other distributed storage.
+  But your current set is #{cache_store}, it has changed to :file_store for working.
+  NOTE: :file_store is still not a good way, it only works with single server case.
+
+  Please make config file `config/initializers/rucaptcha.rb` to setup `cache_store`.
+  More infomation please read GitHub RuCaptcha README file.
+  https://github.com/huacnlee/rucaptcha
+
+"
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:action_controller) do
+  ActionController::Base.include RuCaptcha::ControllerHelpers
+end
+
+ActiveSupport.on_load(:action_view) do
+  include RuCaptcha::ViewHelpers
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: rucaptcha
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: arm64-darwin
+authors:
+- Jason Lee
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-10-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.18
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.18
+description:
+email: huacnlee@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- app/controllers/ru_captcha/captcha_controller.rb
+- config/routes.rb
+- ext/rucaptcha/Cargo.lock
+- ext/rucaptcha/Cargo.toml
+- ext/rucaptcha/extconf.rb
+- ext/rucaptcha/src/captcha.rs
+- ext/rucaptcha/src/lib.rs
+- lib/rucaptcha.rb
+- lib/rucaptcha/2.7/rucaptcha.bundle
+- lib/rucaptcha/3.0/rucaptcha.bundle
+- lib/rucaptcha/3.1/rucaptcha.bundle
+- lib/rucaptcha/cache.rb
+- lib/rucaptcha/configuration.rb
+- lib/rucaptcha/controller_helpers.rb
+- lib/rucaptcha/engine.rb
+- lib/rucaptcha/errors/configuration.rb
+- lib/rucaptcha/version.rb
+- lib/rucaptcha/view_helpers.rb
+homepage: https://github.com/huacnlee/rucaptcha
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.2.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.0.dev
+signing_key:
+specification_version: 4
+summary: Captcha Gem for Rails, which generates captcha image by Rust.
+test_files: []