phoenix_password 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f6cab1c152e70c4126e91a443edc384f3dcada4
-  data.tar.gz: 30feab2c21937a24f8d5ec69954864457676ead0
+  metadata.gz: 62fc2d5162961619812bc5c72b25b055c27c5540
+  data.tar.gz: 68c1882f3687bdfe8163cedcbccfec2a0afe27ef
 SHA512:
-  metadata.gz: db2b7725199dff32c9423d2d0009e88ca2621ea34143dd14155425cc8b1e9a4b74f75ae51b2f494f1659bdde5c57919c1a11d531004b632cef2c1c07df036ea2
-  data.tar.gz: 661f6981b00046b2f913766c8a1add26d68dc8c14f6db19eb8e77d0cbfe166b284785778805d73aeb74061ddea389c370351e319a4100ec866618acbe4454bf9
+  metadata.gz: '0588f9c5423c5b85cac84ee81621c93e5812f9641b7ea801f1473ed014eb3d4060a071fa30bb63e5df431c59668846e7a722d70919c5d47e2adfc0f71e1cea6e'
+  data.tar.gz: 4ccba59a3c45a9a8cd79dc58d1b9243b1bfafab37b39d1f3d2116987497180a0867dd86ba3a0fdcf2d29d1274a3a8b688cba13fa0c96847807a48095e8fb9be2

data/README.md

@@ -99,6 +99,17 @@ When set to repeat only reappearing character combinations are generated xzx
 When set to single only single character appearance combinations are generated xzy.
 
 
+```ruby
+:cap_limit=>1 or more (optional)
+
+```
+When used it ensures that each combination generated will contain only the amount of capital letters specified.
+
+**Note that file size and combination estimates  when using match_limit may not be accurate**
+
+
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/phoenix_password.rb

@@ -36,31 +36,51 @@ class PhoenixPassword
 
 			combinations=[]
 			if data[:extra_chars].nil? || data[:iteration] == 0
-				combinations.<<(combination.join())
-				if combination.last != characters.first
-					reverse_comb=combination.reverse
-					combinations.<<(reverse_comb.join())
-					reverse_comb.pop
-					reverse_comb=reverse_comb.join()
-					characters.each do |char|
-						next if char == characters.first
+				
+			 combinations.<<(combination.join())
+			 if combination.last != characters.first
+				reverse_comb=combination.reverse
+				combinations.<<(reverse_comb.join())
+				reverse_comb.pop
+				reverse_compare=reverse_comb
+				reverse_comb=reverse_comb.join()
+		        check_match= matching_check({:combination=>reverse_comb,:match_limit=>data[:match_limit],:cap_limit=>data[:cap_limit]})
+				characters.each do |char|
+					next if char == characters.first
+					if  data[:type] == "unique"
 						combinations.<<("%s%s"%[reverse_comb,char])
+					else
+						if check_match
+							combinations.<<("%s%s"%[reverse_comb,char])	
+						else							
+						  combinations.<<("%s%s"%[reverse_comb,char]) if char == reverse_compare.last
+						end
 					end
 				end
+			 end
+
 			else
  			  	combinations << combination.join() if combination.include?(characters.last)
-				if combination.last != characters.first
+		     if combination.last != characters.first
 					reverse_comb=combination.reverse 
 				    reverse_comb.pop
+				    reverse_compare=reverse_comb
 				    reverse_comb=reverse_comb.join
-					if reverse_comb.include?(characters.last)
-						characters.each do |char|
-						  combinations.<<("%s%s"%[reverse_comb,char])
+				if reverse_comb.include?(characters.last)
+		        	check_match= matching_check({:combination=>reverse_comb,:match_limit=>data[:match_limit],:cap_limit=>data[:cap_limit]}) if data[:type] == 'matching'
+					characters.each do |char|
+						if  data[:type] == "unique"
+							combinations.<<("%s%s"%[reverse_comb,char])
+						elsif check_match
+							combinations.<<("%s%s"%[reverse_comb,char])
+						else							
+						    combinations.<<("%s%s"%[reverse_comb,char]) if char == reverse_compare.last
 						end
