ber 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b529c78f22f9ef52acf218c052a848d9df4a9593
+  data.tar.gz: 9a9a07871c5ebe2a2cf22e1adb60c02f0d00c771
+SHA512:
+  metadata.gz: 014c806ded70f21fc9d6330a76a8a803fc8f1ae710982b30d0dc62a404cf4e7ce9e894b8180e6c48cbe819da4bc6f36090c6ce6ec2bfb6a3b391faee3a17244a
+  data.tar.gz: 0d3d28f4ecd4cd0a0bfa1752a7828d246cd31a74bc4e60f9e4b111c0bfb2da008672c819eb9849d0b4ba5cb3c3e9443cbe7df8e54c87754946e6b97d835f9148

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_STORE
+.ruby-version

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+ - 1.9.3
+ - 2.0.0
+ - rbx-19mode
+ - jruby-19mode
+script: "bundle exec rspec"
+notifications:
+  email: false

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ber.rb.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Arcath
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,30 @@
+# BER [![Build Status](https://travis-ci.org/Arcath/BER.png?branch=master)](https://travis-ci.org/Arcath/BER)
+
+Implementation of Basic Encoding Rules (BER) in ruby
+
+## Installation
+
+Install via Rubygems:
+
+    $ gem install ber
+	
+Or add as a dependency to your gem 
+
+## Usage
+
+Adds a `to_ber` to the supported classes e.g.
+
+    "Foo".to_ber
+	>> "\x04\x03foo"
+
+Which in BER means that the supplied data is a string of length 3.
+
+BER extends all the supported classes so all you need to do is require it somewhere in your gem.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/ber.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ber/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "ber"
+  gem.version       = Ber::VERSION
+  gem.authors       = ["Arcath"]
+  gem.email         = ["adam@arcath.net"]
+  gem.description   = %q{An implementation of BER (Basic Encoding Rules) in Ruby}
+  gem.summary       = %q{An implementation of BER (Basic Encoding Rules) in Ruby}
+  gem.homepage      = "https://github.com/Arcath/BER"
+  
+  gem.add_development_dependency "rspec"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/ber.rb

@@ -0,0 +1,61 @@
+require "ber/version"
+
+require "ber/array"
+require "ber/bignum"
+require "ber/boolean"
+require "ber/fixnum"
+require "ber/string"
+
+module Ber
+  Zero = [0].pack('C')
+  Identifiers = {
+    end_of_content: 0x0,
+    boolean: 0x1,
+    fixnum: 0x2,
+    bit_string: 0x3,
+    ocet_string: 0x4,
+    null: 0x5,
+    array: 0x30,
+    
+    # Quick shorthands
+    string: 4
+  }
+  
+  def self.decode(input)
+    idents = Identifiers.select { |key, value| value == input.getbyte(0) }
+    identifier = idents.first.first
+    length = input.getbyte(1)
+    if length >= 127
+      length = input.length - (length - 126)
+    end
+    value = input[(input.length - length)..input.length]
+    if identifier == :fixnum
+      if length == 1
+        value = value.unpack('C').first
+      else
+        if value.length < 4
+          padded_value = "#{Zero * (4 - value.length)}#{value}"
+          value = padded_value.unpack('N').first
+        else
+          hex_total = ""
+          value.split("").each do |char|
+            hex = char.ord.to_s(16)
+            hex_total << "0" if hex.length == 1
+            hex_total << hex
+          end
+          value = hex_total.to_i(16)
+        end
+      end
+    elsif identifier == :boolean
+      value = (value == Zero ? false : true)
+    elsif identifier == :array 
+      values = []
+      found = value.scan(/(..[A-z]*)/) # This WILL NOT work for Bignums or strings of over 127 in length TODO: Fix this
+      found.each do |v|
+        values << Ber.decode(v.first)[:value]
+      end
+      value = values
+    end
+    {identifier: identifier, length: length, value: value}
+  end
+end

data/lib/ber/array.rb

@@ -0,0 +1,34 @@
+module Ber
+  module Array
+    def to_ber
+      array = (self.ber? ? self : self.berable).join
+      "#{[Ber::Identifiers[:array]].pack('C')}#{[array.length].pack('C')}#{array}"
+    end
+    
+    def berable
+      self.map { |x| x.to_ber }
+    end
+    
+    def berable!
+      self.map! { |x| x.to_ber }
+    end
+    
+    def ber?
+      ber = true
+      self.each do |i|
+        if ber
+          if i.class == "".class
+            ber = i.ber?
+          else
+            ber = false
+          end
+        end
+      end
+      return ber
+    end
+  end
+end
+
+class Array
+  include Ber::Array
+end

