pkcs11_protect_server 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a5fe3b3e7e2b4371955d63d571b32a889cb5cc4ded9c5f4407c7e248a77e373
-  data.tar.gz: 152bcff476fe55a9a288eff56341d1013492d2aad40b48283d6629ca06bb2bb2
+  metadata.gz: 6fd43fb449a5dea77402583aac55585c11918fff2b61c05a836396c0c57349d1
+  data.tar.gz: 02c39243000b40517d52e9ed0440dcdeaddd7e1d61b755d0aec7f5a2fa31243e
 SHA512:
-  metadata.gz: 260fdae7245c78b951906b3e586e64cbf038540f15833c376c49f1fa3f895fa51169aa30b63c1e7e2fafa8feb5701a68056362553cb0cec1ddddbf791130b168
-  data.tar.gz: da7604086b3b6145add4f76290c016bc959a8a18ed4f9dbdbbd82a60d589998271f1654d68f5fba780b3958a4d05cfa5fc37c912f6b4adba19ddae4f2aecb887
+  metadata.gz: 22662ee801a1b4eb0f6f6a1a21cda143d53b0cd1b63c68ff5f8d81275a96d2dbe380fae8e1e5911220928032f320a6b6b2fa163be544a36d317a47095770a68a
+  data.tar.gz: bd545b633cba8caf2318eb3145758eef9bbbb59ebff0ab1452dbd833e98b369c0b0750e05b097082e575bdd76a782112082c7137526cbf1ec78632048389bc44

checksums.yaml.gz.sig

@@ -1 +1,2 @@
-�����5���"����(V}2T�j��%�5�^W���|ַ=�z�p�if@Dk#7�.��;�*��n�����~��?5o�5Ǹ�vB:��F3�i��X�(Zn��m�&J5V�b�/u�6v�S
+��.=	=f�JX�c�#P=�+7��7����;���릴�?fd1����A.@�"a���0����a�kySy�lɴz�=41]�$����cz�wG� 
+��a+��np+@�"�]m��V�SU��.c)F�ї�~���Vuie��a�.�������i�O�XÃ�D�h����

data/Manifest.txt

@@ -4,8 +4,8 @@ Manifest.txt
 README_PROTECT_SERVER.rdoc
 Rakefile
 ext/extconf.rb
-ext/generate_constants.rb
-ext/generate_structs.rb
+ext/generate_protect_server_constants.rb
+ext/generate_protect_server_structs.rb
 ext/pk11s.c
 lib/pkcs11_protect_server.rb
 lib/pkcs11_protect_server/extensions.rb

data/Rakefile

@@ -7,28 +7,37 @@ require 'rake/extensiontask'
 require 'rbconfig'
 
 PROTECT_SERVER_SDK_DIR = ENV['PROTECT_SERVER_SDK_DIR'] || '/opt/ETcpsdk'
-RUBY_PKCS11_EXT_DIR = File.expand_path('../ext')
+RUBY_PKCS11_DIR = File.expand_path('..')
+$: << File.join(RUBY_PKCS11_DIR, "lib")
 
