uhid 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 95a724401bf1d7cf2d8fb66a56412745c75ef806cd71a9c4b3d2a9febf4d80ed
+  data.tar.gz: 38dcf9a63b553e0e432ef3bcf1d6120dfb2119cf6160cec966f9c878ff0935e4
+SHA512:
+  metadata.gz: 7ecac03e083702842cedc553ccf96fec554eb147b73d3ca7fe4f043aab3c1f9c0b74c86639302053091562ff02414a15911bfc9c4f180a8579538eaa0f80b4f0
+  data.tar.gz: 462ebabcefe0f029292faf59c4a836eb3e267d7fab28aa9c67f6350f5c470419aba0b667338efa87f4778c9d079e52fe31381e8febcf6ab37b43bb20abf58a1d

data/ext/uhid/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+create_makefile "uhid/uhid"
+

data/ext/uhid/uhid.c

@@ -0,0 +1,170 @@
+#include "ruby.h"
+#include "linux/uhid.h"
+#include <fcntl.h>
+
+static void
+cuhid_write(int fd, const struct uhid_event *ev)
+{
+	ssize_t ret;
+
+	ret = write(fd, ev, sizeof(*ev));
+	if (ret < 0) {
+        rb_raise(rb_eRuntimeError, "Cannot write to uhid");
+	} else if (ret != sizeof(*ev)) {
+        rb_raise(rb_eRuntimeError, "Wrong size written to uhid: %zd != %zu",
+                ret, sizeof(ev));
+	} 
+}
+
+static VALUE 
+cuhid_create(VALUE self, VALUE name, VALUE vendor, VALUE product, VALUE data) 
+{
+    Check_Type(name, T_STRING);
+    Check_Type(data, T_STRING);
+
+    struct uhid_event ev; 
+    
+    memset(&ev, 0, sizeof(ev));
+    ev.type = UHID_CREATE2;
+    strncpy((char*)ev.u.create2.name, StringValueCStr(name), 127);
+    ev.u.create2.rd_size = RSTRING_LEN(StringValue(data));
+    memcpy(ev.u.create2.rd_data, RSTRING_PTR(StringValue(data)), ev.u.create2.rd_size);
+    ev.u.create2.bus = BUS_USB;
+    ev.u.create2.vendor = (uint32_t)NUM2INT(vendor);
+    ev.u.create2.product = (uint32_t)NUM2INT(product);
+    ev.u.create2.version = 0;
+	ev.u.create2.country = 0;
+
+    ID file_var = rb_intern("@file");
+    VALUE file = rb_ivar_get(self, file_var);
+    Check_Type(file, T_FILE);
+    VALUE file_fileno = rb_funcall(file, rb_intern("fileno"), 0);
+    int fd = NUM2INT(file_fileno);
+       
+    // This makes the open file non-blocking
+    int flags = fcntl(fd, F_GETFL, 0);
+    fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+
+    cuhid_write(fd, &ev);
+
+    return Qnil;
+}
+
+/*
+ * Close the open uhid device.
+ */
+static VALUE
+cuhid_destroy(VALUE self)
+{
+    struct uhid_event ev; 
+    
+    memset(&ev, 0, sizeof(ev));
+    ev.type = UHID_DESTROY;
+
+    ID file_var = rb_intern("@file");
+    VALUE file = rb_ivar_get(self, file_var);
+    Check_Type(file, T_FILE);
+    VALUE file_fileno = rb_funcall(file, rb_intern("fileno"), 0);
+    int fd = NUM2INT(file_fileno);
+
+    cuhid_write(fd, &ev);
+
+    return Qnil;
+}
+
+/*
+ * Write the given data to the host.
+ *
+ * Make sure you send the data in a format, expected
+ * by the host, e.g. in 64 byte chunks.
+ *
+ * @param data [String] the data to be sent to the host.
+ * @returns [Integer] the number of bytes sent.
+ */
+static VALUE
+cuhid_write_data(VALUE self, VALUE data)
+{
+    const char* d = RSTRING_PTR(StringValue(data));
+    size_t l = RSTRING_LEN(StringValue(data));
+    size_t size = l;
+    if (size > UHID_DATA_MAX) {
+        size = UHID_DATA_MAX;
+    }
+
+    struct uhid_event ev; 
+    
+    memset(&ev, 0, sizeof(ev));
+    ev.type = UHID_INPUT2;
+    memcpy(ev.u.input2.data, d, size);
+    ev.u.input2.size = size;
+
+    ID file_var = rb_intern("@file");
+    VALUE file = rb_ivar_get(self, file_var);
+    Check_Type(file, T_FILE);
+    VALUE file_fileno = rb_funcall(file, rb_intern("fileno"), 0);
+    int fd = NUM2INT(file_fileno);
+
+    cuhid_write(fd, &ev);
+    
+    // We the number of processed bytes
+    return INT2NUM(size);
+}
+
+/*
+ * Read data from the host.
+ *
+ * All returned hashes contain the type key that specifies the type 
+ * of the received packet. Valid types are: START, STOP, OPEN, CLOSE,
+ * OUTPUT. Only OUTPUT Hashes contain a data field that holds the
+ * data received by the host.
+ *
+ * @returns [nil, Hash] a Hash that contains the received data or nil if no data is available.
+ */
+static VALUE
+cuhid_read_data(VALUE self)
+{
+    ID file_var = rb_intern("@file");
+    VALUE file = rb_ivar_get(self, file_var);
+    Check_Type(file, T_FILE);
+    VALUE file_fileno = rb_funcall(file, rb_intern("fileno"), 0);
+    int fd = NUM2INT(file_fileno);
+
+    struct uhid_event ev; 
+    
+    memset(&ev, 0, sizeof(ev));
+    ssize_t ret = read(fd, &ev, sizeof(ev));
+
+    if (ret == -1) { // EAGAIN
+        return Qnil;
+    }
+    
+    VALUE h = rb_hash_new();
+    switch (ev.type) {
+    case UHID_START:
+        rb_hash_aset(h, rb_str_new_cstr("type"), rb_str_new_cstr("START"));
+        return h;
+    case UHID_STOP:
+        rb_hash_aset(h, rb_str_new_cstr("type"), rb_str_new_cstr("STOP"));
+        return h;
+    case UHID_OPEN:
+        rb_hash_aset(h, rb_str_new_cstr("type"), rb_str_new_cstr("OPEN"));
+        return h;
+    case UHID_CLOSE:
+        rb_hash_aset(h, rb_str_new_cstr("type"), rb_str_new_cstr("CLOSE"));
+        return h;
+    case UHID_OUTPUT:
+        rb_hash_aset(h, rb_str_new_cstr("type"), rb_str_new_cstr("OUTPUT"));
+        rb_hash_aset(h, rb_str_new_cstr("data"), rb_str_new((const char *) ev.u.output.data, ev.u.output.size));
+        return h;
+    default:
+        return Qnil;
+    }
+}
+
+void Init_uhid() {
+    VALUE cUhid  = rb_const_get(rb_cObject, rb_intern("Uhid")); 
+    rb_define_private_method(cUhid, "create", cuhid_create, 4);
+    rb_define_private_method(cUhid, "destroy", cuhid_destroy, 0);
+    rb_define_method(cUhid, "write", cuhid_write_data, 1);
+    rb_define_method(cUhid, "read", cuhid_read_data, 0);
+}