-					else						
-						  combinations.<<("%s%s"%[reverse_comb,characters.last])
 					end
+				else						
+				  combinations.<<("%s%s"%[reverse_comb,characters.last])				
 				end
+			 end
 			end
 
 			yield(combinations) if combinations.length >= 1
@@ -114,7 +134,7 @@ class PhoenixPassword
 		begin
 		 generate_combinations(data) do |combinations|
 		  combinations.each do |combination|
-			if matching_check({:combination=>combination,:match_limit=>info[:match_limit]})
+			if matching_check({:combination=>combination,:match_limit=>info[:match_limit],:cap_limit=>info[:cap_limit]})
 				 if info[:piped]
 						puts combination
 				 else
@@ -135,6 +155,10 @@ class PhoenixPassword
 
 	def self.matching_check(info)
 		combination=info[:combination]
+		if info[:cap_limit]
+		  caps=combination.scan(/[A-Z]/)
+		  return false if caps.length == 0 || caps.length > info[:cap_limit]
+		end
 		i=0
 		x=0
 		u=0
@@ -157,8 +181,8 @@ class PhoenixPassword
 		return true
 	end
 
-	def self.unique_combinations(info)	 
-	   data={:characters=>info[:characters],:cmb_length=>info[:cmb_length],:type=>info[:type]}
+	def self.unique_combinations(info)
+	   data={:characters=>info[:characters],:cmb_length=>info[:cmb_length],:type=>info[:type],:uniqueness_type=>info[:uniqueness_type]}
 	   unless info[:extra_chars].nil?
 	   		data[:extra_chars]=info[:extra_chars]
 	   end
@@ -180,7 +204,7 @@ class PhoenixPassword
 	   begin
 		generate_combinations(data) do |combinations|
 		  combinations.each do |combination|
-			 unique_chars=check_uniqueness(combination,uniqueness)
+			 unique_chars=check_uniqueness(combination,uniqueness,info[:cap_limit])
 		 	 if unique_chars == combination.length-1
 				if info[:piped]
 				  puts combination 
@@ -204,7 +228,11 @@ class PhoenixPassword
 		return unique_combs
 	end
 
-	def self.check_uniqueness(combination,uniqueness)
+	def self.check_uniqueness(combination,uniqueness,cap_limit)
+	    if cap_limit
+		  caps=combination.scan(/[A-Z]/)
+		  return 0 if caps.length == 0 || caps.length > cap_limit
+		end
 		i=0
 		unique_chars=0
 		chars_check=[]
@@ -287,7 +315,6 @@ class PhoenixPassword
 			old_matches=old_base*post_matches
 			base=data[:characters].length+data[:extra_chars].length
 		end
-		possible_combinations=base**data[:cmb_length]
 		previous_matches=0
 		i=0
 
@@ -304,6 +331,7 @@ class PhoenixPassword
 		matches=base*previous_matches
 
 		if data[:type]=='unique'
+		    possible_combinations=base**data[:cmb_length]
 			if data[:uniqueness_type].nil?
 			   return (possible_combinations-matches)-(old_combinations-old_matches) if !data[:extra_chars].nil?
 			   return possible_combinations-matches
@@ -378,6 +406,214 @@ class PhoenixPassword
 		end
 	end
 
