sysrandom 1.0.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e24cd46b6417b143899bcec5491ded930fdff1b9
+  data.tar.gz: b4c37eded4ec30f2860538b3db047f3b12b5db78
+SHA512:
+  metadata.gz: d91f8eb67cfa6c2a070fd06e7e15de5379e172d33d248eecce50e592fc8b1ebf1ab9d0bc22cfaef5380c34da9b8a8f979ee466406ece07270c158bead8976ee9
+  data.tar.gz: 708ede372c5493228dcdc63237c398a814df9b4ce47baac08dce981397346f945580cf29931c1dcd6cac2ff9afdb0c07b3d3ae208ae6e519499e3fe630ca40f6

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.so
+*.bundle
+*.dll

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,34 @@
+AllCops:
+  DisplayCopNames: true
+
+#
+# Style
+#
+
+LineLength:
+  Max: 128
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/SpaceBeforeFirstArg:
+  Enabled: false
+
+Style/ConditionalAssignment:
+  Enabled: false
+
+#
+# Metrics
+#
+
+Metrics/MethodLength:
+  Max: 22
+
+Metrics/AbcSize:
+  Max: 20
+
+AllCops:
+  Include:
+    - '**/Rakefile'
+  Exclude:
+    - 'spec/**/*'

data/.travis.yml

@@ -0,0 +1,9 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3.1
+  - jruby-9.1.1.0
+before_install: gem install bundler -v 1.12.3

data/CHANGES.md

@@ -0,0 +1,3 @@
+## 1.0.0 (2016-05-28)
+
+* Initial release.

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem "rake"
+  gem "rake-compiler"
+  gem "rspec"
+  gem "rubocop", "= 0.40.0"
+end

data/LICENSE.txt

@@ -0,0 +1,15 @@
+Copyright (c) 2013-2016
+Frank Denis  <j at pureftpd dot org>
+Tony Arcieri <bascule at gmail dot com>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/README.md

@@ -0,0 +1,112 @@
+# Sysrandom
+
+[![Gem Version](https://badge.fury.io/rb/sysrandom.svg)](https://rubygems.org/gems/sysrandom)
+[![Build Status](https://secure.travis-ci.org/cryptosphere/sysrandom.svg?branch=master)](https://travis-ci.org/cryptosphere/sysrandom)
+[![ISC licensed](https://img.shields.io/badge/license-ISC-blue.svg)](https://github.com/cryptosphere/sysrandom/blob/master/LICENSE.txt)
+
+Secure random number generation for Ruby using system RNG facilities e.g. `/dev/urandom`, `getrandom(2)`
+
+## Description
+
+[Concerns have been raised][concerns] about the current implementation of Ruby's built-in
+`SecureRandom` functionality, as it presently leverages the poorly reputed OpenSSL RNG.
+
+In cryptography circles, [the prevailing advice is to use OS RNG functionality][/dev/urandom],
+namely `/dev/urandom` or equivalent calls which use an OS-level CSPRNG to
+produce random numbers.
+
+This gem provides an easy-to-install repackaging of the `randombytes`
+functionality from [libsodium] for the purpose of generating secure random
+numbers trustworthy for use in cryptographic contexts, such as generating
+cryptographic keys, initialization vectors, or nonces.
+
+The following random number generators are utilized:
+
+| OS      | RNG                                                               |
+|---------|-------------------------------------------------------------------|
+| Linux   | [getrandom(2)] if available, otherwise [/dev/urandom]             |
+| Windows | [RtlGenRandom]                                                    |
+| OpenBSD | [arc4random(3)] with ChaCha20 CSPRNG (not RC4)                    |
+| JRuby   | [SecureRandom.getInstanceStrong] if available, otherwise SHA1PRNG |
+| Others  | [/dev/urandom]                                                    |
+
+[concerns]:      https://bugs.ruby-lang.org/issues/9569
+[libsodium]:     https://github.com/jedisct1/libsodium
+[getrandom(2)]:  http://man7.org/linux/man-pages/man2/getrandom.2.html
+[/dev/urandom]:  http://sockpuppet.org/blog/2014/02/25/safely-generate-random-numbers/
+[RtlGenRandom]:  https://msdn.microsoft.com/en-us/library/windows/desktop/aa387694(v=vs.85).aspx
+[arc4random(3)]: http://man.openbsd.org/arc4random.3
+[SecureRandom.getInstanceStrong]: https://docs.oracle.com/javase/8/docs/api/java/security/SecureRandom.html#getInstanceStrong--
+
+## Supported Platforms
+
+Sysrandom is tested on the following Ruby implementations:
+
+* Ruby (MRI) 2.0, 2.1, 2.2, 2.3
+* JRuby 9.1.1.0
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sysrandom'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sysrandom
+
+## Usage
+
+`Sysrandom` aims to be API-compatible with Ruby's built-in `SecureRandom` class,
+but always prefers OS-level RNG wherever it's available:
+
+```ruby
+>> Sysrandom.random_number(42)
+=> 15
+>> Sysrandom.random_bytes(32)
+=> "\xD6J\xB3\xD2\x8B\x7F*9D\xB7\xF9\xEA\xE2\\\xAAH\tV#\xEC\x84\xE3E\r\x97\xB9\b\xFCH\x17\xA0\v"
+>> Sysrandom.base64(32)
+=> "WXPkxfAuLRpnI6Z4zFb4E+MIenx6w6vKhe01+rMPuIQ="
+>> Sysrandom.urlsafe_base64(32)
+=> "37rsMfR4X8g7Bb-uDJEekRHnB3r_7nO03cv52ilaWqE="
+>> Sysrandom.hex(32)
+=> "c950496ce200abf7d18eb1414e9206c6335f971a37d0394114f56439b59831ba"
+>> Sysrandom.uuid
+=> "391c6f52-8017-4838-9790-131a9b979c63"
+```
+
+* [SecureRandom API docs](http://ruby-doc.org/stdlib-2.0.0/libdoc/securerandom/rdoc/SecureRandom.html)
+
+## Patching SecureRandom with Sysrandom
+
+Since Sysrandom is SecureRandom-compatible, it can be patched in-place of
+SecureRandom if you prefer its RNG behavior.
+
+To do this, require `sysrandom/securerandom`:
+
+```ruby
+>> SecureRandom
+=> SecureRandom
+>> require "sysrandom/securerandom"
+=> true
+>> SecureRandom
+=> Sysrandom
+>> SecureRandom.hex(32)
+=> "d1bbe8c1ab78fc2fe514c5623d913a27ffd2dcdc9e002f3b358bb01a996962f1"
+```
+
+## Contributing
+
+* Fork this repository on Github
+* Make your changes and send a pull request
+* If your changes look good, we'll merge them
+
+## Copyright
+
+Copyright (c) 2013-2016 Frank Denis, Tony Arcieri. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,21 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+require "rake/clean"
+
+unless defined? JRUBY_VERSION
+  require "rake/extensiontask"
+  Rake::ExtensionTask.new("sysrandom_ext") do |ext|
+    ext.ext_dir = "ext/sysrandom"
+  end
+end
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+default_tasks = %w(spec rubocop)
+default_tasks.unshift("compile") unless defined?(JRUBY_VERSION)
+
+task default: default_tasks
+
+CLEAN.include "**/*.o", "**/*.so", "**/*.bundle", "pkg", "tmp"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sysrandom"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/sysrandom/extconf.rb

@@ -0,0 +1,4 @@
+require "mkmf"
+
+dir_config "sysrandom_ext"
+create_makefile "sysrandom_ext"

data/ext/sysrandom/randombytes_sysrandom.c

@@ -0,0 +1,275 @@
+/*
+ * __randombytes_sysrandom.c: adapted from libsodium
+ * Copyright (c) 2013-2016 Frank Denis <j at pureftpd dot org>
+ * https://github.com/jedisct1/libsodium
+ */
+
+#include <stdlib.h>
+#include <sys/types.h>
+#ifndef _WIN32
+# include <sys/stat.h>
+# include <sys/time.h>
+#endif
+#ifdef __linux__
+# include <sys/syscall.h>
+#endif
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdint.h>
+#include <string.h>
+#ifndef _WIN32
+# include <unistd.h>
+#endif
+
+#ifdef _WIN32
+# include <windows.h>
+# define RtlGenRandom SystemFunction036
+# if defined(__cplusplus)
+extern "C"
+# endif
+BOOLEAN NTAPI RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);
+# pragma comment(lib, "advapi32.lib")
+#endif
+
+#if defined(__OpenBSD__) || defined(__CloudABI__)
+# define HAVE_SAFE_ARC4RANDOM 1
+#endif
+
+#ifndef SSIZE_MAX
+# define SSIZE_MAX (SIZE_MAX / 2 - 1)
+#endif
+
+#ifdef HAVE_SAFE_ARC4RANDOM
+
+uint32_t
+__randombytes_sysrandom(void)
+{
+    return arc4random();
+}
+
+static void
+__randombytes_sysrandom_stir(void)
+{
+}
+
+void
+__randombytes_sysrandom_buf(void * const buf, const size_t size)
+{
+    return arc4random_buf(buf, size);
+}
+
+#else /* __OpenBSD__ */
+
+typedef struct SysRandom_ {
+    int random_data_source_fd;
+    int initialized;
+    int getrandom_available;
+} SysRandom;
+
+static SysRandom stream = {
+    .random_data_source_fd = -1,
+    .initialized = 0,
+    .getrandom_available = 0
+};
+
+#ifndef _WIN32
+static ssize_t
+safe_read(const int fd, void * const buf_, size_t size)
+{
+    unsigned char *buf = (unsigned char *) buf_;
+    ssize_t        readnb;
+
+    assert(size > (size_t) 0U);
+    assert(size <= SSIZE_MAX);
+    do {
+        while ((readnb = read(fd, buf, size)) < (ssize_t) 0 &&
+               (errno == EINTR || errno == EAGAIN)); /* LCOV_EXCL_LINE */
+        if (readnb < (ssize_t) 0) {
+            return readnb; /* LCOV_EXCL_LINE */
+        }
+        if (readnb == (ssize_t) 0) {
+            break; /* LCOV_EXCL_LINE */
+        }
+        size -= (size_t) readnb;
+        buf += readnb;
+    } while (size > (ssize_t) 0);
+
+    return (ssize_t) (buf - (unsigned char *) buf_);
+}
+#endif
+
+#ifndef _WIN32
+static int
+__randombytes_sysrandom_random_dev_open(void)
+{
+/* LCOV_EXCL_START */
+    struct stat        st;
+    static const char *devices[] = {
+# ifndef USE_BLOCKING_RANDOM
+        "/dev/urandom",
+# endif
+        "/dev/random", NULL
+    };
+    const char **      device = devices;
+    int                fd;
+
+    do {
+        fd = open(*device, O_RDONLY);
+        if (fd != -1) {
+            if (fstat(fd, &st) == 0 &&
+# ifdef __COMPCERT__
+                1
+# elif defined(S_ISNAM)
+                (S_ISNAM(st.st_mode) || S_ISCHR(st.st_mode))
+# else
+                S_ISCHR(st.st_mode)
+# endif
+               ) {
+# if defined(F_SETFD) && defined(FD_CLOEXEC)
+                (void) fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
+# endif
+                return fd;
+            }
+            (void) close(fd);
+        } else if (errno == EINTR) {
+            continue;
+        }
+        device++;
+    } while (*device != NULL);
+
+    errno = EIO;
+    return -1;
+/* LCOV_EXCL_STOP */
+}
+
+# ifdef SYS_getrandom
+static int
+_randombytes_linux_getrandom(void * const buf, const size_t size)
+{
+    int readnb;
+
+    assert(size <= 256U);
+    do {
+        readnb = syscall(SYS_getrandom, buf, (int) size, 0);
+    } while (readnb < 0 && (errno == EINTR || errno == EAGAIN));
+
+    return (readnb == (int) size) - 1;
+}
+
+static int
+randombytes_linux_getrandom(void * const buf_, size_t size)
+{
+    unsigned char *buf = (unsigned char *) buf_;
+    size_t         chunk_size = 256U;
+
+    do {
+        if (size < chunk_size) {
+            chunk_size = size;
+            assert(chunk_size > (size_t) 0U);
+        }
+        if (_randombytes_linux_getrandom(buf, chunk_size) != 0) {
+            return -1;
+        }
+        size -= chunk_size;
+        buf += chunk_size;
+    } while (size > (size_t) 0U);
+
+    return 0;
+}
+# endif
+
+static void
+__randombytes_sysrandom_init(void)
+{
+    const int     errno_save = errno;
+
+# ifdef SYS_getrandom
+    {
+        unsigned char fodder[16];
+
+        if (randombytes_linux_getrandom(fodder, sizeof fodder) == 0) {
+            stream.getrandom_available = 1;
+            errno = errno_save;
+            return;
+        }
+        stream.getrandom_available = 0;
+    }
+# endif
+
+    if ((stream.random_data_source_fd =
+         __randombytes_sysrandom_random_dev_open()) == -1) {
+        abort(); /* LCOV_EXCL_LINE */
+    }
+    errno = errno_save;
+}
+
+#else /* _WIN32 */
+
+static void
+__randombytes_sysrandom_init(void)
+{
+}
+#endif
+
+static void
+__randombytes_sysrandom_stir(void)
+{
+    if (stream.initialized == 0) {
+        __randombytes_sysrandom_init();
+        stream.initialized = 1;
+    }
+}
+
+static void
+__randombytes_sysrandom_stir_if_needed(void)
+{
+    if (stream.initialized == 0) {
+        __randombytes_sysrandom_stir();
+    }
+}
+
+void
+__randombytes_sysrandom_buf(void * const buf, const size_t size)
+{
+    __randombytes_sysrandom_stir_if_needed();
+#ifdef ULONG_LONG_MAX
+    /* coverity[result_independent_of_operands] */
+    assert(size <= ULONG_LONG_MAX);
+#endif
+#ifndef _WIN32
+# ifdef SYS_getrandom
+    if (stream.getrandom_available != 0) {
+        if (randombytes_linux_getrandom(buf, size) != 0) {
+            abort();
+        }
+        return;
+    }
+# endif
+    if (stream.random_data_source_fd == -1 ||
+        safe_read(stream.random_data_source_fd, buf, size) != (ssize_t) size) {
+        abort(); /* LCOV_EXCL_LINE */
+    }
+#else
+    if (size > (size_t) 0xffffffff) {
+        abort(); /* LCOV_EXCL_LINE */
+    }
+    if (! RtlGenRandom((PVOID) buf, (ULONG) size)) {
+        abort(); /* LCOV_EXCL_LINE */
+    }
+#endif
+}
+
+uint32_t
+__randombytes_sysrandom(void)
+{
+    uint32_t r;
+
+    __randombytes_sysrandom_buf(&r, sizeof r);
+
+    return r;
+}
+
+#endif /* __OpenBSD__ */

data/ext/sysrandom/sysrandom_ext.c

@@ -0,0 +1,77 @@
+#include "ruby.h"
+
+/* How many bytes to generate by default, matching SecureRandom
+ * Why SecureRandom has a default size argument is beyond me */
+#define DEFAULT_N_BYTES 16
+
+static VALUE mSysrandom = Qnil;
+
+static VALUE Sysrandom_random_uint32(VALUE self);
+static VALUE Sysrandom_random_bytes(int argc, VALUE *argv, VALUE self);
+
+/* From randombytes_sysrandom.c */
+uint32_t __randombytes_sysrandom(void);
+void __randombytes_sysrandom_buf(void * const buf, const size_t size);
+
+void Init_sysrandom_ext()
+{
+    mSysrandom = rb_define_module("Sysrandom");
+
+    rb_define_singleton_method(mSysrandom, "__random_uint32", Sysrandom_random_uint32, 0);
+    rb_define_method(mSysrandom, "__random_uint32", Sysrandom_random_uint32, 0);
+
+    rb_define_singleton_method(mSysrandom, "random_bytes", Sysrandom_random_bytes, -1);
+    rb_define_method(mSysrandom, "random_bytes", Sysrandom_random_bytes, -1);
+}
+
+/**
+ *  call-seq:
+ *    Sysrandom#__random_uint32 -> Fixnum
+ *
+ * Generates a random unsigned 32-bit integer using the OS CSPRNG
+ *
+ */
+static VALUE
+Sysrandom_random_uint32(VALUE self)
+{
+    return UINT2NUM(__randombytes_sysrandom());
+}
+
+/**
+ *  call-seq:
+ *    Sysrandom#random_bytes(n=nil) -> String
+ *
+ * ::random_bytes generates a random binary string via the OS CSPRNG.
+ *
+ * The argument n specifies how long the resulting string should be.
+ *
+ * For compatibility with SecureRandom, if n is not specified, 16 is assumed.
+ *
+ * The resulting string may contain any byte (i.e. "x00" - "xff")
+ *
+ */
+static VALUE
+Sysrandom_random_bytes(int argc, VALUE * argv, VALUE self)
+{
+    VALUE n_obj, str;
+    int n;
+
+    if (rb_scan_args(argc, argv, "01", &n_obj) == 1) {
+        n = NUM2INT(n_obj);
+
+        if(n < 0) {
+          rb_raise(rb_eArgError, "negative string size");
+        }
+    } else {
+        n = DEFAULT_N_BYTES;
+    }
+
+    if(n > 0) {
+        str = rb_str_new(0, n);
+        __randombytes_sysrandom_buf(RSTRING_PTR(str), n);
+    } else {
+        str = rb_str_new2("");
+    }
+
+    return str;
+}

data/lib/sysrandom/securerandom.rb

@@ -0,0 +1,7 @@
+require "sysrandom"
+
+# Make sure SecureRandom has been loaded before we patch it
+require "securerandom"
+
+Object.send(:remove_const, :SecureRandom)
+SecureRandom = Sysrandom

data/lib/sysrandom/version.rb

@@ -0,0 +1,3 @@
+module Sysrandom
+  VERSION = "1.0.0".freeze
+end

data/lib/sysrandom.rb

@@ -0,0 +1,64 @@
+require "sysrandom/version"
+
+require "base64"
+
+# Secure random number generation using system RNG facilities
+module Sysrandom
+  module_function
+
+  # For some reason SecureRandom defaults to 16 bytes
+  DEFAULT_LENGTH = 16
+
+  if defined?(JRUBY_VERSION)
+    require "java"
+
+    if java.security.SecureRandom.respond_to?(:getInstanceStrong)
+      @_java_secure_random = java.security.SecureRandom.getInstanceStrong
+    else
+      @_java_secure_random = java.security.SecureRandom.getInstance("SHA1PRNG")
+    end
+
+    # Random uint32, used by random_number. The C extension provides an equivalent method
+    def __random_uint32
+      @_java_secure_random.nextLong & 0xFFFFFFFF
+    end
+
+    def random_bytes(n = DEFAULT_LENGTH)
+      raise ArgumentError, "negative string size" if n < 0
+
+      bytes = Java::byte[n].new
+      @_java_secure_random.nextBytes(bytes)
+      String.from_java_bytes(bytes)
+    end
+  else
+    require "sysrandom_ext"
+  end
+
+  def random_number(n = 0)
+    result = __random_uint32 / (2**32).to_f
+
+    if n <= 0
+      result
+    else
+      result *= n
+      n.is_a?(Fixnum) ? result.floor : result
+    end
+  end
+
+  def base64(n = DEFAULT_LENGTH)
+    Base64.encode64(random_bytes(n)).chomp
+  end
+
+  def urlsafe_base64(n = DEFAULT_LENGTH)
+    Base64.urlsafe_encode64(random_bytes(n)).chomp
+  end
+
+  def hex(n = DEFAULT_LENGTH)
+    random_bytes(n).unpack("h*").first
+  end
+
+  def uuid
+    values = SecureRandom.hex(16).match(/\A(.{8})(.{4})(.)(.{3})(.)(.{3})(.{12})\z/)
+    "#{values[1]}-#{values[2]}-4#{values[4]}-#{'89ab'[values[5].ord % 4]}#{values[6]}-#{values[7]}"
+  end
+end

data/sysrandom.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "sysrandom/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "sysrandom"
+  spec.version       = Sysrandom::VERSION
+  spec.authors       = ["Tony Arcieri"]
+  spec.email         = ["bascule@gmail.com"]
+
+  spec.summary       = "Secure random number generation using system RNG facilities"
+  spec.description   = "Sysrandom generates secure random numbers using /dev/urandom, getrandom(), etc"
+  spec.homepage      = "https://github.com/cryptosphere/sysrandom"
+  spec.licenses      = ["ISC"]
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  if defined? JRUBY_VERSION
+    spec.platform = "java"
+  else
+    spec.extensions = ["ext/sysrandom/extconf.rb"]
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: sysrandom
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: java
+authors:
+- Tony Arcieri
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2016-05-29 00:00:00.000000000 Z
+dependencies: []
+description: Sysrandom generates secure random numbers using /dev/urandom, getrandom(), etc
+email:
+- bascule@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGES.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/sysrandom/extconf.rb
+- ext/sysrandom/randombytes_sysrandom.c
+- ext/sysrandom/sysrandom_ext.c
+- lib/sysrandom.rb
+- lib/sysrandom/securerandom.rb
+- lib/sysrandom/version.rb
+- sysrandom.gemspec
+homepage: https://github.com/cryptosphere/sysrandom
+licenses:
+- ISC
+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: []
+rubyforge_project:
+rubygems_version: 2.4.8
+signing_key:
+specification_version: 4
+summary: Secure random number generation using system RNG facilities
+test_files: []