data/lib/uhid.rb

@@ -0,0 +1,47 @@
+# Linux UHID class.
+#
+# This class allows the creation of virtual USB HID
+# devices on Linux using the `uhid` kernel module.
+#
+# @author David P. Sugar (r4gus)
+class Uhid
+  VERSION = "0.1.0"
+  
+  # FIDO2/U2F USB report descriptor
+  RD_FIDO = "\x06\xd0\xf1\x09\x01\xa1\x01\x09"\
+            "\x20\x15\x00\x26\xff\x00\x75\x08"\
+            "\x95\x40\x81\x02\x09\x21\x15\x00"\
+            "\x26\xff\x00\x75\x08\x95\x40\x91"\
+            "\x02\xc0".force_encoding("BINARY")
+  
+  # Create a new virtual HID device.
+  #
+  # @param name [String] the name of the device.
+  # @param rd [String] `BINARY` encoded report descriptor.
+  # @param vendor [Integer] vendor ID.
+  # @param product [Integer] product ID.
+  # @param path [String] the file path (usually `/dev/uhid`).
+  def initialize(
+    name = "ruby-fido", 
+    rd = RD_FIDO, 
+    vendor = 0x15d9, 
+    product = 0x0a37, 
+    path = "/dev/uhid"
+  )
+    @file = File.open(path, "r+", File::NONBLOCK)
+    ObjectSpace.define_finalizer(self, method(:finalize))
+    self.create(name, vendor, product, rd)
+  end
+  
+  private
+
+  def finalize(_id)
+    self.destroy()
+    @file.close
+  end
+end
+
+require_relative "uhid/uhid"
+
+
+

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: uhid
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Pierre Sugar
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-12-29 00:00:00.000000000 Z
+dependencies: []
+description: Create virtual USB devices on Linux using the uhid module
+email: david@thesugar.de
+executables: []
+extensions:
+- ext/uhid/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/uhid/extconf.rb
+- ext/uhid/uhid.c
+- lib/uhid.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.0.dev
+signing_key:
+specification_version: 4
+summary: Linux uhid library
+test_files: []