ampk 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 16ec52ea4400c790a5d30a3855ba5822fe8f9eea
+  data.tar.gz: 5cddbce6840ae250d4ee25f9546d4f04c1e52d44
+SHA512:
+  metadata.gz: 21e2b879cadf32f9b6321b87954442ea1d19a3296320937e573becb677e88943290d8397f72f7014fa8897fb3b812f57b9d417178b5b2fea0aaae11f9c47d826
+  data.tar.gz: 2035dcc012105fa13b24b923a3b2d98c867bdb2ddc6aad1742375c3078ff4918e4b6289fed2ca6d1e11c56bdfff89ab73a3bb21bf54ffa979debb7cd6ada2500

data/bin/ampk

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path('../../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'ampk'
+require 'optparse'
+Version = [0,0,1]
+def Version.to_s; "v#{join('.')}"; end
+
+options = {
+  :verbose => false
+}
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: ampk [options] <archive> [<files>]"
+  opts.on('-v', '--verbose', 'Verbose output') do
+    options[:verbose] = true
+  end
+  opts.on('-V', '--version', 'Display version') do
+    options[:mode] = :version
+  end
+  opts.on('-k', '--key=KEYFILE', 'Keyfile') do |key|
+    options[:keyfile] = key
+  end
+  opts.on('-d', '--digest=DIGEST', 'Digest/Password for keyfile') do |digest|
+	options[:digest] = digest
+  end
+  opts.on('-t', '--test', 'Check archive') do |v|
+    options[:mode] = :test
+  end
+  opts.on('-x', '--extract', 'Extract archive contents') do
+    options[:mode] = :extract
+  end
+  opts.on('-c', '--create', 'Create an archive') do
+    options[:mode] = :create
+  end
+  opts.on('-l', '--list', 'List archive contents') do
+    options[:mode] = :list
+  end
+end
+parser.program_name = File.basename(__FILE__)
+parser.parse!
+
+case options[:mode]
+when :create
+  key = Crypto::Key.from_file(options[:keyfile], options[:digest]) if options[:keyfile]
+  archive = AmpkReader.new(ARGV[0], key)
+  if archive.signed_or_encrypted?
+	if key.nil? && !options[:nocrypt]
+		raise "Archive requires a valid keyfile to verify"
+	end
+  end
+
+  archive.verify!
+when :extract
+when :list
+  key = Crypto::Key.from_file(options[:keyfile], options[:digest]) if options[:keyfile]
+  archive = AmpkReader.new(ARGV[0], key)
+
+  bits = [['Type', 'Flags', 'Size', 'Filename']]
+
+  archive.entities.each do |name|
+	info = archive.entity(name)
+	flags = info[:filter].to_s
+	flags += "S" if info[:signature]
+	bits << [info[:type], flags, info[:length], name]
+  end
+
+  if options[:verbose]
+	  col_size = [0]
+	  bits[0].each_with_index do |item, index|
+		  col_size[index] = 0
+		  bits.each do |row|
+			 col_size[index] = [col_size[index], row[index].to_s.size].max
+		  end
+	  end
+	  fmt = col_size.inject('') do |fmt, size|
+		  fmt << " | " unless fmt.empty?
+		  fmt << "%#{size}s"
+	  end << "\n"
+	  bits.each_with_index do |bit, index|
+		  printf fmt, *bit
+		  printf fmt, *col_size.map { |i| '-' * i } if index.zero?	  
+	  end
+  else
+	  puts archive.entities.join("\n")
+  end
+when :version
+  puts parser.version.to_s
+else
+  puts parser.help
+end
+

data/lib/ampk.rb

@@ -0,0 +1,6 @@
+require 'zlib'
+require 'ampk/writer'
+require 'ampk/reader'
+require 'ampk/crypto'
+require 'ampk/version'
+

data/lib/ampk/crypto.rb

@@ -0,0 +1,54 @@
+require 'fileutils'
+require 'openssl'
+require 'base64'
+
+module Crypto
+	def self.create_keys(priv = "dsa_key", pub = "#{priv}", bits = 1024)
+		private_key = OpenSSL::PKey::RSA.new(bits)
+		FileUtils.mkdir_p('private')
+		FileUtils.mkdir_p('public')
+		File.open("private/"+priv+".private", "w+") { |fp| fp << private_key.to_s }
+		File.open("public/"+pub+".public",  "w+") { |fp| fp << private_key.public_key.to_s }
+		private_key
+	end
+
+	class Key
+		attr_accessor :digest_string
+		def initialize(data, digest_string)
+			@public = (data =~ /^-----BEGIN (RSA|DSA) PRIVATE KEY-----$/).nil?
+			@prefix = @public ? "public" : "private"
+			@key = OpenSSL::PKey::RSA.new(data)
+			@digest_string = digest_string
+		end
+		
+		def self.from_file(filename, digest_string)
+			self.new(File.read(filename), digest_string)
+		end
+		
+		def encrypt(text)
+			Base64.encode64(@key.send("#{@prefix}_encrypt", text))
+		end
+		
+		def decrypt(text)
+			@key.send("#{@prefix}_decrypt", Base64.decode64(text))
+		end
+		
+		def sign(data)
+			Base64.encode64(@key.sign(digest, data))
+		end
+		
+		def verify(signature, data)
+			@key.verify(digest, Base64.decode64(signature), data)
+		end
+		
+		def public?
+			@public
+		end
+		
+		def digest
+			OpenSSL::Digest::MD5.new(@digest_string)
+		end
+	end
+end
+
+

data/lib/ampk/reader.rb

@@ -0,0 +1,232 @@
+require 'zlib'
+
+class AmpkReader
+	attr_reader :items, :path
+	def initialize(path, public_key)
+		@fp = File.open(@path=path,'rb')
+		@public_key = public_key
+	end
+	def verify!(verify_data=false)
+		@fp.rewind
+		must('start AMPK') { read4 == 'AMPK' }
+		until @fp.eof?
+			break if peek4 == 'ENDS'
+			name = verify_entry('NAME', true)
+			headers = {}
+			signature = nil
+			
+			until (header = peek4).eql?('DATA')
+				headers[header] ||= 0
+				headers[header] += 1
+				raise "Duplicate #{header} entry for #{name}" if headers[header] > 1
+				
+				case header
+				when 'FILT', 'DLEN', 'TYPE'
+					verify_entry(header, false)
+				when 'SIGN'
+					signature = verify_entry('SIGN', true)
+				end
+			end
+			
+			if signature
+				verify_entry_with_sig('DATA', verify_data, signature)
+			else
+				verify_entry('DATA', verify_data)
+			end
+		end
+	end
+	def entities
+		auto_scan
+		@items.map { |item| item[:name] }
+	end
+	def entity_signed?(name)
+		entity(name).has_key?(:signature)
+	end
+	def entity_encrypted?(name)
+		item = entity(name)
+		item.has_key?(:filter) and item[:filter].include?(?C)
+	end
+	def entity_compressed?(name)
+		item = entity(name)
+		item.has_key?(:filter) and item[:filter].include?(?Z)
+	end
+	def entity_size(name)
+		entity(name)[:length]
+	end
+	alias :entity_length :entity_size
+	def entity_type(name)
+		entity(name)[:type]
+	end
+	def entity(name)
+		auto_scan
+		item = @items.find { |item| item[:name] == name }
+		raise Errno::ENOENT, name if item.nil?
+		item
+	end
+	def read_entity(name)
+		auto_scan unless @items
+		item = @items.find { |item| item[:name] == name }
+		raise Errno::ENOENT, name if item.nil?
+		read_entity_data(item)
+	end
+	def close
+		@fp.close
+	end
+	
+	protected
+	def auto_scan
+		read_headers unless @items
+		nil
+	end
+
+	def read_headers
+		@fp.rewind
+		must('start AMPK') { read4 == 'AMPK' }
+		@items = []
+		until @fp.eof?
+			break if peek4 == 'ENDS'
+			@items << read_entity_header()
+			skip_entry('DATA')
+		end
+		@items
+	end
+	
+	def read_entity_header
+		start = @fp.tell
+		name = read_entry('NAME')
+		item = { :name => name, :header => start }
+		until (header=peek4).eql?('DATA')
+			case header
+			when 'SIGN'
+				item[:signature] = read_entry(header)
+			when 'DLEN'
+				item[:length] = read_entry(header).to_i
+			when 'FILT'
+				item[:filter] = read_entry(header)
+			when 'TYPE'
+				item[:type] = read_entry(header)
+			when 'ENCD'
+				item[:encoding] = read_entry(header)
+			else
+				raise RuntimeError, "Unknown/invalid header #{header}"
+			end
+		end
+		item[:offset] = @fp.tell
+		item
+	end
+	
+	def read_entity_data(item)
+		@fp.seek(item[:offset])
+		data = read_entry('DATA')
+		
+		if item[:filter]
+			item[:filter].reverse.each_byte do |byte|
+				case byte
+				when ?Z.ord
+					data = Zlib::Inflate.inflate(data)
+				when ?C.ord
+					data = @public_key.decrypt(data)
+				end
+			end
+		end
+		
+		if item[:signature]
+			if @public_key.verify(item[:signature], data)
+				return decode(item, data)
+			else
+				raise RuntimeError, "Invalid data for #{item[:name]}"
+			end
+		else
+			return decode(item, data)
+		end
+	end
+	
+	def decode(item, data)
+		if item[:encoding] && data.respond_to?(:encoding)
+			data.force_encoding(item[:encoding])
+		else
+			data
+		end
+	end
+	
+	def read_entry(name)
+		must("have a #{name} entry") { read4 == name }
+		size, data = read_data
+		must("have some #{name} data") { size == data.size }
+		data
+	end
+	
+	def skip_entry(name)
+		must("have a #{name} entry'") { read4 == name }
+		size, skipped = skip_data
+		must("have some #{name} data") { size == skipped }
+		nil
+	end
+	
+	def verify_entry(name, verify_data)
+		must("have a #{name} entry") { read4 == name }
+		if verify_data
+			size, data = read_data
+			must("have some #{name} data") { size == data.size }
+			data
+		else
+			size, skipped = skip_data
+			must("have at least as much data left") { skipped == size }
+			nil
+		end
+	end
+	
+	def verify_entry_with_sig(name, verify_data, sig)
+		data = verify_entry(name, verify_data)
+		if data and sig
+			must('be valid, signed data') { @public_key.verify(sig, data) }
+		end
+	end
+	
+	def must(description,&block)
+		raise RuntimeError, "Archive is invalid: It must #{description}" unless yield
+	end
+	
+	def read4
+		str = @fp.read(4)
+		str
+	end
+	
+	def peek4
+		pos = @fp.tell
+		str = @fp.read(4)
+		@fp.seek(pos, IO::SEEK_SET)
+		str
+	end
+	
+	def read_data_size
+		size = ""
+		while (c = get_byte).nonzero?
+			size << c
+		end
+		size.to_i
+	end
+	
+	def get_byte
+		if @fp.respond_to?(:getbyte)
+			@fp.getbyte
+		else
+			@fp.getc
+		end
+	end
+	
+	def read_data
+		size = read_data_size
+		data = @fp.read(size)
+		[size, data]
+	end
+	
+	def skip_data
+		size = read_data_size
+		posn = @fp.tell
+		@fp.seek(size, IO::SEEK_CUR)
+		skipped = @fp.tell - posn
+		[size, skipped]
+	end
+end
+

data/lib/ampk/version.rb

@@ -0,0 +1,6 @@
+module Ampk
+  VERSION = [0,0,5]
+  def VERSION.to_s
+    self * "."
+  end
+end

data/lib/ampk/writer.rb

@@ -0,0 +1,69 @@
+require 'zlib'
+
+class AmpkWriter
+	def initialize(path, private_key, &block)
+		@fp = File.open(path,'wb')
+		write("AMPK")
+		@private_key = private_key
+		if block_given?
+			begin
+				yield(self)
+			ensure
+				close()
+			end
+		end
+	end
+	def add_entity(name, data, options = {})
+		write_entry("NAME", name)
+		write_entry("DLEN", size(data).to_s)
+		
+		if data.respond_to?(:encoding)
+			write_entry("ENCD", data.encoding.name)
+			data = data.force_encoding("ASCII-8BIT")
+		end
+		
+		write_entry("TYPE", options[:type] || 'application/octet-stream')
+		if options[:sign] || options[:signature]
+			write_entry("SIGN", options[:signature] || @private_key.sign(data))
+		end
+		filter = ""
+		if options[:encrypt] || options[:crypt]
+			filter << "C"
+			data = @private_key.encrypt(data)
+		end
+		orig_size = size(data)
+		if options[:compress] and size(data) > 256
+			filter << "Z"
+			data = Zlib::Deflate.deflate(data)
+		end
+		unless filter.empty?
+			write_entry('FILT', filter)
+		end
+		write_size = size(data)
+		write_entry("DATA", data)
+	end
+	
+	def close
+		write('ENDS')
+		@fp.close()
+	end
+	
+	protected
+	def size(data)
+		sz = data.size
+		sz = data.bytesize if data.respond_to?(:bytesize)
+		sz
+	end
+	def write(str)
+		@fp.write(str)
+	end
+	def write_data(data)
+		write("#{size(data)}\0")
+		write(data)
+	end
+	def write_entry(name, data)
+		write(name)
+		write_data(data)
+	end
+end
+

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: ampk
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Geoff Youngs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-26 00:00:00.000000000 Z
+dependencies: []
+description: "  AMPK is simple archive format which allows contents to be encrypted
+  or signed\n \tusing a public/private key system.\n \t\n  Entities (i.e. files) can
+  be stored encrypted or signed with a private key.\n"
+email: git@intersect-uk.co.uk
+executables:
+- ampk
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/ampk
+- lib/ampk/writer.rb
+- lib/ampk/reader.rb
+- lib/ampk/crypto.rb
+- lib/ampk/version.rb
+- lib/ampk.rb
+homepage: http://github.com/livelink/ampk
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Simple signed/encrypted archive format library
+test_files: []