+	def self.cap_limit_matching(data)
+		cap_data={}
+			total_chars=data[:characters].join()
+			caps_matched= total_chars.scan(/[A-Z]/)
+			cap_data[:characters]=[]
+			data[:characters].each do |char|
+				next if caps_matched.include?(char)
+				cap_data[:characters].push(char)
+			end
+			base=cap_data[:characters].length
+			cap_matches=0
+			case data[:cmb_length]
+			  when 3
+				cap_matches += base*2
+			  when 4
+				  	cap_matches+=get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1})*2
+				  	cap_matches+=(base**2)*2
+			  else
+			  	cap_matches+=get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1})*2			  	
+			  	cap_matches+=(get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-2})*base)*(data[:cmb_length]-2)
+			end
+
+		if !data[:extra_chars].nil?
+			all_chars=data[:characters]+data[:extra_chars]
+			new_cap_matches=cap_limit_matching({:cmb_length=>data[:cmb_length],:characters=>all_chars})
+			return	new_cap_matches-(cap_matches*caps_matched.length)
+		else
+  		  return cap_matches*caps_matched.length		
+		end
+
+	end
+
+	def self.cap_limit_matching_l(data)
+		cap_data={}		
+		total_chars=data[:characters].join()
+		caps_matched= total_chars.scan(/[A-Z]/)
+		cap_data[:characters]=[]
+		data[:characters].each do |char|
+			next if caps_matched.include?(char)
+			cap_data[:characters].push(char)
+		end
+		base=cap_data[:characters].length
+		cap_matches=0
+		no_limit_matches=get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1})
+		case data[:cmb_length]
+		  when 3
+			cap_matches += base*2
+		  when 4
+			 cap_matches+=(no_limit_matches-get_above_limit({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1,:match_limit=>data[:match_limit]}))*2
+			 cap_matches+=(base**2)*2
+		  else
+
+		  	#XXA
+		  	cap_matches+=(no_limit_matches-get_above_limit({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1,:match_limit=>data[:match_limit]}))*2
+		  	no_limit_matches=get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-2})
+		  	#XAX
+		  	cap_matches+=((no_limit_matches-get_above_limit({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-2,:match_limit=>data[:match_limit]}))*base)*2
+		  	x=data[:cmb_length]-4
+		  	if x == 1
+				cap_matches +=get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-2})*base
+		  	elsif x == 2
+				grt_half_no_limit=get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-3})
+				grt_half_limit =grt_half_no_limit-get_above_limit({:characters=>cap_data[:characters],:match_limit=>data[:match_limit],:cmb_length=>data[:cmb_length]-3})
+				cap_matches +=(((grt_half_limit*base**2)+(base*base**3))-(grt_half_no_limit*base))*2
+		  	else
+		  		#AXX
+				i=3
+				p=0
+				l=0
+				begin
+					grt_half=get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-(3+l)})
+					grt_half_limit =grt_half-get_above_limit({:characters=>cap_data[:characters],:match_limit=>data[:match_limit],:cmb_length=>data[:cmb_length]-(3+l)})
+					if i == 3
+						if data[:cmb_length] <=8							
+								cap_matches +=(((grt_half_limit*base**2)+(base*base**(x+1)))-(grt_half*base))*2
+							else
+							cap_matches +=((grt_half_limit*((base**2)-base))+(base*base**(x+1)))*2
+
+						end 
+					else
+						lsr_half=get_combinations({:characters=>cap_data[:characters],:cmb_length=>i-1})
+						lsr_half_limit=lsr_half-get_above_limit(:characters=>cap_data[:characters],:match_limit=>data[:match_limit],:cmb_length=>i-1)
+						cap_matches +=(((grt_half_limit*(base**(2+p)))+(lsr_half_limit*base**(x+1-p)))-(grt_half*lsr_half))*2
+						  	
+					end
+					p+=1
+					l+=1
+					i+=1
+				end while i < (data[:cmb_length]/2.0).ceil
+
+
+
+				if x%2 == 1
+					no_limit_matches=get_combinations({:characters=>cap_data[:characters],:cmb_length=>x-(p-1)})
+					half_point=(((no_limit_matches-get_above_limit({:characters=>cap_data[:characters],:cmb_length=>x-(p-1),:match_limit=>data[:match_limit]})))*base**(x-(p-1)))*2
+					if data[:cmb_length] == 7
+ 				    	cap_matches+=half_point-((half_point/base))
+					else
+						half_no_limit=get_combinations(:characters=>cap_data[:characters],:cmb_length=>x-1)							
+						half_no_limit_b=get_combinations(:characters=>cap_data[:characters],:cmb_length=>x-2)
+
+						if data[:cmb_length] >= 9 && data[:extra_chars].nil?
+							puts "!------Approximately less  than------!"
+						end
+						cap_matches+=half_point-((half_point/base))
+						
+					end
+
+				else
+					no_limit_matches_a=get_combinations({:characters=>cap_data[:characters],:cmb_length=>(x-l)+1})
+					greater_half=(((no_limit_matches_a-get_above_limit({:characters=>cap_data[:characters],:cmb_length=>(x-l)+1,:match_limit=>data[:match_limit]})))*base**(x-l))
+					no_limit_matches_b=get_combinations({:characters=>cap_data[:characters],:cmb_length=>(x-l)})
+					lesser_half=(((no_limit_matches_b-get_above_limit({:characters=>cap_data[:characters],:cmb_length=>(x-l),:match_limit=>data[:match_limit]})))*base**(x-l+1))
+					
+					if data[:cmb_length] == 10 && data[:extra_chars].nil?
+						puts "!------Approximately less  than------!"
+					elsif data[:cmb_length] == 12 && data[:extra_chars].nil?
+						puts "!------Approximately more  than------!"
+					end
+					cap_matches+=((greater_half+lesser_half)-((no_limit_matches_a*no_limit_matches_b)-(no_limit_matches_b*base)))*2
+				end
+
+		  	end
+			  
+		end
+
+		if (cap_data[:characters].length <= 2 || data[:cmb_length] >= 13) && data[:extra_chars].nil?
+			puts "!!!----Inaccurate information----!!!"
+		end
+
+		if !data[:extra_chars].nil?
+			all_chars=data[:characters]+data[:extra_chars]
+			new_cap_matches=cap_limit_matching_l({:cmb_length=>data[:cmb_length],:characters=>all_chars,:match_limit=>data[:match_limit]})
+			return	new_cap_matches-(cap_matches*caps_matched.length)
+		else
+    		return cap_matches*caps_matched.length		
+		end
+	end
+
+	def self.unique_cap_limit(data)
+		cap_data={}
+		total_chars=data[:characters].join()
+		caps_matched= total_chars.scan(/[A-Z]/)
+		cap_data[:characters]=[]
+		data[:characters].each do |char|
+			next if caps_matched.include?(char)
+			cap_data[:characters].push(char)
+		end
+		base=cap_data[:characters].length
+		unique_cap_limit=0
+		if data[:uniqueness_type] == 'single'
+		  if data[:cmb_length] == 3
+			  unique_cap_limit=(((base**2)-(base))*3)
+		  else
+			  previous_single=get_single_combs(:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1,:type=>"unique")
+			  unique_cap_limit=previous_single*data[:cmb_length]
+	   	  end
+		else
+			case data[:cmb_length]
+				when 3
+					if data[:uniqueness_type].nil?
+						unique_cap_limit=((base**2)*3)-(base*2)
+					else
+						unique_cap_limit=((base**2)*3)-(base*2)-(((base**2)-(base))*3)
+					end
+				when 4
+					previous_unique=get_combinations(:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1,:type=>"unique")
+				   if data[:uniqueness_type].nil?
+						unique_cap_limit=(previous_unique*2)+((((base**2)-base)*base)*2)
+				   else
+						previous_single=get_single_combs(:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1,:type=>"unique")
+						unique_cap_limit=(previous_unique*2)+((((base**2)-base)*base)*2)-(previous_single*data[:cmb_length])
+				   end					
+				else
+					previous_unique_a=get_combinations(:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1,:type=>"unique")
+					previous_unique_b=get_combinations(:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-2,:type=>"unique")
+					if data[:uniqueness_type].nil?
+						unique_cap_limit=(previous_unique_a*2)+((previous_unique_b*base)*(data[:cmb_length]-2))
+					else
+						previous_single=get_single_combs(:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1,:type=>"unique")
+						unique_cap_limit=(previous_unique_a*2)+((previous_unique_b*base)*(data[:cmb_length]-2))-(previous_single*data[:cmb_length])
+					end
+			end
+		end
+			
+		if !data[:extra_chars].nil?
+			all_chars=data[:characters]+data[:extra_chars]
+			new_unique_cap_limit=unique_cap_limit({:cmb_length=>data[:cmb_length],:characters=>all_chars,:uniqueness_type=>data[:uniqueness_type]})
+			return	new_unique_cap_limit-(unique_cap_limit*caps_matched.length)
+		else
+			return unique_cap_limit*caps_matched.length
+		end
+
+	end
+
+	def self.cap_limit_combs(data,x=0)
+		if data[:type] == "matching"
+			if !data[:match_limit].nil?
+			   puts "Combinations and file size may vary when using match_limit" if x == 0
+			   cap_limit_matching_l(data)
+			else
+			   cap_limit_matching(data)			
+			end
+		else
+			unique_cap_limit(data)			
+		end
+	end
+
 	def self.get_size(data)
 		bytes=data[:combinations]*(data[:cmb_length]+1)
 		kilo_bytes=bytes/1000.0