-GENERATED_FILES = [
-  'ext/pk11s_struct_impl.inc',
-  'ext/pk11s_struct_def.inc',
-  'ext/pk11s_const_def.inc',
-  'ext/pk11s_struct.doc',
+SHARED_FILES = [
   'ext/pk11_struct_macros.h',
   'ext/pk11_const_macros.h',
   'ext/pk11_version.h',
+  'ext/generate_structs.rb',
+  'ext/generate_constants.rb',
+]
+GENERATED_FILES = [
+  "ext/std_structs.rb"
 ]
 
+CLEAN.include SHARED_FILES
 CLEAN.include GENERATED_FILES
 CLEAN.include 'lib/pkcs11_protect_server_ext.so'
 CLEAN.include 'tmp'
 
 def pkcs11_version
-  file = File.join(RUBY_PKCS11_EXT_DIR, 'pk11_version.h')
+  file = File.join(RUBY_PKCS11_DIR, 'ext/pk11_version.h')
   version_re = /VERSION += +([\"\'])([\d][\d\w\.]+)\1/
   File.read_utf(file)[version_re, 2]
 end
 
+# Ensure pkg is rebuilt
+task :remove_pkg do
+  rm_rf 'pkg'
+end
+task :gem => [:remove_pkg]
+
 hoe = Hoe.spec 'pkcs11_protect_server' do
   developer('Lars Kanis', 'kanis@comcard.de')
   extra_deps << ['pkcs11', "= #{pkcs11_version}"]
@@ -44,7 +53,7 @@ hoe = Hoe.spec 'pkcs11_protect_server' do
   self.extra_rdoc_files << self.readme_file << 'ext/pk11s.c'
   spec_extras[:extensions] = 'ext/extconf.rb'
   spec_extras[:files] = File.read_utf("Manifest.txt").split(/\r?\n\r?/)
-  spec_extras[:files] += GENERATED_FILES
+  spec_extras[:files] += SHARED_FILES + GENERATED_FILES
   spec_extras[:required_ruby_version] = '>= 2.2.0'
 end
 
@@ -56,27 +65,20 @@ Rake::ExtensionTask.new('pkcs11_protect_server_ext', hoe.spec) do |ext|
   ext.config_options << "--with-protect-server-sdk-dir=#{PROTECT_SERVER_SDK_DIR.inspect}"
 end
 
-def copy_from_base_task(filename)
-  file File.join('ext', filename) => File.join(RUBY_PKCS11_EXT_DIR, filename) do |t|
+# Add shared file from base pkcs11 gem
+SHARED_FILES.each do |filename|
+  file filename => File.join(RUBY_PKCS11_DIR, filename) do |t|
     cp t.prerequisites.first, t.name, verbose: true
   end
+  file 'ext/extconf.rb' => filename
 end
 
-copy_from_base_task 'pk11_struct_macros.h'
-copy_from_base_task 'pk11_const_macros.h'
-copy_from_base_task 'pk11_version.h'
-
-file 'ext/extconf.rb' => ['ext/pk11s_struct_def.inc', 'ext/pk11s_const_def.inc', 'ext/pk11_struct_macros.h', 'ext/pk11_const_macros.h', 'ext/pk11_version.h']
-file 'ext/pk11s_struct_def.inc' => 'ext/generate_structs.rb' do
-  sh "#{RbConfig::CONFIG['ruby_install_name']} -I../lib ext/generate_structs.rb --def ext/pk11s_struct_def.inc --impl ext/pk11s_struct_impl.inc --doc ext/pk11s_struct.doc #{File.join(PROTECT_SERVER_SDK_DIR, 'include/ctvdef.h').inspect}"
-end
-file 'ext/pk11s_struct_impl.inc' => 'ext/pk11s_struct_def.inc'
-file 'ext/pk11s_struct.doc' => 'ext/pk11s_struct_def.inc'
+file "ext/std_structs.rb" do |t|
+  require "pkcs11"
+  std_structs = PKCS11.constants.select{|c| PKCS11.const_get(c).respond_to?(:ancestors) && !(PKCS11.const_get(c).ancestors & [PKCS11::CStruct, PKCS11::CK_ATTRIBUTE]).empty? }
 
-file 'ext/pk11s_const_def.inc' => 'ext/generate_constants.rb' do
-  sh "#{RbConfig::CONFIG['ruby_install_name']} -I../lib ext/generate_constants.rb --const ext/pk11s_const_def.inc #{File.join(PROTECT_SERVER_SDK_DIR, 'include/ctvdef.h').inspect}"
+  File.write t.name, "PKCS11_STD_STRUCTS = #{std_structs.inspect}"
 end
-file 'ext/pk11s.c' => ['ext/pk11s_struct_def.inc', 'ext/pk11s_struct_impl.inc', 'ext/pk11s_const_def.inc']
 
 task doc_files:  'ext/pk11s_struct.doc'
 

data/ext/extconf.rb

@@ -4,11 +4,16 @@ require "rubygems"
 inc, lib = dir_config('protect-server-sdk', '/opt/ETcpsdk/include', '/opt/ETcpsdk/lib')
 puts "using ProtectServer-SDK include:#{inc} lib:#{lib}"
 
-# inc, lib = dir_config('ruby-pkcs11')
-# inc ||= Gem.required_location('pkcs11', '../ext')
-# puts "using ruby-pkcs11 include:#{inc} lib:#{lib}"
-# raise "path to ruby-pkcs11/ext could not be found (use --with-ruby-pkcs11-include=my_path)" unless inc
-# $INCFLAGS << " -I"+inc
+require_relative "generate_protect_server_constants"
+require_relative "generate_protect_server_structs"
+
+args = ["--const", "pk11s_const_def.inc", File.join(inc, 'ctvdef.h')]
+puts "running const parser with: #{args.join(" ")}"
+PKCS11::ProtectServer::ConstantParser.run(args)
+
+args = ["--def", "pk11s_struct_def.inc", "--impl", "pk11s_struct_impl.inc", "--doc", "pk11s_struct.doc", File.join(inc, 'ctvdef.h')]
+puts "running struct parser with: #{args.join(" ")}"
+PKCS11::ProtectServer::StructParser.run(args)
 
 find_header('pk11_struct_macros.h')
 find_header('pk11_const_macros.h')

data/ext/generate_constants.rb

@@ -2,20 +2,39 @@
 # Quick and dirty parser for PKCS#11 constants and
 # generator for Ruby wrapper classes.
 
-require File.expand_path(File.join(File.dirname(__FILE__), '../../ext/generate_constants'))
+require 'optparse'
 
 module PKCS11
-module ProtectServer
-class ConstantParser < PKCS11::ConstantParser
+class ConstantParser
+
+  attr_accessor :options
+
+  def self.run(argv)
+    s = self.new
+    options = Struct.new(:verbose, :const, :files).new
+    OptionParser.new do |opts|
+      opts.banner = "Usage: #{$0} [options] <header-file.h>*"
+
+      opts.on("-v", "--[no-]verbose", "Run verbosely", &options.method(:verbose=))
+      opts.on("--const FILE", "Write const implementations to this file", &options.method(:const=))
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+    end.parse!(argv)
+    options.files = argv
+    s.options = options
+    s.start!
+  end
+  
+  ConstTemplate = Struct.new :regexp, :def
   ConstGroups = [
-    ConstTemplate.new(/#define\s+(CKM_[A-Z_0-9]+)\s+(.+)/, 'PKCS11_DEFINE_MECHANISM'),
-    ConstTemplate.new(/#define\s+(CKA_[A-Z_0-9]+)\s+(.+)/, 'PKCS11_DEFINE_ATTRIBUTE'),
-    ConstTemplate.new(/#define\s+(CKO_[A-Z_0-9]+)\s+(.+)/, 'PKCS11_DEFINE_OBJECT_CLASS'),
-    ConstTemplate.new(/#define\s+(CKR_[A-Z_0-9]+)\s+(.+)/, 'PKCS11_DEFINE_RETURN_VALUE'),
+    ConstTemplate.new(/#define\s+(CKM_[A-Z_0-9]+)\s+(\w+)/, 'PKCS11_DEFINE_MECHANISM'),
+    ConstTemplate.new(/#define\s+(CKA_[A-Z_0-9]+)\s+(\w+)/, 'PKCS11_DEFINE_ATTRIBUTE'),
+    ConstTemplate.new(/#define\s+(CKO_[A-Z_0-9]+)\s+(\w+)/, 'PKCS11_DEFINE_OBJECT_CLASS'),
+    ConstTemplate.new(/#define\s+(CKR_[A-Z_0-9]+)\s+(\w+)/, 'PKCS11_DEFINE_RETURN_VALUE'),
   ]
 
-  IgnoreConstants = %w[CKR_CERTIFICATE_NOT_YET_ACTIVE CKR_CERTIFICATE_EXPIRED]
-
   def start!
     File.open(options.const, "w") do |fd_const|
       options.files.each do |file_h|
@@ -23,8 +42,7 @@ class ConstantParser < PKCS11::ConstantParser
         ConstGroups.each do |const_group|
           c_src.scan(const_group.regexp) do
             const_name, const_value = $1, $2
-            next if IgnoreConstants.include?(const_name)
-
+            
             fd_const.puts "#{const_group.def}(#{const_name}); /* #{const_value} */"
           end
         end
@@ -33,9 +51,7 @@ class ConstantParser < PKCS11::ConstantParser
   end
 end
 end
-end
-
 
 if $0==__FILE__
-  PKCS11::ProtectServer::ConstantParser.run(ARGV)
+  PKCS11::ConstantParser.run(ARGV)
 end

data/ext/generate_protect_server_constants.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# Quick and dirty parser for PKCS#11 constants and
+# generator for Ruby wrapper classes.
+
+require_relative "generate_constants"
+
+module PKCS11
+module ProtectServer
+class ConstantParser < PKCS11::ConstantParser
+  ConstGroups = [
+    ConstTemplate.new(/#define\s+(CKM_[A-Z_0-9]+)\s+(.+)/, 'PKCS11_DEFINE_MECHANISM'),
+    ConstTemplate.new(/#define\s+(CKA_[A-Z_0-9]+)\s+(.+)/, 'PKCS11_DEFINE_ATTRIBUTE'),
+    ConstTemplate.new(/#define\s+(CKO_[A-Z_0-9]+)\s+(.+)/, 'PKCS11_DEFINE_OBJECT_CLASS'),
+    ConstTemplate.new(/#define\s+(CKR_[A-Z_0-9]+)\s+(.+)/, 'PKCS11_DEFINE_RETURN_VALUE'),
+  ]
+
+  IgnoreConstants = %w[CKR_CERTIFICATE_NOT_YET_ACTIVE CKR_CERTIFICATE_EXPIRED]
+
+  def start!
+    File.open(options.const, "w") do |fd_const|
+      options.files.each do |file_h|
+        c_src = IO.read(file_h)
+        ConstGroups.each do |const_group|
+          c_src.scan(const_group.regexp) do
+            const_name, const_value = $1, $2
+            next if IgnoreConstants.include?(const_name)
+
+            fd_const.puts "#{const_group.def}(#{const_name}); /* #{const_value} */"
+          end
+        end
+      end
+    end
+  end
+end
+end
+end
+
+
+if $0==__FILE__
+  PKCS11::ProtectServer::ConstantParser.run(ARGV)
+end

data/ext/generate_protect_server_structs.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# Quick and dirty parser for PKCS#11 structs and
+# generator for Ruby wrapper classes.
+
+require_relative "generate_structs"
+require_relative "std_structs"
+
+module PKCS11
+module ProtectServer
+class StructParser < PKCS11::StructParser
+
+  SIZE_CONSTANTS = {
+    'CK_MANUFACTURER_SIZE' => 32,
+    'CK_SERIAL_NUMBER_SIZE' => 16,
+    'CK_TIME_SIZE' => 16,
+    'CK_LIB_DESC_SIZE' => 32,
+    'CK_SLOT_DESCRIPTION_SIZE' => 64,
+    'CK_SLOT_MANUFACTURER_SIZE' => 32,
+    'CK_MAX_PIN_LEN' => 32,
+    'CK_TOKEN_LABEL_SIZE' => 32,
+    'CK_TOKEN_MANUFACTURER_SIZE' => 32,
+    'CK_TOKEN_MODEL_SIZE' => 16,
+    'CK_TOKEN_SERIAL_NUMBER_SIZE' => 16,
+    'CK_TOKEN_TIME_SIZE' => 16,
+    'CK_MAX_PBE_IV_SIZE' =>	8,
+    'CK_MAX_PAD_SIZE' => 16,
+  }
+
+  ULONG_TYPES = %w[CK_COUNT CK_SIZE CK_TIMESTAMP_FORMAT]
+  ULONG_PTR_TYPES = %w[CK_COUNT_PTR]
+
+  def struct_module
+    'PKCS11::ProtectServer'
+  end
+
+  def array_attribute_names; %w[attributes mechanism certAttr hCert]; end
+
+  def parse_files(files)
+    structs = []
+    files.each do |file_h|
+      c_src = IO.read(file_h)
+      c_src.scan(/struct\s+([A-Z_0-9]+)\s*\{(.*?)\}/m) do |struct|
+        struct_text = $2
+        struct = PKCS11::StructParser::CStruct.new( $1, [] )
+
+        struct_text.scan(/^\s+([A-Z_0-9]+)([\*\s]+)([\w_]+)\s*(\[\s*(\w+)\s*\])?/) do |elem|
+          type, name = $1, $3
+          qual = SIZE_CONSTANTS[$5] || $5
+          ptr = $2.include?('*')
+          type = "CK_ULONG" if ULONG_TYPES.include?(type)
+          type = "CK_ULONG_PTR" if ULONG_PTR_TYPES.include?(type)
+          struct.attrs << Attribute.new(ptr ? type+"_PTR" : type, name, qual)
+        end
+        structs << struct
+      end
+    end
+    return structs
+  end
+
+  def start!
+    @structs = parse_files(options.files)
+    @structs_by_name = @structs.inject({}){|sum, v| sum[v.name]=v; sum }
+    @std_structs_by_name = PKCS11_STD_STRUCTS.inject({}){|sum, v| sum[v.to_s]=true; sum }
+
+    write_files
+  end
+end
+end
+end
+
+
+if $0==__FILE__
+  PKCS11::ProtectServer::StructParser.run(ARGV)
+end

data/ext/generate_structs.rb

@@ -2,39 +2,56 @@
 # Quick and dirty parser for PKCS#11 structs and
 # generator for Ruby wrapper classes.
 
-require 'rubygems'
-require 'pkcs11'
-require File.expand_path(File.join(File.dirname(__FILE__), '../../ext/generate_structs'))
+require 'optparse'
 
 module PKCS11
-module ProtectServer
-class StructParser < PKCS11::StructParser
-
-  SIZE_CONSTANTS = {
-    'CK_MANUFACTURER_SIZE' => 32,
-    'CK_SERIAL_NUMBER_SIZE' => 16,
-    'CK_TIME_SIZE' => 16,
-    'CK_LIB_DESC_SIZE' => 32,
-    'CK_SLOT_DESCRIPTION_SIZE' => 64,
-    'CK_SLOT_MANUFACTURER_SIZE' => 32,
-    'CK_MAX_PIN_LEN' => 32,
-    'CK_TOKEN_LABEL_SIZE' => 32,
-    'CK_TOKEN_MANUFACTURER_SIZE' => 32,
-    'CK_TOKEN_MODEL_SIZE' => 16,
-    'CK_TOKEN_SERIAL_NUMBER_SIZE' => 16,
-    'CK_TOKEN_TIME_SIZE' => 16,
-    'CK_MAX_PBE_IV_SIZE' =>	8,
-    'CK_MAX_PAD_SIZE' => 16,
-  }
-
-  ULONG_TYPES = %w[CK_COUNT CK_SIZE CK_TIMESTAMP_FORMAT]
-  ULONG_PTR_TYPES = %w[CK_COUNT_PTR]
+class StructParser
+
+  attr_accessor :options
+  attr_accessor :structs
+  attr_accessor :structs_by_name
+  attr_accessor :std_structs_by_name
+
+  def self.run(argv)
+    s = self.new
+    options = Struct.new(:verbose, :def, :impl, :doc, :files).new
+    OptionParser.new do |opts|
+      opts.banner = "Usage: #{$0} [options] <header-file.h>*"
+
+      opts.on("-v", "--[no-]verbose", "Run verbosely", &options.method(:verbose=))
+      opts.on("--def FILE", "Write struct definitions to this file", &options.method(:def=))
+      opts.on("--impl FILE", "Write struct implementations to this file", &options.method(:impl=))
+      opts.on("--doc FILE", "Write documentation to this file", &options.method(:doc=))
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+    end.parse!(argv)
+    options.files = argv
+    s.options = options
+    s.start!
+  end
+
+  CStruct = Struct.new(:name, :attrs)
+  Attribute = Struct.new(:type, :name, :qual, :mark)
+  IgnoreStructs = %w[CK_ATTRIBUTE CK_MECHANISM]
+  OnlyAllocatorStructs = %w[CK_MECHANISM_INFO CK_C_INITIALIZE_ARGS CK_INFO CK_SLOT_INFO CK_TOKEN_INFO CK_SESSION_INFO]
 
   def struct_module
-    'PKCS11::ProtectServer'
+    'PKCS11'
   end
 
-  def array_attribute_names; %w[attributes mechanism certAttr hCert]; end
+  class CStruct
+    def attr_by_sign(key)
+      attrs.find{|a| a.type+" "+a.name==key }
+    end
+  end
+
+  class Attribute
+    def type_noptr
+      type.gsub(/_PTR$/,'')
+    end
+  end
 
   def parse_files(files)
     structs = []
@@ -42,15 +59,10 @@ class StructParser < PKCS11::StructParser
       c_src = IO.read(file_h)
       c_src.scan(/struct\s+([A-Z_0-9]+)\s*\{(.*?)\}/m) do |struct|
         struct_text = $2
-        struct = PKCS11::StructParser::CStruct.new( $1, [] )
-
-        struct_text.scan(/^\s+([A-Z_0-9]+)([\*\s]+)([\w_]+)\s*(\[\s*(\w+)\s*\])?/) do |elem|
-          type, name = $1, $3
-          qual = SIZE_CONSTANTS[$5] || $5
-          ptr = $2.include?('*')
-          type = "CK_ULONG" if ULONG_TYPES.include?(type)
-          type = "CK_ULONG_PTR" if ULONG_PTR_TYPES.include?(type)
-          struct.attrs << Attribute.new(ptr ? type+"_PTR" : type, name, qual)
+        struct = CStruct.new( $1, [] )
+
+        struct_text.scan(/^\s+([A-Z_0-9]+)\s+([\w_]+)\s*(\[\s*(\d+)\s*\])?/) do |elem|
+          struct.attrs << Attribute.new($1, $2, $4)
         end
         structs << struct
       end
@@ -61,15 +73,145 @@ class StructParser < PKCS11::StructParser
   def start!
     @structs = parse_files(options.files)
     @structs_by_name = @structs.inject({}){|sum, v| sum[v.name]=v; sum }
-    @std_structs_by_name = PKCS11.constants.select{|c| PKCS11.const_get(c).respond_to?(:ancestors) && !(PKCS11.const_get(c).ancestors & [PKCS11::CStruct, PKCS11::CK_ATTRIBUTE]).empty? }.inject({}){|sum, v| sum[v.to_s]=true; sum }
+    @std_structs_by_name = @structs_by_name.dup
 
     write_files
   end
+
+  def array_attribute_names; ['pParams']; end
+
+  def write_files
+    File.open(options.def, "w") do |fd_def|
+    File.open(options.impl, "w") do |fd_impl|
+    File.open(options.doc, "w") do |fd_doc|
+    structs.each do |struct|
+      next if IgnoreStructs.include?(struct.name)
+
+      if OnlyAllocatorStructs.include?(struct.name)
+        fd_impl.puts "PKCS11_IMPLEMENT_ALLOCATOR(#{struct.name});"
+      else
+        fd_impl.puts "PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(#{struct.name});"
+      end
+      fd_def.puts "PKCS11_DEFINE_STRUCT(#{struct.name});"
+      fd_doc.puts"class #{struct_module}::#{struct.name} < #{struct_module}::CStruct"
+      fd_doc.puts"# Size of corresponding C struct in bytes\nSIZEOF_STRUCT=Integer"
+      fd_doc.puts"# @return [String] Binary copy of the C struct\ndef to_s; end"
+      fd_doc.puts"# @return [Array<String>] Attributes of this struct\ndef members; end"
+
+      # find attributes belonging together for array of struct
+      struct.attrs.select{|attr| structs_by_name[attr.type_noptr] || std_structs_by_name[attr.type_noptr] }.each do |attr|
+        if array_attribute_names.include?(attr.name) && (len_attr = struct.attr_by_sign("CK_ULONG ulCount") || struct.attr_by_sign("CK_ULONG count") || struct.attr_by_sign("CK_ULONG #{attr.name}Count"))
+          std_struct = "PKCS11_" if std_structs_by_name[attr.type_noptr]
+          fd_impl.puts "PKCS11_IMPLEMENT_#{std_struct}STRUCT_PTR_ARRAY_ACCESSOR(#{struct.name}, #{attr.type_noptr}, #{attr.name}, #{len_attr.name});"
+          fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+          fd_doc.puts"# @return [Array<PKCS11::#{attr.type_noptr}>] accessor for #{attr.name} and #{len_attr.name}\nattr_accessor :#{attr.name}"
+          len_attr.mark = true
+          attr.mark = true
+        end
+      end
+      # find string attributes belonging together
+      struct.attrs.select{|attr| ['CK_BYTE_PTR', 'CK_VOID_PTR', 'CK_UTF8CHAR_PTR', 'CK_CHAR_PTR'].include?(attr.type) }.each do |attr|
+        enco = case attr.type
+          when 'CK_UTF8CHAR_PTR' then 'utf8'
+          when 'CK_CHAR_PTR' then 'usascii'
+          when 'CK_BYTE_PTR', 'CK_VOID_PTR' then 'ascii8bit'
+          else raise "unexpected type #{attr.type.inspect}"
+        end
+        if len_attr=struct.attr_by_sign("CK_ULONG #{attr.name.gsub(/^p([A-Z])/){ "ul"+$1 }}Len")
+          fd_impl.puts "PKCS11_IMPLEMENT_STRING_PTR_LEN_ACCESSOR(#{struct.name}, #{attr.name}, #{len_attr.name}, #{enco});"
+          fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+          fd_doc.puts"# @return [#{enco.upcase}-String, nil] accessor for #{attr.name} and #{len_attr.name}\nattr_accessor :#{attr.name}"
+          len_attr.mark = true
+        elsif attr.name=='pData' && (len_attr = struct.attr_by_sign("CK_ULONG length") || struct.attr_by_sign("CK_ULONG ulLen"))
+          fd_impl.puts "PKCS11_IMPLEMENT_STRING_PTR_LEN_ACCESSOR(#{struct.name}, #{attr.name}, #{len_attr.name}, #{enco});"
+          fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+          fd_doc.puts"# @return [#{enco.upcase}-String, nil] accessor for #{attr.name} and #{len_attr.name}\nattr_accessor :#{attr.name}"
+          len_attr.mark = true
+        else
+          fd_impl.puts "PKCS11_IMPLEMENT_STRING_PTR_ACCESSOR(#{struct.name}, #{attr.name}, #{enco});"
+          fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+          fd_doc.puts"# @return [#{enco.upcase}-String, nil] accessor for #{attr.name}\nattr_accessor :#{attr.name}"
+        end
+        attr.mark = true
+      end
+
+      # standalone attributes
+      struct.attrs.reject{|a| a.mark }.each do |attr|
+        if attr.qual
+          # Attributes with qualifier
+          enco = case attr.type
+            when 'CK_BYTE' then 'ascii8bit'
+            when 'CK_UTF8CHAR' then 'utf8'
+            when 'CK_CHAR' then 'usascii'
+          end
+          case attr.type
+          when 'CK_BYTE', 'CK_UTF8CHAR', 'CK_CHAR'
+            fd_impl.puts "PKCS11_IMPLEMENT_STRING_ACCESSOR(#{struct.name}, #{attr.name}, #{enco});"
+            fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+            fd_doc.puts"# @return [#{enco.upcase}-String] accessor for #{attr.name} (max #{attr.qual} bytes)\nattr_accessor :#{attr.name}"
+          else
+            fd_impl.puts "/* unimplemented attr #{attr.type} #{attr.name} #{attr.qual} */"
+            fd_def.puts "/* unimplemented attr #{attr.type} #{attr.name} #{attr.qual} */"
+          end
+        else
+          case attr.type
+          when 'CK_BYTE'
+            fd_impl.puts "PKCS11_IMPLEMENT_BYTE_ACCESSOR(#{struct.name}, #{attr.name});"
+            fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+            fd_doc.puts"# @return [Integer] accessor for #{attr.name} (CK_BYTE)\nattr_accessor :#{attr.name}"
+          when 'CK_ULONG', 'CK_FLAGS', 'CK_SLOT_ID', 'CK_STATE', /CK_[A-Z_0-9]+_TYPE/
+            fd_impl.puts "PKCS11_IMPLEMENT_ULONG_ACCESSOR(#{struct.name}, #{attr.name});"
+            fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+            fd_doc.puts"# @return [Integer] accessor for #{attr.name} (CK_ULONG)\nattr_accessor :#{attr.name}"
+          when 'CK_OBJECT_HANDLE'
+            fd_impl.puts "PKCS11_IMPLEMENT_HANDLE_ACCESSOR(#{struct.name}, #{attr.name});"
+            fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+            fd_doc.puts"# @return [Integer, PKCS11::Object] Object handle (CK_ULONG)\nattr_accessor :#{attr.name}"
+          when 'CK_BBOOL'
+            fd_impl.puts "PKCS11_IMPLEMENT_BOOL_ACCESSOR(#{struct.name}, #{attr.name});"
+            fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+            fd_doc.puts"# @return [Boolean]  Bool value\nattr_accessor :#{attr.name}"
+          when 'CK_ULONG_PTR'
+            fd_impl.puts "PKCS11_IMPLEMENT_ULONG_PTR_ACCESSOR(#{struct.name}, #{attr.name});"
+            fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+            fd_doc.puts"# @return [Integer, nil] accessor for #{attr.name} (CK_ULONG_PTR)\nattr_accessor :#{attr.name}"
+          else
+            # Struct attributes
+            if structs_by_name[attr.type]
+              fd_impl.puts "PKCS11_IMPLEMENT_STRUCT_ACCESSOR(#{struct.name}, #{attr.type}, #{attr.name});"
+              fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+              fd_doc.puts"# @return [#{struct_module}::#{attr.type}] inline struct\nattr_accessor :#{attr.name}"
+            elsif structs_by_name[attr.type_noptr]
+              fd_impl.puts "PKCS11_IMPLEMENT_STRUCT_PTR_ACCESSOR(#{struct.name}, #{attr.type_noptr}, #{attr.name});"
+              fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+              fd_doc.puts"# @return [#{struct_module}::#{attr.type_noptr}, nil] pointer to struct\nattr_accessor :#{attr.name}"
+            elsif std_structs_by_name[attr.type]
+              fd_impl.puts "PKCS11_IMPLEMENT_PKCS11_STRUCT_ACCESSOR(#{struct.name}, #{attr.type}, #{attr.name});"
+              fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+              fd_doc.puts"# @return [PKCS11::#{attr.type}] inline struct (see pkcs11.gem)\nattr_accessor :#{attr.name}"
+            elsif std_structs_by_name[attr.type_noptr]
+              fd_impl.puts "PKCS11_IMPLEMENT_PKCS11_STRUCT_PTR_ACCESSOR(#{struct.name}, #{attr.type_noptr}, #{attr.name});"
+              fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+              fd_doc.puts"# @return [PKCS11::#{attr.type_noptr}, nil] pointer to struct (see pkcs11.gem)\nattr_accessor :#{attr.name}"
+            else
+              fd_impl.puts "/* unimplemented attr #{attr.type} #{attr.name} #{attr.qual} */"
+              fd_def.puts "/* unimplemented attr #{attr.type} #{attr.name} #{attr.qual} */"
+            end
+          end
+        end
+      end
+
+      fd_impl.puts
+      fd_def.puts
+      fd_doc.puts "end"
+    end
+    end
+    end
+    end
+  end
 end
 end
-end
-
 
 if $0==__FILE__
-  PKCS11::ProtectServer::StructParser.run(ARGV)
+  PKCS11::StructParser.run(ARGV)
 end

data/ext/pk11_version.h

@@ -1,6 +1,6 @@
 #ifndef RUBY_PK11_VERSION_H
 #define RUBY_PK11_VERSION_H
 
-static const char *VERSION = "0.3.0";
+static const char *VERSION = "0.3.2";
 
 #endif

data/ext/std_structs.rb

@@ -0,0 +1 @@
+PKCS11_STD_STRUCTS = [:CK_MECHANISM, :CK_VERSION, :CK_INFO, :CK_SLOT_INFO, :CK_TOKEN_INFO, :CK_SESSION_INFO, :CK_DATE, :CK_MECHANISM_INFO, :CK_C_INITIALIZE_ARGS, :CK_RSA_PKCS_OAEP_PARAMS, :CK_RSA_PKCS_PSS_PARAMS, :CK_ECDH1_DERIVE_PARAMS, :CK_ECMQV_DERIVE_PARAMS, :CK_X9_42_DH1_DERIVE_PARAMS, :CK_X9_42_DH2_DERIVE_PARAMS, :CK_X9_42_MQV_DERIVE_PARAMS, :CK_KEA_DERIVE_PARAMS, :CK_RC2_CBC_PARAMS, :CK_RC2_MAC_GENERAL_PARAMS, :CK_RC5_PARAMS, :CK_RC5_CBC_PARAMS, :CK_RC5_MAC_GENERAL_PARAMS, :CK_DES_CBC_ENCRYPT_DATA_PARAMS, :CK_AES_CBC_ENCRYPT_DATA_PARAMS, :CK_SKIPJACK_PRIVATE_WRAP_PARAMS, :CStruct, :CK_ATTRIBUTE, :CK_SKIPJACK_RELAYX_PARAMS, :CK_PBE_PARAMS, :CK_KEY_WRAP_SET_OAEP_PARAMS, :CK_SSL3_RANDOM_DATA, :CK_SSL3_MASTER_KEY_DERIVE_PARAMS, :CK_SSL3_KEY_MAT_OUT, :CK_SSL3_KEY_MAT_PARAMS, :CK_WTLS_RANDOM_DATA, :CK_WTLS_MASTER_KEY_DERIVE_PARAMS, :CK_WTLS_PRF_PARAMS, :CK_WTLS_KEY_MAT_OUT, :CK_WTLS_KEY_MAT_PARAMS, :CK_CMS_SIG_PARAMS, :CK_KEY_DERIVATION_STRING_DATA, :CK_PKCS5_PBKD2_PARAMS, :CK_OTP_PARAM, :CK_OTP_PARAMS, :CK_OTP_SIGNATURE_INFO, :CK_KIP_PARAMS, :CK_AES_CTR_PARAMS, :CK_GCM_PARAMS, :CK_CCM_PARAMS, :CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS, :CK_ARIA_CBC_ENCRYPT_DATA_PARAMS, :CK_DSA_PARAMETER_GEN_PARAM, :CK_ECDH_AES_KEY_WRAP_PARAMS, :CK_RSA_AES_KEY_WRAP_PARAMS, :CK_TLS12_MASTER_KEY_DERIVE_PARAMS, :CK_TLS12_KEY_MAT_PARAMS, :CK_TLS_KDF_PARAMS, :CK_TLS_MAC_PARAMS, :CK_GOSTR3410_DERIVE_PARAMS, :CK_GOSTR3410_KEY_WRAP_PARAMS]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pkcs11_protect_server
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Lars Kanis
@@ -29,7 +29,7 @@ cert_chain:
   D5uWyL3krcnTOgVS0jv7qSuxDjlvpHqvN1BNaw64Gf5TpqRDNM5r+hXhD8U339Ot
   lrxBVhTTtOOm6AE6oziYmw==
   -----END CERTIFICATE-----
-date: 2019-12-05 00:00:00.000000000 Z
+date: 2020-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pkcs11
@@ -37,14 +37,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.3.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.3.2
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -126,15 +126,14 @@ files:
 - Rakefile
 - ext/extconf.rb
 - ext/generate_constants.rb
+- ext/generate_protect_server_constants.rb
+- ext/generate_protect_server_structs.rb
 - ext/generate_structs.rb
 - ext/pk11_const_macros.h
 - ext/pk11_struct_macros.h
 - ext/pk11_version.h
 - ext/pk11s.c
-- ext/pk11s_const_def.inc
-- ext/pk11s_struct.doc
-- ext/pk11s_struct_def.inc
-- ext/pk11s_struct_impl.inc
+- ext/std_structs.rb
 - lib/pkcs11_protect_server.rb
 - lib/pkcs11_protect_server/extensions.rb
 - test/helper.rb

metadata.gz.sig

@@ -1,3 +1 @@
-.�	V��,j��������r�x�WYs��c�$���YnD21P��Fr�Lch��&�1�ڕ�|'zP�;Ԉp3���yP���6������+��q�)r=�I�J0��~e�q�ZL�5ї*�o�%�xҏ�
-zJ������_s���H�O_D�)���&]`U=�*�j*�UX�� z���/�h�A�m��>o��P���:����mw�-*=Ӹ1��a�b�[i��D��<!��<MĶ�
-�Ezm����9�'`
+*�0T�w� 
 � �����g$��$��H��/X.�!� ij{`z

data/ext/pk11s_const_def.inc

@@ -1,182 +0,0 @@
-PKCS11_DEFINE_MECHANISM(CKM_DSA_SHA1_PKCS); /* (CKM_VENDOR_DEFINED + CKM_DSA_SHA1 + 0x1) */
-PKCS11_DEFINE_MECHANISM(CKM_RIPEMD256_RSA_PKCS); /* (CKM_VENDOR_DEFINED + CKM_RIPEMD160_RSA_PKCS + 0x1) */
-PKCS11_DEFINE_MECHANISM(CKM_DES_MDC_2_PAD1); /* (CKM_VENDOR_DEFINED + 0x200 + 0x0) */
-PKCS11_DEFINE_MECHANISM(CKM_MD4); /* (CKM_VENDOR_DEFINED + 0x200 + 0x1) */
-PKCS11_DEFINE_MECHANISM(CKM_SHA); /* (CKM_VENDOR_DEFINED + 0x200 + 0x2) */
-PKCS11_DEFINE_MECHANISM(CKM_RIPEMD); /* (CKM_VENDOR_DEFINED + 0x200 + 0x3) */
-PKCS11_DEFINE_MECHANISM(CKM_ARDFP); /* (CKM_VENDOR_DEFINED + 0x200 + 0x4) */
-PKCS11_DEFINE_MECHANISM(CKM_NVB); /* (CKM_VENDOR_DEFINED + 0x200 + 0x5) */
-PKCS11_DEFINE_MECHANISM(CKM_DES_ECB_PAD); /* (CKM_VENDOR_DEFINED + CKM_DES_ECB) */
-PKCS11_DEFINE_MECHANISM(CKM_CAST_ECB_PAD); /* (CKM_VENDOR_DEFINED + CKM_CAST_ECB) */
-PKCS11_DEFINE_MECHANISM(CKM_CAST3_ECB_PAD); /* (CKM_VENDOR_DEFINED + CKM_CAST3_ECB) */
-PKCS11_DEFINE_MECHANISM(CKM_CAST5_ECB_PAD); /* (CKM_VENDOR_DEFINED + CKM_CAST5_ECB) */
-PKCS11_DEFINE_MECHANISM(CKM_CAST128_ECB_PAD); /* CKM_CAST5_ECB_PAD */
-PKCS11_DEFINE_MECHANISM(CKM_DES3_ECB_PAD); /* (CKM_VENDOR_DEFINED + CKM_DES3_ECB) */
-PKCS11_DEFINE_MECHANISM(CKM_IDEA_ECB_PAD); /* (CKM_VENDOR_DEFINED + CKM_IDEA_ECB) */
-PKCS11_DEFINE_MECHANISM(CKM_RC2_ECB_PAD); /* (CKM_VENDOR_DEFINED + CKM_RC2_ECB) */
-PKCS11_DEFINE_MECHANISM(CKM_CDMF_ECB_PAD); /* (CKM_VENDOR_DEFINED + CKM_CDMF_ECB) */
-PKCS11_DEFINE_MECHANISM(CKM_RC5_ECB_PAD); /* (CKM_VENDOR_DEFINED + CKM_RC5_ECB) */
-PKCS11_DEFINE_MECHANISM(CKM_DES_DERIVE_ECB); /* (CKM_VENDOR_DEFINED + 0x500) */
-PKCS11_DEFINE_MECHANISM(CKM_DES_DERIVE_CBC); /* (CKM_VENDOR_DEFINED + 0x501) */
-PKCS11_DEFINE_MECHANISM(CKM_DES3_DERIVE_ECB); /* (CKM_VENDOR_DEFINED + 0x502) */
-PKCS11_DEFINE_MECHANISM(CKM_DES3_DERIVE_CBC); /* (CKM_VENDOR_DEFINED + 0x503) */
-PKCS11_DEFINE_MECHANISM(CKM_DES3_RETAIL_CFB_MAC); /* (CKM_VENDOR_DEFINED + 0x510) */
-PKCS11_DEFINE_MECHANISM(CKM_SHA1_RSA_PKCS_TIMESTAMP); /* (CKM_VENDOR_DEFINED + 0x600) */
-PKCS11_DEFINE_MECHANISM(CKM_DES_BCF); /* (CKM_VENDOR_DEFINED + 910) */
-PKCS11_DEFINE_MECHANISM(CKM_DES3_BCF); /* (CKM_VENDOR_DEFINED + 911) */
-PKCS11_DEFINE_MECHANISM(CKM_DES3_X919_MAC); /* (CKM_VENDOR_DEFINED + CKM_DES3_MAC) */
-PKCS11_DEFINE_MECHANISM(CKM_DES3_X919_MAC_GENERAL); /* (CKM_VENDOR_DEFINED + CKM_DES3_MAC_GENERAL) */
-PKCS11_DEFINE_MECHANISM(CKM_ENCODE_PKCS_7); /* (CKM_VENDOR_DEFINED + 0x934) */
-PKCS11_DEFINE_MECHANISM(CKM_DECODE_PKCS_7); /* (CKM_VENDOR_DEFINED + 0x935) */
-PKCS11_DEFINE_MECHANISM(CKM_RSA_PKCS_7); /* (CKM_VENDOR_DEFINED + 0x930) */
-PKCS11_DEFINE_MECHANISM(CKM_RSA_PKCS_7_ENC); /* (CKM_VENDOR_DEFINED + 0x931) */
-PKCS11_DEFINE_MECHANISM(CKM_RSA_PKCS_7_SIGN); /* (CKM_VENDOR_DEFINED + 0x932) */
-PKCS11_DEFINE_MECHANISM(CKM_RSA_PKCS_7_SIGN_ENC); /* (CKM_VENDOR_DEFINED + 0x933) */
-PKCS11_DEFINE_MECHANISM(CKM_DES_OFB64); /* (CKM_VENDOR_DEFINED + 0x940) */
-PKCS11_DEFINE_MECHANISM(CKM_DES3_OFB64); /* (CKM_VENDOR_DEFINED + 0x941) */
-PKCS11_DEFINE_MECHANISM(CKM_XOR_BASE_AND_KEY); /* (CKM_VENDOR_DEFINED + 0x364) */
-PKCS11_DEFINE_MECHANISM(CKM_ENCODE_ATTRIBUTES); /* (CKM_VENDOR_DEFINED + 0x950) */
-PKCS11_DEFINE_MECHANISM(CKM_ENCODE_X_509); /* (CKM_VENDOR_DEFINED + 0x951) */
-PKCS11_DEFINE_MECHANISM(CKM_ENCODE_PKCS_10); /* (CKM_VENDOR_DEFINED + 0x952) */
-PKCS11_DEFINE_MECHANISM(CKM_DECODE_X_509); /* (CKM_VENDOR_DEFINED + 0x953) */
-PKCS11_DEFINE_MECHANISM(CKM_ENCODE_PUBLIC_KEY); /* (CKM_VENDOR_DEFINED + 0x954) */
-PKCS11_DEFINE_MECHANISM(CKM_ENCODE_X_509_LOCAL_CERT); /* (CKM_VENDOR_DEFINED + 0x955) */
-PKCS11_DEFINE_MECHANISM(CKM_WRAPKEY_DES3_ECB); /* (CKM_VENDOR_DEFINED + 0x961) */
-PKCS11_DEFINE_MECHANISM(CKM_WRAPKEY_DES3_CBC); /* (CKM_VENDOR_DEFINED + 0x962) */
-PKCS11_DEFINE_MECHANISM(CKM_DES3_DDD_CBC); /* (CKM_VENDOR_DEFINED + 0x964) */
-PKCS11_DEFINE_MECHANISM(CKM_VERIFY_CERTIFICATE); /* (CKM_VENDOR_DEFINED + 0x980) */
-PKCS11_DEFINE_MECHANISM(CKM_KEY_TRANSLATION); /* (CK_VENDOR_DEFINED + 0x1B) */
-PKCS11_DEFINE_MECHANISM(CKM_OS_UPGRADE); /* (CKM_VENDOR_DEFINED + 0x990) */
-PKCS11_DEFINE_MECHANISM(CKM_FM_DOWNLOAD); /* (CKM_VENDOR_DEFINED + 0x991) */
-PKCS11_DEFINE_MECHANISM(CKM_PP_LOAD_SECRET); /* (CKM_VENDOR_DEFINED + 0x9a0) */
-PKCS11_DEFINE_MECHANISM(CKM_VISA_CVV); /* (CKM_VENDOR_DEFINED + 0x9b0) */
-PKCS11_DEFINE_MECHANISM(CKM_ZKA_MDC_2_KEY_DERIVATION); /* (CKM_VENDOR_DEFINED + 0x9c0) */
-PKCS11_DEFINE_MECHANISM(CKM_SEED_KEY_GEN); /* (CKM_VENDOR_DEFINED + 0x9d0) */
-PKCS11_DEFINE_MECHANISM(CKM_SEED_ECB); /* (CKM_VENDOR_DEFINED + 0x9d1) */
-PKCS11_DEFINE_MECHANISM(CKM_SEED_CBC); /* (CKM_VENDOR_DEFINED + 0x9d2) */
-PKCS11_DEFINE_MECHANISM(CKM_SEED_MAC); /* (CKM_VENDOR_DEFINED + 0x9d3) */
-PKCS11_DEFINE_MECHANISM(CKM_SEED_MAC_GENERAL); /* (CKM_VENDOR_DEFINED + 0x9d4) */
-PKCS11_DEFINE_MECHANISM(CKM_SEED_ECB_PAD); /* (CKM_VENDOR_DEFINED + 0x9d5) */
-PKCS11_DEFINE_MECHANISM(CKM_SEED_CBC_PAD); /* (CKM_VENDOR_DEFINED + 0x9d6) */
-PKCS11_DEFINE_MECHANISM(CKM_REPLICATE_TOKEN_RSA_AES); /* (CKM_VENDOR_DEFINED + 0x9e0) */
-PKCS11_DEFINE_MECHANISM(CKM_SECRET_SHARE_WITH_ATTRIBUTES); /* (CKM_VENDOR_DEFINED + 0x9f0) */
-PKCS11_DEFINE_MECHANISM(CKM_SECRET_RECOVER_WITH_ATTRIBUTES); /* (CKM_VENDOR_DEFINED + 0x9f1) */
-PKCS11_DEFINE_MECHANISM(CKM_PKCS12_PBE_EXPORT); /* (CKM_VENDOR_DEFINED + 0x9f2) */
-PKCS11_DEFINE_MECHANISM(CKM_PKCS12_PBE_IMPORT); /* (CKM_VENDOR_DEFINED + 0x9f3) */
-PKCS11_DEFINE_MECHANISM(CKM_ECIES); /* (CKM_VENDOR_DEFINED + 0xA00) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_USAGE_COUNT); /* (CKA_VENDOR_DEFINED + 0x0101) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_TIME_STAMP); /* (CKA_VENDOR_DEFINED + 0x0102) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_CHECK_VALUE); /* (CKA_VENDOR_DEFINED + 0x0103) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_MECHANISM_LIST); /* (CKA_VENDOR_DEFINED + 0x0104) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_SIGN_LOCAL_CERT); /* (CKA_VENDOR_DEFINED + 0x0127) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_EXPORT); /* (CKA_VENDOR_DEFINED + 0x0128) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_EXPORTABLE); /* (CKA_VENDOR_DEFINED + 0x0129) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_DELETABLE); /* (CKA_VENDOR_DEFINED + 0x012A) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_IMPORT); /* (CKA_VENDOR_DEFINED + 0x012B) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_KEY_SIZE); /* (CKA_VENDOR_DEFINED + 0x012C) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_ISSUER_STR); /* (CKA_VENDOR_DEFINED + 0x0130) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_SUBJECT_STR); /* (CKA_VENDOR_DEFINED + 0x0131) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_SERIAL_NUMBER_INT); /* (CKA_VENDOR_DEFINED + 0x0132) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_RECORD_COUNT); /* (CKA_VENDOR_DEFINED + 0x0136) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_RECORD_NUMBER); /* (CKA_VENDOR_DEFINED + 0x0137) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_PURGE); /* (CKA_VENDOR_DEFINED + 0x0139) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_EVENT_LOG_FULL); /* (CKA_VENDOR_DEFINED + 0x013A) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_SECURITY_MODE); /* (CKA_VENDOR_DEFINED + 0x0140) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_TRANSPORT_MODE); /* (CKA_VENDOR_DEFINED + 0x0141) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_BATCH); /* (CKA_VENDOR_DEFINED + 0x0142) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_HW_STATUS); /* (CKA_VENDOR_DEFINED + 0x0143) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_FREE_MEM); /* (CKA_VENDOR_DEFINED + 0x0144) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_TAMPER_CMD); /* (CKA_VENDOR_DEFINED + 0x0145) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_DATE_OF_MANUFACTURE); /* (CKA_VENDOR_DEFINED + 0x0146) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_HALT_CMD); /* (CKA_VENDOR_DEFINED + 0x0147) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_APPLICATION_COUNT); /* (CKA_VENDOR_DEFINED + 0x0148) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_FW_VERSION); /* (CKA_VENDOR_DEFINED + 0x0149) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_RESCAN_PERIPHERALS_CMD); /* (CKA_VENDOR_DEFINED + 0x014A) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_RTC_AAC_ENABLED); /* (CKA_VENDOR_DEFINED + 0x014B) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_RTC_AAC_GUARD_SECONDS); /* (CKA_VENDOR_DEFINED + 0x014C) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_RTC_AAC_GUARD_COUNT); /* (CKA_VENDOR_DEFINED + 0x014D) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_RTC_AAC_GUARD_DURATION); /* (CKA_VENDOR_DEFINED + 0x014E) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_HW_EXT_INFO_STR); /* (CKA_VENDOR_DEFINED + 0x014F) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_SLOT_ID); /* (CKA_VENDOR_DEFINED + 0x0151) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_MAX_SESSIONS); /* (CKA_VENDOR_DEFINED + 0x0155) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_MIN_PIN_LEN); /* (CKA_VENDOR_DEFINED + 0x0156) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_MAX_PIN_FAIL); /* (CKA_VENDOR_DEFINED + 0x0158) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_FLAGS); /* (CKA_VENDOR_DEFINED + 0x0159) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_PINPAD_DESC); /* (CKA_VENDOR_DEFINED + 0x015A) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_VERIFY_OS); /* (CKA_VENDOR_DEFINED + 0x0170) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_VERSION); /* (CKA_VENDOR_DEFINED + 0x0181) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_MANUFACTURER); /* (CKA_VENDOR_DEFINED + 0x0182) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_BUILD_DATE); /* (CKA_VENDOR_DEFINED + 0x0183) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_FINGERPRINT); /* (CKA_VENDOR_DEFINED + 0x0184) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_ROM_SPACE); /* (CKA_VENDOR_DEFINED + 0x0185) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_RAM_SPACE); /* (CKA_VENDOR_DEFINED + 0x0186) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_FM_STATUS); /* (CKA_VENDOR_DEFINED + 0x0187) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_DELETE_FM); /* (CKA_VENDOR_DEFINED + 0x0188) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_FM_STARTUP_STATUS); /* (CKA_VENDOR_DEFINED + 0x0189) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_CERTIFICATE_START_TIME); /* (CKA_VENDOR_DEFINED + 0x0190) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_CERTIFICATE_END_TIME); /* (CKA_VENDOR_DEFINED + 0x0191) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_PKI_ATTRIBUTE_BER_ENCODED); /* (CKA_VENDOR_DEFINED + 0x0230) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_HIFACE_MASTER); /* (CKA_VENDOR_DEFINED + 0x250) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_SEED); /* (CKA_VENDOR_DEFINED + 0x260) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_COUNTER); /* (CKA_VENDOR_DEFINED + 0x261) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_H_VALUE); /* (CKA_VENDOR_DEFINED + 0x262) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_INTERNAL_1); /* (CKA_VENDOR_DEFINED + 0x270) */
-PKCS11_DEFINE_ATTRIBUTE(CKA_ENUM_ATTRIBUTE); /* ((CK_ATTRIBUTE_TYPE)0xFFFF) */
-PKCS11_DEFINE_OBJECT_CLASS(CKO_CERTIFICATE_REQUEST); /* (CKO_VENDOR_DEFINED + 0x0201) */
-PKCS11_DEFINE_OBJECT_CLASS(CKO_CRL); /* (CKO_VENDOR_DEFINED + 0x0202) */
-PKCS11_DEFINE_OBJECT_CLASS(CKO_ADAPTER); /* (CKO_VENDOR_DEFINED + 0x020A) */
-PKCS11_DEFINE_OBJECT_CLASS(CKO_SLOT); /* (CKO_VENDOR_DEFINED + 0x020B) */
-PKCS11_DEFINE_OBJECT_CLASS(CKO_FM); /* (CKO_VENDOR_DEFINED + 0x020C) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_ERACOM_ERROR); /* (CKR_VENDOR_DEFINED+0x100) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_TIME_STAMP); /* (CKR_ERACOM_ERROR+0x01) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_ACCESS_DENIED); /* (CKR_ERACOM_ERROR+0x02) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_CRYPTOKI_UNUSABLE); /* (CKR_ERACOM_ERROR+0x03) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_ENCODE_ERROR); /* (CKR_ERACOM_ERROR+0x04) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_V_CONFIG); /* (CKR_ERACOM_ERROR+0x05) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_SO_NOT_LOGGED_IN); /* (CKR_ERACOM_ERROR+0x06) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_CERT_NOT_VALIDATED); /* (CKR_ERACOM_ERROR+0x07) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_PIN_ALREADY_INITIALIZED); /* (CKR_ERACOM_ERROR+0x08) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_REMOTE_SERVER_ERROR); /* (CKR_ERACOM_ERROR+0x0a) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_CSA_HW_ERROR); /* (CKR_ERACOM_ERROR+0x0b) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_NO_CHALLENGE); /* (CKR_ERACOM_ERROR+0x10) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_RESPONSE_INVALID); /* (CKR_ERACOM_ERROR+0x11) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_EVENT_LOG_NOT_FULL); /* (CKR_ERACOM_ERROR+0x13) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_OBJECT_READ_ONLY); /* (CKR_ERACOM_ERROR+0x14) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_TOKEN_READ_ONLY); /* (CKR_ERACOM_ERROR+0x15) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_TOKEN_NOT_INITIALIZED); /* (CKR_ERACOM_ERROR+0x16) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_NOT_ADMIN_TOKEN); /* (CKR_ERACOM_ERROR+0x17) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_AUTHENTICATION_REQUIRED); /* (CKR_ERACOM_ERROR + 0x30) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_OPERATION_NOT_PERMITTED); /* (CKR_ERACOM_ERROR + 0x31) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_PKCS12_DECODE); /* (CKR_ERACOM_ERROR + 0x32) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_PKCS12_UNSUPPORTED_SAFEBAG_TYPE); /* (CKR_ERACOM_ERROR + 0x33) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_PKCS12_UNSUPPORTED_PRIVACY_MODE); /* (CKR_ERACOM_ERROR + 0x34) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_PKCS12_UNSUPPORTED_INTEGRITY_MODE); /* (CKR_ERACOM_ERROR + 0x35) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_ET_NOT_ODD_PARITY); /* (CKR_ERACOM_ERROR + 0x40) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_HOST_ERROR); /* (CKR_VENDOR_DEFINED+0x1000) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_BAD_REQUEST); /* (CKR_HOST_ERROR + 1) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_BAD_ATTRIBUTE_PACKING); /* (CKR_HOST_ERROR + 2) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_BAD_ATTRIBUTE_COUNT); /* (CKR_HOST_ERROR + 3) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_BAD_PARAM_PACKING); /* (CKR_HOST_ERROR + 4) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_EXTERN_DCP_ERROR); /* (CKR_HOST_ERROR + 0x386) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_HIMK_NOT_FOUND); /* (CKR_HOST_ERROR + 0x400) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_MSG_ERROR); /* (CKR_VENDOR_DEFINED+0x300) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_CANNOT_DERIVE_KEYS); /* (CKR_MSG_ERROR + 0x81) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_BAD_REQ_SIGNATURE); /* (CKR_MSG_ERROR + 0x82) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_BAD_REPLY_SIGNATURE); /* (CKR_MSG_ERROR + 0x83) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_SMS_ERROR); /* (CKR_MSG_ERROR + 0x84) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_BAD_PROTECTION); /* (CKR_MSG_ERROR + 0x85) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_DEVICE_RESET); /* (CKR_MSG_ERROR + 0x86) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_NO_SESSION_KEYS); /* (CKR_MSG_ERROR + 0x87) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_BAD_REPLY); /* (CKR_MSG_ERROR + 0x88) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_KEY_ROLLOVER); /* (CKR_MSG_ERROR + 0x89) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_NEED_IV_UPDATE); /* (CKR_MSG_ERROR+0x10) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_DUPLICATE_IV_FOUND); /* (CKR_MSG_ERROR+0x11) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_WLD_ERROR); /* (CKR_VENDOR_DEFINED + 0x2000) */
-PKCS11_DEFINE_RETURN_VALUE(CKR_WLD_CONFIG_NOT_FOUND); /* (CKR_WLD_ERROR) + 0x01 */
-PKCS11_DEFINE_RETURN_VALUE(CKR_WLD_CONFIG_ITEM_READ_FAILED); /* (CKR_WLD_ERROR) + 0x02 */
-PKCS11_DEFINE_RETURN_VALUE(CKR_WLD_CONFIG_NO_TOKEN_LABEL); /* (CKR_WLD_ERROR) + 0x03 */
-PKCS11_DEFINE_RETURN_VALUE(CKR_WLD_CONFIG_TOKEN_LABEL_LEN); /* (CKR_WLD_ERROR) + 0x04 */
-PKCS11_DEFINE_RETURN_VALUE(CKR_WLD_CONFIG_TOKEN_SERIAL_NUM_LEN); /* (CKR_WLD_ERROR) + 0x05 */
-PKCS11_DEFINE_RETURN_VALUE(CKR_WLD_CONFIG_SLOT_DESCRIPTION_LEN); /* (CKR_WLD_ERROR) + 0x06 */
-PKCS11_DEFINE_RETURN_VALUE(CKR_WLD_CONFIG_ITEM_FORMAT_INVALID); /* (CKR_WLD_ERROR) + 0x07 */
-PKCS11_DEFINE_RETURN_VALUE(CKR_WLD_LOGIN_CACHE_INCONSISTENT); /* (CKR_WLD_ERROR) + 0x10 */

data/ext/pk11s_struct.doc

@@ -1,206 +0,0 @@
-class PKCS11::ProtectServer::CK_DES_CBC_PARAMS < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [ASCII8BIT-String] accessor for iv (max 8 bytes)
-attr_accessor :iv
-# @return [ASCII8BIT-String] accessor for data (max 8 bytes)
-attr_accessor :data
-end
-class PKCS11::ProtectServer::CK_DES2_CBC_PARAMS < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [ASCII8BIT-String] accessor for iv (max 8 bytes)
-attr_accessor :iv
-# @return [ASCII8BIT-String] accessor for data (max 16 bytes)
-attr_accessor :data
-end
-class PKCS11::ProtectServer::CK_DES3_CBC_PARAMS < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [ASCII8BIT-String] accessor for iv (max 8 bytes)
-attr_accessor :iv
-# @return [ASCII8BIT-String] accessor for data (max 24 bytes)
-attr_accessor :data
-end
-class PKCS11::ProtectServer::CK_TIMESTAMP_PARAMS < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [Boolean]  Bool value
-attr_accessor :useMilliseconds
-# @return [Integer] accessor for timestampFormat (CK_ULONG)
-attr_accessor :timestampFormat
-end
-class PKCS11::ProtectServer::CK_ATTRIBUTES < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [Array<PKCS11::CK_ATTRIBUTE>] accessor for attributes and count
-attr_accessor :attributes
-end
-class PKCS11::ProtectServer::CK_MECH_AND_OBJECT < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [PKCS11::CK_MECHANISM] inline struct (see pkcs11.gem)
-attr_accessor :mechanism
-# @return [Integer, PKCS11::Object] Object handle (CK_ULONG)
-attr_accessor :obj
-end
-class PKCS11::ProtectServer::CK_MECH_TYPE_AND_OBJECT < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [Integer] accessor for mechanism (CK_ULONG)
-attr_accessor :mechanism
-# @return [Integer, PKCS11::Object] Object handle (CK_ULONG)
-attr_accessor :obj
-end
-class PKCS11::ProtectServer::CK_MECH_AND_OBJECTS < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [Array<PKCS11::CK_MECH_AND_OBJECT>] accessor for mechanism and count
-attr_accessor :mechanism
-end
-class PKCS11::ProtectServer::CK_PKCS_7_PARAMS < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [Integer] accessor for flags (CK_ULONG)
-attr_accessor :flags
-# @return [Integer] accessor for length (CK_ULONG)
-attr_accessor :length
-# @return [PKCS11::ProtectServer::CK_MECH_AND_OBJECTS] inline struct
-attr_accessor :signature
-# @return [PKCS11::ProtectServer::CK_MECH_AND_OBJECTS] inline struct
-attr_accessor :encryption
-# @return [PKCS11::ProtectServer::CK_ATTRIBUTES] inline struct
-attr_accessor :extensions
-end
-class PKCS11::ProtectServer::CK_PP_LOAD_SECRET_PARAMS < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [USASCII-String, nil] accessor for prompt
-attr_accessor :prompt
-# @return [Boolean]  Bool value
-attr_accessor :bMaskInput
-# @return [Integer] accessor for cConvert (CK_ULONG)
-attr_accessor :cConvert
-end
-class PKCS11::ProtectServer::CK_REPLICATE_TOKEN_PARAMS < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [USASCII-String] accessor for peerId (max 16 bytes)
-attr_accessor :peerId
-end
-class PKCS11::ProtectServer::CK_SECRET_SHARE_PARAMS < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [Integer] accessor for n (CK_ULONG)
-attr_accessor :n
-# @return [Integer] accessor for m (CK_ULONG)
-attr_accessor :m
-end
-class PKCS11::ProtectServer::CK_PKCS12_PBE_EXPORT_PARAMS < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [USASCII-String, nil] accessor for passwordAuthSafe and passwordAuthSafeLen
-attr_accessor :passwordAuthSafe
-# @return [USASCII-String, nil] accessor for passwordHMAC and passwordHMACLen
-attr_accessor :passwordHMAC
-# @return [Integer, PKCS11::Object] Object handle (CK_ULONG)
-attr_accessor :keyCert
-# @return [Integer] accessor for safeBagKgMech (CK_ULONG)
-attr_accessor :safeBagKgMech
-# @return [Integer] accessor for safeContentKgMech (CK_ULONG)
-attr_accessor :safeContentKgMech
-# @return [Integer] accessor for hmacKgMech (CK_ULONG)
-attr_accessor :hmacKgMech
-end
-class PKCS11::ProtectServer::CK_PKCS12_PBE_IMPORT_PARAMS < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [Array<PKCS11::CK_ATTRIBUTE>] accessor for certAttr and certAttrCount
-attr_accessor :certAttr
-# @return [USASCII-String, nil] accessor for passwordAuthSafe and passwordAuthSafeLen
-attr_accessor :passwordAuthSafe
-# @return [USASCII-String, nil] accessor for passwordHMAC and passwordHMACLen
-attr_accessor :passwordHMAC
-# @return [Integer, nil] accessor for hCertCount (CK_ULONG_PTR)
-attr_accessor :hCertCount
-end
-class PKCS11::ProtectServer::CK_ECIES_PARAMS < PKCS11::ProtectServer::CStruct
-# Size of corresponding C struct in bytes
-SIZEOF_STRUCT=Integer
-# @return [String] Binary copy of the C struct
-def to_s; end
-# @return [Array<String>] Attributes of this struct
-def members; end
-# @return [ASCII8BIT-String, nil] accessor for pSharedData1
-attr_accessor :pSharedData1
-# @return [ASCII8BIT-String, nil] accessor for pSharedData2
-attr_accessor :pSharedData2
-# @return [Integer] accessor for kdf (CK_ULONG)
-attr_accessor :kdf
-# @return [Integer] accessor for ulSharedDataLen1 (CK_ULONG)
-attr_accessor :ulSharedDataLen1
-# @return [Integer] accessor for ulEncKeyLenInBits (CK_ULONG)
-attr_accessor :ulEncKeyLenInBits
-# @return [Integer] accessor for ulMacKeyLenInBits (CK_ULONG)
-attr_accessor :ulMacKeyLenInBits
-# @return [Integer] accessor for ulMacLenInBits (CK_ULONG)
-attr_accessor :ulMacLenInBits
-# @return [Integer] accessor for ulSharedDataLen2 (CK_ULONG)
-attr_accessor :ulSharedDataLen2
-end

data/ext/pk11s_struct_def.inc

@@ -1,79 +0,0 @@
-PKCS11_DEFINE_STRUCT(CK_DES_CBC_PARAMS);
-PKCS11_DEFINE_MEMBER(CK_DES_CBC_PARAMS, iv);
-PKCS11_DEFINE_MEMBER(CK_DES_CBC_PARAMS, data);
-
-PKCS11_DEFINE_STRUCT(CK_DES2_CBC_PARAMS);
-PKCS11_DEFINE_MEMBER(CK_DES2_CBC_PARAMS, iv);
-PKCS11_DEFINE_MEMBER(CK_DES2_CBC_PARAMS, data);
-
-PKCS11_DEFINE_STRUCT(CK_DES3_CBC_PARAMS);
-PKCS11_DEFINE_MEMBER(CK_DES3_CBC_PARAMS, iv);
-PKCS11_DEFINE_MEMBER(CK_DES3_CBC_PARAMS, data);
-
-PKCS11_DEFINE_STRUCT(CK_TIMESTAMP_PARAMS);
-PKCS11_DEFINE_MEMBER(CK_TIMESTAMP_PARAMS, useMilliseconds);
-PKCS11_DEFINE_MEMBER(CK_TIMESTAMP_PARAMS, timestampFormat);
-
-PKCS11_DEFINE_STRUCT(CK_ATTRIBUTES);
-PKCS11_DEFINE_MEMBER(CK_ATTRIBUTES, attributes);
-
-PKCS11_DEFINE_STRUCT(CK_MECH_AND_OBJECT);
-PKCS11_DEFINE_MEMBER(CK_MECH_AND_OBJECT, mechanism);
-PKCS11_DEFINE_MEMBER(CK_MECH_AND_OBJECT, obj);
-
-PKCS11_DEFINE_STRUCT(CK_MECH_TYPE_AND_OBJECT);
-PKCS11_DEFINE_MEMBER(CK_MECH_TYPE_AND_OBJECT, mechanism);
-PKCS11_DEFINE_MEMBER(CK_MECH_TYPE_AND_OBJECT, obj);
-
-PKCS11_DEFINE_STRUCT(CK_MECH_AND_OBJECTS);
-PKCS11_DEFINE_MEMBER(CK_MECH_AND_OBJECTS, mechanism);
-
-PKCS11_DEFINE_STRUCT(CK_PKCS_7_PARAMS);
-PKCS11_DEFINE_MEMBER(CK_PKCS_7_PARAMS, flags);
-PKCS11_DEFINE_MEMBER(CK_PKCS_7_PARAMS, length);
-PKCS11_DEFINE_MEMBER(CK_PKCS_7_PARAMS, signature);
-PKCS11_DEFINE_MEMBER(CK_PKCS_7_PARAMS, encryption);
-PKCS11_DEFINE_MEMBER(CK_PKCS_7_PARAMS, extensions);
-
-PKCS11_DEFINE_STRUCT(CK_PP_LOAD_SECRET_PARAMS);
-PKCS11_DEFINE_MEMBER(CK_PP_LOAD_SECRET_PARAMS, prompt);
-PKCS11_DEFINE_MEMBER(CK_PP_LOAD_SECRET_PARAMS, bMaskInput);
-PKCS11_DEFINE_MEMBER(CK_PP_LOAD_SECRET_PARAMS, cConvert);
-/* unimplemented attr CK_CHAR cTimeout  */
-/* unimplemented attr CK_CHAR reserved  */
-
-PKCS11_DEFINE_STRUCT(CK_REPLICATE_TOKEN_PARAMS);
-PKCS11_DEFINE_MEMBER(CK_REPLICATE_TOKEN_PARAMS, peerId);
-
-PKCS11_DEFINE_STRUCT(CK_SECRET_SHARE_PARAMS);
-PKCS11_DEFINE_MEMBER(CK_SECRET_SHARE_PARAMS, n);
-PKCS11_DEFINE_MEMBER(CK_SECRET_SHARE_PARAMS, m);
-
-PKCS11_DEFINE_STRUCT(CK_PKCS12_PBE_EXPORT_PARAMS);
-PKCS11_DEFINE_MEMBER(CK_PKCS12_PBE_EXPORT_PARAMS, passwordAuthSafe);
-PKCS11_DEFINE_MEMBER(CK_PKCS12_PBE_EXPORT_PARAMS, passwordHMAC);
-PKCS11_DEFINE_MEMBER(CK_PKCS12_PBE_EXPORT_PARAMS, keyCert);
-PKCS11_DEFINE_MEMBER(CK_PKCS12_PBE_EXPORT_PARAMS, safeBagKgMech);
-PKCS11_DEFINE_MEMBER(CK_PKCS12_PBE_EXPORT_PARAMS, safeContentKgMech);
-PKCS11_DEFINE_MEMBER(CK_PKCS12_PBE_EXPORT_PARAMS, hmacKgMech);
-
-PKCS11_DEFINE_STRUCT(CK_PKCS12_PBE_IMPORT_PARAMS);
-PKCS11_DEFINE_MEMBER(CK_PKCS12_PBE_IMPORT_PARAMS, certAttr);
-PKCS11_DEFINE_MEMBER(CK_PKCS12_PBE_IMPORT_PARAMS, passwordAuthSafe);
-PKCS11_DEFINE_MEMBER(CK_PKCS12_PBE_IMPORT_PARAMS, passwordHMAC);
-/* unimplemented attr CK_OBJECT_HANDLE_PTR hCert  */
-PKCS11_DEFINE_MEMBER(CK_PKCS12_PBE_IMPORT_PARAMS, hCertCount);
-
-PKCS11_DEFINE_STRUCT(CK_ECIES_PARAMS);
-PKCS11_DEFINE_MEMBER(CK_ECIES_PARAMS, pSharedData1);
-PKCS11_DEFINE_MEMBER(CK_ECIES_PARAMS, pSharedData2);
-/* unimplemented attr CK_EC_DH_PRIMITIVE dhPrimitive  */
-PKCS11_DEFINE_MEMBER(CK_ECIES_PARAMS, kdf);
-PKCS11_DEFINE_MEMBER(CK_ECIES_PARAMS, ulSharedDataLen1);
-/* unimplemented attr CK_EC_ENC_SCHEME encScheme  */
-PKCS11_DEFINE_MEMBER(CK_ECIES_PARAMS, ulEncKeyLenInBits);
-/* unimplemented attr CK_EC_MAC_SCHEME macScheme  */
-PKCS11_DEFINE_MEMBER(CK_ECIES_PARAMS, ulMacKeyLenInBits);
-PKCS11_DEFINE_MEMBER(CK_ECIES_PARAMS, ulMacLenInBits);
-PKCS11_DEFINE_MEMBER(CK_ECIES_PARAMS, ulSharedDataLen2);
-

data/ext/pk11s_struct_impl.inc

@@ -1,79 +0,0 @@
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_DES_CBC_PARAMS);
-PKCS11_IMPLEMENT_STRING_ACCESSOR(CK_DES_CBC_PARAMS, iv, ascii8bit);
-PKCS11_IMPLEMENT_STRING_ACCESSOR(CK_DES_CBC_PARAMS, data, ascii8bit);
-
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_DES2_CBC_PARAMS);
-PKCS11_IMPLEMENT_STRING_ACCESSOR(CK_DES2_CBC_PARAMS, iv, ascii8bit);
-PKCS11_IMPLEMENT_STRING_ACCESSOR(CK_DES2_CBC_PARAMS, data, ascii8bit);
-
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_DES3_CBC_PARAMS);
-PKCS11_IMPLEMENT_STRING_ACCESSOR(CK_DES3_CBC_PARAMS, iv, ascii8bit);
-PKCS11_IMPLEMENT_STRING_ACCESSOR(CK_DES3_CBC_PARAMS, data, ascii8bit);
-
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_TIMESTAMP_PARAMS);
-PKCS11_IMPLEMENT_BOOL_ACCESSOR(CK_TIMESTAMP_PARAMS, useMilliseconds);
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_TIMESTAMP_PARAMS, timestampFormat);
-
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_ATTRIBUTES);
-PKCS11_IMPLEMENT_PKCS11_STRUCT_PTR_ARRAY_ACCESSOR(CK_ATTRIBUTES, CK_ATTRIBUTE, attributes, count);
-
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_MECH_AND_OBJECT);
-PKCS11_IMPLEMENT_PKCS11_STRUCT_ACCESSOR(CK_MECH_AND_OBJECT, CK_MECHANISM, mechanism);
-PKCS11_IMPLEMENT_HANDLE_ACCESSOR(CK_MECH_AND_OBJECT, obj);
-
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_MECH_TYPE_AND_OBJECT);
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_MECH_TYPE_AND_OBJECT, mechanism);
-PKCS11_IMPLEMENT_HANDLE_ACCESSOR(CK_MECH_TYPE_AND_OBJECT, obj);
-
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_MECH_AND_OBJECTS);
-PKCS11_IMPLEMENT_STRUCT_PTR_ARRAY_ACCESSOR(CK_MECH_AND_OBJECTS, CK_MECH_AND_OBJECT, mechanism, count);
-
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_PKCS_7_PARAMS);
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_PKCS_7_PARAMS, flags);
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_PKCS_7_PARAMS, length);
-PKCS11_IMPLEMENT_STRUCT_ACCESSOR(CK_PKCS_7_PARAMS, CK_MECH_AND_OBJECTS, signature);
-PKCS11_IMPLEMENT_STRUCT_ACCESSOR(CK_PKCS_7_PARAMS, CK_MECH_AND_OBJECTS, encryption);
-PKCS11_IMPLEMENT_STRUCT_ACCESSOR(CK_PKCS_7_PARAMS, CK_ATTRIBUTES, extensions);
-
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_PP_LOAD_SECRET_PARAMS);
-PKCS11_IMPLEMENT_STRING_PTR_ACCESSOR(CK_PP_LOAD_SECRET_PARAMS, prompt, usascii);
-PKCS11_IMPLEMENT_BOOL_ACCESSOR(CK_PP_LOAD_SECRET_PARAMS, bMaskInput);
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_PP_LOAD_SECRET_PARAMS, cConvert);
-/* unimplemented attr CK_CHAR cTimeout  */
-/* unimplemented attr CK_CHAR reserved  */
-
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_REPLICATE_TOKEN_PARAMS);
-PKCS11_IMPLEMENT_STRING_ACCESSOR(CK_REPLICATE_TOKEN_PARAMS, peerId, usascii);
-
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_SECRET_SHARE_PARAMS);
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_SECRET_SHARE_PARAMS, n);
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_SECRET_SHARE_PARAMS, m);
-
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_PKCS12_PBE_EXPORT_PARAMS);
-PKCS11_IMPLEMENT_STRING_PTR_LEN_ACCESSOR(CK_PKCS12_PBE_EXPORT_PARAMS, passwordAuthSafe, passwordAuthSafeLen, usascii);
-PKCS11_IMPLEMENT_STRING_PTR_LEN_ACCESSOR(CK_PKCS12_PBE_EXPORT_PARAMS, passwordHMAC, passwordHMACLen, usascii);
-PKCS11_IMPLEMENT_HANDLE_ACCESSOR(CK_PKCS12_PBE_EXPORT_PARAMS, keyCert);
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_PKCS12_PBE_EXPORT_PARAMS, safeBagKgMech);
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_PKCS12_PBE_EXPORT_PARAMS, safeContentKgMech);
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_PKCS12_PBE_EXPORT_PARAMS, hmacKgMech);
-
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_PKCS12_PBE_IMPORT_PARAMS);
-PKCS11_IMPLEMENT_PKCS11_STRUCT_PTR_ARRAY_ACCESSOR(CK_PKCS12_PBE_IMPORT_PARAMS, CK_ATTRIBUTE, certAttr, certAttrCount);
-PKCS11_IMPLEMENT_STRING_PTR_LEN_ACCESSOR(CK_PKCS12_PBE_IMPORT_PARAMS, passwordAuthSafe, passwordAuthSafeLen, usascii);
-PKCS11_IMPLEMENT_STRING_PTR_LEN_ACCESSOR(CK_PKCS12_PBE_IMPORT_PARAMS, passwordHMAC, passwordHMACLen, usascii);
-/* unimplemented attr CK_OBJECT_HANDLE_PTR hCert  */
-PKCS11_IMPLEMENT_ULONG_PTR_ACCESSOR(CK_PKCS12_PBE_IMPORT_PARAMS, hCertCount);
-
-PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(CK_ECIES_PARAMS);
-PKCS11_IMPLEMENT_STRING_PTR_ACCESSOR(CK_ECIES_PARAMS, pSharedData1, ascii8bit);
-PKCS11_IMPLEMENT_STRING_PTR_ACCESSOR(CK_ECIES_PARAMS, pSharedData2, ascii8bit);
-/* unimplemented attr CK_EC_DH_PRIMITIVE dhPrimitive  */
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_ECIES_PARAMS, kdf);
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_ECIES_PARAMS, ulSharedDataLen1);
-/* unimplemented attr CK_EC_ENC_SCHEME encScheme  */
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_ECIES_PARAMS, ulEncKeyLenInBits);
-/* unimplemented attr CK_EC_MAC_SCHEME macScheme  */
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_ECIES_PARAMS, ulMacKeyLenInBits);
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_ECIES_PARAMS, ulMacLenInBits);
-PKCS11_IMPLEMENT_ULONG_ACCESSOR(CK_ECIES_PARAMS, ulSharedDataLen2);
-