data/lib/ber/bignum.rb

@@ -0,0 +1,26 @@
+module Ber
+  module Bignum
+    ChunkSize = 0.size
+    
+    def to_ber
+      "#{[Ber::Identifiers[:fixnum]].pack('C')}#{encoded_self}"
+    end
+    
+    private
+    
+    def encoded_self
+      ber_blocks = []
+      i = self
+      while i > 0
+        block = i & 0xff
+        ber_blocks.push block
+        i = i >> ChunkSize
+      end
+      ([ber_blocks.size] + ber_blocks.reverse).pack('C*')
+    end
+  end
+end
+
+class Bignum
+  include Ber::Bignum
+end

data/lib/ber/boolean.rb

@@ -0,0 +1,22 @@
+module Ber
+  module Boolean
+    def to_ber
+      "#{[Ber::Identifiers[:boolean]].pack('C')}#{encoded_self}"
+    end
+    
+    private
+    
+    def encoded_self
+      encoded = (self ? [1].pack('C') : [0].pack('C'))
+      [1].pack('C') + encoded
+    end
+  end
+end
+
+class TrueClass
+  include Ber::Boolean
+end
+
+class FalseClass
+  include Ber::Boolean
+end

data/lib/ber/fixnum.rb

@@ -0,0 +1,28 @@
+module Ber
+  module Fixnum
+    ChunkSize = 0.size
+    
+    def to_ber
+      "#{[Ber::Identifiers[:fixnum]].pack('C')}#{encoded_self}"
+    end
+    
+    private
+    
+    def encoded_self
+      if self < (2 ** ChunkSize)
+        code = [self].pack('C')
+      else
+        code32 = [self].pack('N')
+        code = ""
+        code32.split("").each do |char|
+          code += char if char != [0].pack('C')
+        end
+      end
+      [code.length].pack('C') + code
+    end
+  end
+end
+
+class Fixnum
+  include Ber::Fixnum
+end

data/lib/ber/string.rb

@@ -0,0 +1,26 @@
+module Ber
+  module String
+    def to_ber(identifier = :string)
+      "#{[Ber::Identifiers[identifier]].pack('C')}#{encoded_length}#{self}"
+    end
+    
+    def ber?
+      self[0].ord < 30
+    end
+  
+    private
+  
+    def encoded_length
+      if length <= 127
+        [length].pack('C')
+      else
+        i = [length].pack('N').sub(/^[\0]+/,"")
+        [0x80 + i.length].pack('C') + i
+      end
+    end
+  end
+end
+
+class String
+  include Ber::String
+end

data/lib/ber/version.rb

@@ -0,0 +1,3 @@
+module Ber
+  VERSION = "0.0.1"
+end

data/spec/ber_array_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Ber::Array do
+  it "should make everything in the array \"berable\"" do
+    a = ["foo", "bar"]
+    a.berable.should eq ["foo".to_ber, "bar".to_ber]
+    a.should eq ["foo", "bar"]
+    a.berable!
+    a.should eq ["foo".to_ber, "bar".to_ber]
+  end
+  
+  it "should be able to check if it is ber" do
+    ["foo", "bar"].ber?.should be_false
+    ["foo".to_ber, "bar".to_ber].ber?.should be_true
+    ["foo".to_ber, "bar"].ber?.should be_false
+  end
+  
+  it "should be able to convert into ber" do
+    ["foo", "bar"].to_ber.should eq "0\n\x04\x03foo\x04\x03bar"
+  end
+end

data/spec/ber_bignum_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Ber::Bignum do
+  it "should encode a bignum" do
+    (2 ** 64).class.should be Bignum
+    (2 ** 64).to_ber.should eq "\u0002\t\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000"
+  end
+end

data/spec/ber_boolean_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Ber::Boolean do
+  it "should encode a true value" do
+    true.to_ber.should eq "\001\001\001"
+  end
+  
+  it "should encode a false value" do
+    false.to_ber.should eq "\001\001\000"
+  end
+end

data/spec/ber_fixnum_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Ber::Fixnum do
+  it "should have a Chunk Size defined" do
+    Ber::Fixnum::ChunkSize.should be_a Fixnum
+  end
+  
+  it "should extend fixnum with to_ber" do
+    10.to_ber
+  end
+  
+  it "should encode a small number (less than #{Ber::Fixnum::ChunkSize} bits long (less than #{(2 ** Ber::Fixnum::ChunkSize) - 1}))" do
+    15.to_ber.should eq "\u0002\u0001\u000F"
+  end
+  
+  it "should encode a large number (more than #{Ber::Fixnum::ChunkSize} bits long (more than #{(2 ** Ber::Fixnum::ChunkSize)}))" do
+    257.to_ber.should eq "\u0002\u0002\u0001\u0001"
+  end
+end