@@ -394,7 +630,7 @@ class PhoenixPassword
 			end
 			return_sizes[key]=value if value > 0.01 && key != :bytes
 		end
-		yield(return_sizes)
+		yield(return_sizes) if block_given?
 		return return_sizes
 	end
 
@@ -426,22 +662,35 @@ class PhoenixPassword
 		if data[:file_append].nil? || !data[:file_append]
 			if data[:write_cmbs].nil?
 				poss_combs=get_combinations(data)
-				unless data[:match_limit].nil?
-					poss_combs -= get_above_limit(data)
+				if !data[:match_limit].nil?
+					if !data[:cap_limit].nil?
+						poss_combs=cap_limit_combs(data)
+					else
+				  		poss_combs -= get_above_limit(data)
+					end
+				elsif !data[:cap_limit].nil?
+			      poss_combs=cap_limit_combs(data)
 				end
-				matching_file_size=get_size({:cmb_length=>data[:cmb_length],:combinations=>poss_combs}){}
+				matching_file_size=get_size({:cmb_length=>data[:cmb_length],:combinations=>poss_combs})
 			else
 				poss_combs=0
 				matching_file_size={:bytes=>0,:kilo=>0,:mega=>0,:giga=>0,:tera=>0,:peta=>0}
 				dataB=data.clone
+				cmb_count=data[:write_cmbs].length if !data[:cap_limit].nil?
 				data[:write_cmbs].each do |n|
 					dataB[:cmb_length]=n
+				  if data[:cap_limit].nil?
 					current_combs=get_combinations(dataB)
 					poss_combs +=current_combs
 				    unless data[:match_limit].nil?
 					     poss_combs -= get_above_limit(dataB)
 					     current_combs -= get_above_limit(dataB)
 				    end
+				  else
+				  	 current_combs=cap_limit_combs(dataB,cmb_count)
+				  	 cmb_count -= 1
+				  	 poss_combs +=cap_limit_combs(dataB,cmb_count)
+				  end
 					get_size({:cmb_length=>n,:combinations=>current_combs})do |sizes|
 						sizes.each do |key,value|
 							matching_file_size[key] +=value

data/lib/phoenix_password/version.rb

@@ -1,3 +1,3 @@
 class PhoenixPassword
-  VERSION = "0.1.6"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phoenix_password
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - Spiros Avlonitis
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-02 00:00:00.000000000 Z
+date: 2017-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler