mpw 2.0.3 → 3.0.0

data/lib/mpw/mpw.rb

@@ -1,332 +1,460 @@
 #!/usr/bin/ruby
-# author: nishiki
-# mail: nishiki@yaegashi.fr
+# MPW is a software to crypt and manage your passwords
+# Copyright (C) 2016  Adrien Waksberg <mpw@yae.im>
+# 
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
-require 'rubygems'
+require 'rubygems/package'
 require 'gpgme'
-require 'csv'
 require 'i18n'
-require 'fileutils'
 require 'yaml'
-require 'mpw/item'
+
+#TODO
+require "#{APP_ROOT}/../lib/mpw/item.rb"
 	
 module MPW
-	class MPW
-	
-		attr_accessor :error_msg
-		
-		# Constructor
-		def initialize(file_gpg, key, share_keys='')
-			@error_msg  = nil
-			@file_gpg   = file_gpg
-			@key        = key
-			@share_keys = share_keys
-			@data       = []
-		end
-	
-		# Decrypt a gpg file
-		# @args: password -> the GPG key password
-		# @rtrn: true if data has been decrypted
-		def decrypt(password=nil)
-			@data = []
-
-			if File.exist?(@file_gpg) and not File.zero?(@file_gpg)
-				crypto       = GPGME::Crypto.new(armor: true)
-				data_decrypt = crypto.decrypt(IO.read(@file_gpg), password: password).read.force_encoding('utf-8')
-
-				if not data_decrypt.to_s.empty?
-					YAML.load(data_decrypt).each_value do |d|
-						@data.push(Item.new(id:        d['id'],
-						                    name:      d['name'],
-						                    group:     d['group'],
-						                    host:      d['host'],
-						                    protocol:  d['protocol'],
-						                    user:      d['user'],
-						                    password:  d['password'],
-						                    port:      d['port'],
-						                    comment:   d['comment'],
-						                    last_edit: d['last_edit'],
-						                    created:   d['created'],
-						                   )
-						          )
-					end
+class MPW
+
+	# Constructor
+	def initialize(key, wallet_file, gpg_pass=nil)
+		@key         = key
+		@gpg_pass    = gpg_pass
+		@wallet_file = wallet_file
+	end
+
+	# Read mpw file
+	def read_data
+		@config    = {}
+		@data      = []
+		@keys      = {}
+		@passwords = {}
+
+		data       = nil
+
+		return if not File.exists?(@wallet_file)
+
+		Gem::Package::TarReader.new(File.open(@wallet_file)) do |tar|
+			tar.each do |f| 
+				case f.full_name
+					when 'wallet/config.gpg'
+						@config = YAML.load(decrypt(f.read))
+
+					when 'wallet/meta.gpg'
+						data = decrypt(f.read)
+
+					when /^wallet\/keys\/(?<key>.+)\.pub$/
+						key = Regexp.last_match('key')
+
+						if GPGME::Key.find(:public, key).length == 0
+							GPGME::Key.import(f.read, armor: true)
+						end
+
+						@keys[key] = f.read
+
+					when /^wallet\/passwords\/(?<id>[a-zA-Z0-9]+)\.gpg$/
+						@passwords[Regexp.last_match('id')] = f.read
+					else
+						next
 				end
 			end
-	
-			return true
-		rescue Exception => e 
-			@error_msg = "#{I18n.t('error.gpg_file.decrypt')}\n#{e}"
-			return false
 		end
-	
-		# Encrypt a file
-		# @rtrn: true if the file has been encrypted
-		def encrypt
-			FileUtils.cp(@file_gpg, "#{@file_gpg}.bk") if File.exist?(@file_gpg)
 
-			data_to_encrypt = {}
-	
-			@data.each do |item|
-				next if item.empty?
-
-				data_to_encrypt.merge!(item.id => {'id'        => item.id,
-				                                   'name'      => item.name,
-				                                   'group'     => item.group,
-				                                   'host'      => item.host,
-				                                   'protocol'  => item.protocol,
-				                                   'user'      => item.user,
-				                                   'password'  => item.password,
-				                                   'port'      => item.port,
-				                                   'comment'   => item.comment,
-				                                   'last_edit' => item.last_edit,
-				                                   'created'   => item.created,
-				                                  }
-				                      )
+		if not data.nil? and not data.empty?
+			YAML.load(data).each_value do |d|
+				@data.push(Item.new(id:        d['id'],
+				                    name:      d['name'],
+				                    group:     d['group'],
+				                    host:      d['host'],
+				                    protocol:  d['protocol'],
+				                    user:      d['user'],
+				                    port:      d['port'],
+				                    comment:   d['comment'],
+				                    last_edit: d['last_edit'],
+				                    created:   d['created'],
+				                   )
+				          )
 			end
-	
-			recipients = []
-			recipients.push(@key)
-			if not @share_keys.nil?
-				@share_keys.split.each { |k| recipients.push(k) }
+		end
+
+		add_key(@key) if @keys[@key].nil?
+	rescue Exception => e
+		raise "#{I18n.t('error.mpw_file.read_data')}\n#{e}"
+	end
+
+	# Encrypt a file
+	def write_data
+		data     = {}
+		tmp_file = "#{@wallet_file}.tmp"
+
+		@data.each do |item|
+			next if item.empty?
+
+			data.merge!(item.id => {'id'        => item.id,
+			                        'name'      => item.name,
+		                            'group'     => item.group,
+			                        'host'      => item.host,
+			                        'protocol'  => item.protocol,
+			                        'user'      => item.user,
+			                        'port'      => item.port,
+			                        'comment'   => item.comment,
+			                        'last_edit' => item.last_edit,
+			                        'created'   => item.created,
+			                       }
+			           )
+		end
+
+		Gem::Package::TarWriter.new(File.open(tmp_file, 'w+')) do |tar|
+			data_encrypt = encrypt(data.to_yaml)
+			tar.add_file_simple('wallet/meta.gpg', 0400, data_encrypt.length) do |io|
+				io.write(data_encrypt)
 			end
 
-			crypto = GPGME::Crypto.new(armor: true)
-			file_gpg = File.open(@file_gpg, 'w+')
-			crypto.encrypt(data_to_encrypt.to_yaml, recipients: recipients, output: file_gpg)
-			file_gpg.close
-	
-			FileUtils.rm("#{@file_gpg}.bk") if File.exist?("#{@file_gpg}.bk")
-			return true
-		rescue Exception => e 
-			@error_msg = "#{I18n.t('error.gpg_file.encrypt')}\n#{e}"
-			FileUtils.mv("#{@file_gpg}.bk", @file_gpg) if File.exist?("#{@file_gpg}.bk")
-			return false
+			config = encrypt(@config.to_yaml)
+			tar.add_file_simple('wallet/config.gpg', 0400, config.length) do |io|
+				io.write(config)
+			end
+
+			@passwords.each do |id, password|
+				tar.add_file_simple("wallet/passwords/#{id}.gpg", 0400, password.length) do |io|
+					io.write(password)
+				end
+			end
+
+			@keys.each do |id, key|
+				tar.add_file_simple("wallet/keys/#{id}.pub", 0400, key.length) do |io|
+					io.write(key)
+				end
+			end
 		end
+
+		File.rename(tmp_file, @wallet_file)
+	rescue Exception => e
+		File.unlink(tmp_file)
+
+		raise "#{I18n.t('error.mpw_file.write_data')}\n#{e}"
+	end
+
+	# Get a password
+	# args: id -> the item id
+	def get_password(id)
+		password = decrypt(@passwords[id])
 		
-		# Add a new item
-		# @args: item -> Object MPW::Item
-		# @rtrn: true if add item
-		def add(item)
-			if not item.instance_of?(Item)
-				@error_msg = I18n.t('error.bad_class')
-				return false
-			elsif item.empty?
-				@error_msg = I18n.t('error.add.empty')
-				return false
-			else
-				@data.push(item)
-				return true
-			end
+		if /^\$[a-zA-Z0-9]{4,9}::(?<password>.+)$/ =~ password
+			return Regexp.last_match('password')
+		else
+			return password
 		end
+	end
 
-		# Search in some csv data
-		# @args: options -> a hash with paramaters
-		# @rtrn: a list with the resultat of the search
-		def list(options={})
-			result = []
-	
-			search   = options[:search].to_s.downcase
-			group    = options[:group].to_s.downcase
-			protocol = options[:protocol].to_s.downcase
+	# Set a password
+	# args: id -> the item id
+	#       password -> the new password
+	def set_password(id, password)
+		salt     = MPW::password(Random.rand(4..9))
+		password = "$#{salt}::#{password}"
 
-			@data.each do |item|
-				next if item.empty?
+		@passwords[id] = encrypt(password)
+	end
 
-				next if not group.empty?    and not group.eql?(item.group.downcase)
-				next if not protocol.empty? and not protocol.eql?(item.protocol.downcase)
-				
-				name    = item.name.to_s.downcase
-				host    = item.host.to_s.downcase
-				comment = item.comment.to_s.downcase
+	# Add a public key
+	# args: key ->  new public key
+	#       file -> public gpg file to import
+	def add_key(key, file=nil)
+		if not file.nil? and File.exists?(file)
+			data = File.open(file).read
+			GPGME::Key.import(data, armor: true)
+		else
+			data = GPGME::Key.export(key, armor: true).read
+		end
 
-				if not name =~ /^.*#{search}.*$/ and not host =~ /^.*#{search}.*$/ and not comment =~ /^.*#{search}.*$/ 
-					next
-				end
+		if data.to_s.empty?
+			raise I18n.t('error.export_key')
+		end
 
-				result.push(item)
-			end
-	
-			return result
+		@keys[key] = data
+	end
+
+	# Delete a public key
+	# args: key ->  public key to delete
+	def delete_key(key)
+		@keys.delete(key)
+	end
+
+	# Set config
+	# args: config -> a hash with config options
+	def set_config(config)
+		@config['sync'] = {} if @config['sync'].nil?
+
+		@config['sync']['type']      = config['sync']['type']
+		@config['sync']['host']      = config['sync']['host']
+		@config['sync']['port']      = config['sync']['port']
+		@config['sync']['user']      = config['sync']['user']
+		@config['sync']['password']  = config['sync']['password']
+		@config['sync']['path']      = config['sync']['path']
+		@config['sync']['last_sync'] = @config['sync']['last_sync'].nil? ? 0 : @config['sync']['last_sync']
+	end
+
+	# Add a new item
+	# @args: item -> Object MPW::Item
+	def add(item)
+		if not item.instance_of?(Item)
+			raise I18n.t('error.bad_class')
+		elsif item.empty?
+			raise I18n.t('error.add.empty')
+		else
+			@data.push(item)
 		end
-	
-		# Search in some csv data
-		# @args: id -> the id item
-		# @rtrn: a row with the result of the search
-		def search_by_id(id)
-			@data.each do |item|
-				return item if item.id == id
+	end
+
+	# Search in some csv data
+	# @args: options -> a hash with paramaters
+	# @rtrn: a list with the resultat of the search
+	def list(options={})
+		result = []
+
+		search   = options[:search].to_s.downcase
+		group    = options[:group].to_s.downcase
+
+		@data.each do |item|
+			next if item.empty?
+			next if not group.empty?    and not group.eql?(item.group.downcase)
+			
+			name    = item.name.to_s.downcase
+			host    = item.host.to_s.downcase
+			comment = item.comment.to_s.downcase
+
+			if not name =~ /^.*#{search}.*$/ and not host =~ /^.*#{search}.*$/ and not comment =~ /^.*#{search}.*$/ 
+				next
 			end
-	
-			return nil
+
+			result.push(item)
 		end
+
+		return result
+	end
+
+	# Search in some csv data
+	# @args: id -> the id item
+	# @rtrn: a row with the result of the search
+	def search_by_id(id)
+		@data.each do |item|
+			return item if item.id == id
+		end
+
+		return nil
+	end
+
+	# Export to yaml
+	# @args: file -> file where you export the data
+	def export(file)
+		data = {}
+		@data.each do |item|
+			data.merge!(item.id => {'id'        => item.id,
+			                        'name'      => item.name,
+			                        'group'     => item.group,
+			                        'host'      => item.host,
+			                        'protocol'  => item.protocol,
+			                        'user'      => item.user,
+			                        'password'  => get_password(item.id),
+			                        'port'      => item.port,
+			                        'comment'   => item.comment,
+			                        'last_edit' => item.last_edit,
+			                        'created'   => item.created,
+			                       }
+			            )
+		end
+
+		File.open(file, 'w') {|f| f << data.to_yaml}
+	rescue Exception => e 
+		raise "#{I18n.t('error.export', file: file)}\n#{e}"
+	end
+
+	# Import to yaml
+	# @args: file -> path to file import
+	def import(file)
+		YAML::load_file(file).each_value do |row| 
+			item = Item.new(name:     row['name'], 
+			                group:    row['group'],
+			                host:     row['host'],
+			                protocol: row['protocol'],
+			                user:     row['user'],
+			                port:     row['port'],
+			                comment:  row['comment'],
+			               )
+
+			raise 'Item is empty' if item.empty?
+
+			@data.push(item)
+			set_password(item.id, row['password'])
+		end
+	rescue Exception => e 
+		raise "#{I18n.t('error.import', file: file)}\n#{e}"
+	end
+
+	# Get last sync
+	def get_last_sync
+		return @config['sync']['last_sync'].to_i
+	rescue
+		return 0
+	end
+
+	# Sync data with remote file
+	def sync
+		return if @config.empty? or @config['sync'].nil?
 		
-		# Export to csv
-		# @args: file -> file where you export the data
-		#        type -> udata type
-		# @rtrn: true if export work
-		def export(file, type=:yaml)
-			case type
-			when :csv
-				CSV.open(file, 'w', write_headers: true,
-									headers: ['name', 'group', 'protocol', 'host', 'user', 'password', 'port', 'comment']) do |csv|
-					@data.each do |item|
-						csv << [item.name, item.group, item.protocol, item.host, item.user, item.password, item.port, item.comment]
+		tmp_file  = "#{@wallet_file}.sync"
+		last_sync = @config['last_sync'].to_i
+
+		case @config['sync']['type']
+		when 'sftp', 'scp', 'ssh'
+			require "#{APP_ROOT}/../lib/mpw/sync/ssh.rb"
+			sync = SyncSSH.new(@config['sync'])
+		when 'ftp'
+			require 'mpw/sync/ftp'
+			sync = SyncFTP.new(@config['sync'])
+		else
+			raise I18n.t('error.sync.unknown_type')
+		end
+
+		sync.connect
+		sync.get(tmp_file)
+
+		remote = MPW.new(@key, tmp_file, @gpg_pass)
+		remote.read_data
+
+		File.unlink(tmp_file) if File.exist?(tmp_file)
+
+		return if remote.get_last_sync == get_last_sync
+
+		if not remote.to_s.empty?
+			@data.each do |item|
+				update = false
+
+				remote.list.each do |r|
+					next if item.id != r.id
+
+					# Update item
+					if item.last_edit < r.last_edit
+						item.update(name:      r.name,
+						            group:     r.group,
+						            host:      r.host,
+						            protocol:  r.protocol,
+						            user:      r.user,
+						            port:      r.port,
+						            comment:   r.comment
+						           )
+						set_password(item.id, remote.get_password(item.id))
 					end
+
+					r.delete
+					update = true
+
+					break
 				end
 
-			when :yaml
-				data = {}
-				@data.each do |item|
-					data.merge!(item.id => {'id'        => item.id,
-					                        'name'      => item.name,
-					                        'group'     => item.group,
-					                        'host'      => item.host,
-					                        'protocol'  => item.protocol,
-					                        'user'      => item.user,
-					                        'password'  => item.password,
-					                        'port'      => item.port,
-					                        'comment'   => item.comment,
-					                        'last_edit' => item.last_edit,
-					                        'created'   => item.created,
-					                       }
-					            )
+				# Remove an old item
+				if not update and item.last_sync.to_i < last_sync and item.last_edit < last_sync
+					item.delete
 				end
+			end
+		end
 
-				File.open(file, 'w') {|f| f << data.to_yaml}
+		# Add item
+		remote.list.each do |r|
+			next if r.last_edit <= last_sync
 
-			else
-				@error_msg = "#{I18n.t('error.export.unknown_type', type: type)}"
-				return false
-			end
+			item = Item.new(id:        r.id,
+			                name:      r.name,
+			                group:     r.group,
+			                host:      r.host,
+			                protocol:  r.protocol,
+			                user:      r.user,
+			                port:      r.port,
+			                comment:   r.comment,
+			                created:   r.created,
+			                last_edit: r.last_edit
+			               )
 
-			return true
-		rescue Exception => e 
-			@error_msg = "#{I18n.t('error.export.write', file: file)}\n#{e}"
-			return false
+			set_password(item.id, remote.get_password(item.id))
+			add(item)
 		end
-	
-		# Import to csv
-		# @args: file -> path to file import
-		#        type -> udata type
-		# @rtrn: true if the import work
-		def import(file, type=:yaml)
-			case type
-			when :csv
-				CSV.foreach(file, {headers: true}) do |row|
-					item = Item.new(name:     row['name'], 
-					                group:    row['group'],
-					                host:     row['host'],
-					                protocol: row['protocol'],
-					                user:     row['user'],
-					                password: row['password'],
-					                port:     row['port'],
-					                comment:  row['comment'],
-					               )
-
-					return false if item.empty?
-
-					@data.push(item)
-				end
 
-			when :yaml
-				YAML::load_file(file).each_value do |row| 
-					item = Item.new(name:     row['name'], 
-					                group:    row['group'],
-					                host:     row['host'],
-					                protocol: row['protocol'],
-					                user:     row['user'],
-					                password: row['password'],
-					                port:     row['port'],
-					                comment:  row['comment'],
-					               )
-
-					return false if item.empty?
-
-					@data.push(item)
-				end
+		remote = nil
 
-			else
-				@error_msg = "#{I18n.t('error.export.unknown_type', type: type)}"
-				return false
-			end
-	
-			return true
-		rescue Exception => e 
-			@error_msg = "#{I18n.t('error.import.read', file: file)}\n#{e}"
-			return false
+		@data.each do |item|
+			item.set_last_sync
 		end
-	
-		# Return a preview import 
-		# @args: file -> path to file import
-		# @rtrn: a hash with the items to import, if there is an error return false
-		def import_preview(file, type=:yaml)
-			data = []
-
-			case type
-			when :csv
-				CSV.foreach(file, {headers: true}) do |row|
-					item = Item.new(name:     row['name'], 
-					                group:    row['group'],
-					                host:     row['host'],
-					                protocol: row['protocol'],
-					                user:     row['user'],
-					                password: row['password'],
-					                port:     row['port'],
-					                comment:  row['comment'],
-					               )
-
-					return false if item.empty?
-
-					data.push(item)
-				end
 
-			when :yaml
-				YAML::load_file(file).each_value do |row| 
-					item = Item.new(name:     row['name'], 
-					                group:    row['group'],
-					                host:     row['host'],
-					                protocol: row['protocol'],
-					                user:     row['user'],
-					                password: row['password'],
-					                port:     row['port'],
-					                comment:  row['comment'],
-					               )
-
-					return false if item.empty?
-
-					data.push(item)
-				end
+		@config['sync']['last_sync'] = Time.now.to_i
 
-			else
-				@error_msg = "#{I18n.t('error.export.unknown_type', type: type)}"
-				return false
-			end
-	
-			return data
-		rescue Exception => e 
-			@error_msg = "#{I18n.t('error.import.read', file: file)}\n#{e}"
-			return false
+		write_data
+		sync.update(@wallet_file)
+	rescue Exception => e
+		File.unlink(tmp_file) if File.exist?(tmp_file)
+
+		raise "#{I18n.t('error.sync.general')}\n#{e}"
+	end
+
+	# Generate a random password
+	# @args: length -> the length password
+	# @rtrn: a random string
+	def self.password(length=8)
+		if length.to_i <= 0
+			length = 8
+		else
+			length = length.to_i
 		end
-	
-		# Generate a random password
-		# @args: length -> the length password
-		# @rtrn: a random string
-		def self.password(length=8)
-			if length.to_i <= 0
-				length = 8
-			else
-				length = length.to_i
-			end
-	
-			result = ''
-			while length > 62 do
-				result << ([*('A'..'Z'),*('a'..'z'),*('0'..'9')]).sample(62).join
-				length -= 62
-			end
-			result << ([*('A'..'Z'),*('a'..'z'),*('0'..'9')]).sample(length).join
-	
-			return result
+
+		result = ''
+		while length > 62 do
+			result << ([*('A'..'Z'),*('a'..'z'),*('0'..'9')]).sample(62).join
+			length -= 62
+		end
+		result << ([*('A'..'Z'),*('a'..'z'),*('0'..'9')]).sample(length).join
+
+		return result
+	end
+
+	# Decrypt a gpg file
+	# @args: data -> string to decrypt
+	private
+	def decrypt(data)
+		crypto = GPGME::Crypto.new(armor: true)
+		
+		return crypto.decrypt(data, password: @gpg_pass).read.force_encoding('utf-8')
+	rescue Exception => e 
+		raise "#{I18n.t('error.gpg_file.decrypt')}\n#{e}"
+	end
+
+	# Encrypt a file
+	# args: data -> string to encrypt
+	private
+	def encrypt(data)
+		recipients = []
+		crypto     = GPGME::Crypto.new(armor: true, always_trust: true)
+
+		@keys.each_key do |key|
+			recipients.push(key)
 		end
 
+		recipients.push(@key) if not recipients.index(@key).nil?
+
+		return crypto.encrypt(data, recipients: recipients).read
+	rescue Exception => e 
+		raise "#{I18n.t('error.gpg_file.encrypt')}\n#{e}"
 	end
+
+end
 end