data/spec/ber_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Ber do
+  it "should have a version" do
+    Ber::VERSION.should be_a String
+  end
+  
+  it "should have a hash of identifiers" do
+    Ber::Identifiers.should be_a Hash
+  end
+  
+  it "should be able to decode a string" do
+    string = "foo".to_ber
+    decoded = Ber.decode(string)
+    decoded.should be_a Hash
+    decoded[:identifier].should eq :ocet_string
+    decoded[:length].should eq 3
+    decoded[:value].should eq "foo"
+  end
+  
+  it "should be able to decode a long_string" do
+    string = long_string.to_ber
+    decoded = Ber.decode(string)
+    decoded.should be_a Hash
+    decoded[:identifier].should eq :ocet_string
+    decoded[:length].should eq long_string.length
+    decoded[:value].should eq long_string
+    
+    string = long_string(200).to_ber
+    decoded = Ber.decode(string)
+    decoded.should be_a Hash
+    decoded[:identifier].should eq :ocet_string
+    decoded[:length].should eq long_string(200).length
+    decoded[:value].should eq long_string(200)
+  end
+  
+  it "should be able to decode a number" do
+    number = 15
+    decoded = Ber.decode(number.to_ber)
+    decoded[:identifier].should eq :fixnum
+    decoded[:length].should eq 1
+    decoded[:value].should eq number
+    
+    number = 258
+    decoded = Ber.decode(number.to_ber)
+    decoded[:identifier].should eq :fixnum
+    decoded[:length].should eq 2
+    decoded[:value].should eq number
+  end
+  
+  it "should be able to decode a big num" do
+    number = (2 ** 65)
+    decoded = Ber.decode(number.to_ber)
+    decoded[:identifier].should eq :fixnum
+    decoded[:length].should eq 9
+    decoded[:value].should eq number
+  end
+  
+  it "should be able to decode a true value" do
+    bool = true
+    decoded = Ber.decode(bool.to_ber)
+    decoded[:identifier].should eq :boolean
+    decoded[:length].should eq 1
+    decoded[:value].should eq bool
+  end
+  
+  it "should be able to decode a false value" do
+    bool = false
+    decoded = Ber.decode(bool.to_ber)
+    decoded[:identifier].should eq :boolean
+    decoded[:length].should eq 1
+    decoded[:value].should eq bool
+  end
+  
+  it "should be able to decode an array" do
+    array = ["foo", "bar"]
+    decoded = Ber.decode(array.to_ber)
+    decoded[:identifier].should eq :array
+    decoded[:length].should eq 10
+    decoded[:value].should eq array
+  end
+end

data/spec/ber_string_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Ber::String do
+  it "should extend String" do
+    "foo".to_ber
+  end
+  
+  it "should ber encode a string" do
+    "foo".to_ber.should eq "\x04\x03foo"
+  end
+  
+  it "should be able to tell if a string is a ber string" do
+    "foo".ber?.should be_false
+    "foo".to_ber.ber?.should be_true
+  end
+  
+  #it "should encode a longer string" do
+  #  long_string.to_ber.should eq "\x04\x82\x02X#{long_string}"
+  #end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'ber'
+
+def long_string(iterations = 100)
+  "foobar" * iterations
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: ber
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Arcath
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An implementation of BER (Basic Encoding Rules) in Ruby
+email:
+- adam@arcath.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ber.gemspec
+- lib/ber.rb
+- lib/ber/array.rb
+- lib/ber/bignum.rb
+- lib/ber/boolean.rb
+- lib/ber/fixnum.rb
+- lib/ber/string.rb
+- lib/ber/version.rb
+- spec/ber_array_spec.rb
+- spec/ber_bignum_spec.rb
+- spec/ber_boolean_spec.rb
+- spec/ber_fixnum_spec.rb
+- spec/ber_spec.rb
+- spec/ber_string_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Arcath/BER
+licenses: []
+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.0.0
+signing_key: 
+specification_version: 4
+summary: An implementation of BER (Basic Encoding Rules) in Ruby
+test_files:
+- spec/ber_array_spec.rb
+- spec/ber_bignum_spec.rb
+- spec/ber_boolean_spec.rb
+- spec/ber_fixnum_spec.rb
+- spec/ber_spec.rb
+- spec/ber_string_spec.rb
+- spec/spec_helper.rb