Refactor ronin/support/encoding/base64 to not use the Base64 library

lib/ronin/support/encoding/base64.rb

@@ -16,8 +16,6 @@
 # along with ronin-support.  If not, see <https://www.gnu.org/licenses/>.
 #
 
-require 'base64'
-
 module Ronin
   module Support
     class Encoding < ::Encoding
@@ -48,9 +46,9 @@ module Base64
         #
         def self.encode(data, mode: nil)
           case mode
-          when :strict   then ::Base64.strict_encode64(data)
-          when :url_safe then ::Base64.urlsafe_encode64(data)
-          when nil       then ::Base64.encode64(data)
+          when :strict   then strict_encode64(data)
+          when :url_safe then urlsafe_encode64(data)
+          when nil       then encode64(data)
           else
             raise(ArgumentError,"Base64 mode must be either :string, :url_safe, or nil: #{mode.inspect}")
           end
@@ -70,13 +68,100 @@ def self.encode(data, mode: nil)
         #
         def self.decode(data, mode: nil)
           case mode
-          when :strict   then ::Base64.strict_decode64(data)
-          when :url_safe then ::Base64.urlsafe_decode64(data)
-          when nil       then ::Base64.decode64(data)
+          when :strict   then strict_decode64(data)
+          when :url_safe then urlsafe_decode64(data)
+          when nil       then decode64(data)
           else
             raise(ArgumentError,"Base64 mode must be either :string, :url_safe, or nil: #{mode.inspect}")
           end
         end
+
+        #
+        # Base64 encodes the given data.
+        #
+        # @param [String] data
+        #   The data to Base64 encode.
+        #
+        # @return [String]
+        #   The Base64 encoded data.
+        #
+        def self.encode64(data)
+          [data].pack("m")
+        end
+
+        #
+        # Base64 decodes the given data.
+        #
+        # @param [String] data
+        #   The Base64 data to decode.
+        #
+        # @return [String]
+        #   The decoded data.
+        #
+        def self.decode64(data)
+          data.unpack1("m")
+        end
+
+        #
+        # Base64 strict encodes the given data.
+        #
+        # @param [String] data
+        #   The data to Base64 encode.
+        #
+        # @return [String]
+        #   The Base64 strict encoded data.
+        #
+        def self.strict_encode64(data)
+          [data].pack("m0")
+        end
+
+        #
+        # Base64 strict decodes the given data.
+        #
+        # @param [String] data
+        #   The Base64 data to decode.
+        #
+        # @return [String]
+        #   The strict decoded data.
+        #
+        def self.strict_decode64(data)
+          data.unpack1("m0")
+        end
+
+        #
+        # Base64 url-safe encodes the given data.
+        #
+        # @param [String] data
+        #   The data to Base64 encode.
+        #
+        # @return [String]
+        #   The Base64 url-safe encoded data.
+        #
+        def self.urlsafe_encode64(data, padding: true)
+          str = strict_encode64(data)
+          str.chomp!("==") or str.chomp!("=") unless padding
+          str.tr!("+/", "-_")
+          str
+        end
+
+        #
+        # Base64 url-safe decodes the given data.
+        #
+        # @param [String] data
+        #   The Base64 data to decode.
+        #
+        # @return [String]
+        #   The url-safe decoded data.
+        #
+        def self.urlsafe_decode64(data)
+          if !data.end_with?("=") && data.length % 4 != 0
+            data = data.ljust((str.length + 3) & ~3, "=")
+            data.tr!("-_", "+/")
+          else
+            data = data.tr("-_", "+/")
+          end
+          strict_decode64(data)
+        end
       end
     end
   end

spec/encoding/base64/core_ext/string_spec.rb

@@ -13,15 +13,15 @@
     subject { "hello" }
 
     it "must Base64 encode the String" do
-      expect(subject.base64_encode).to eq(Base64.encode64(subject))
+      expect(subject.base64_encode).to eq(Ronin::Support::Encoding::Base64.encode64(subject))
     end
 
     context "when given the mode: keyword of :strict" do
       subject { 'A' * 256 }
 
       it "must strict encode the String" do
         expect(subject.base64_encode(mode: :strict)).to eq(
-          Base64.strict_encode64(subject)
+          Ronin::Support::Encoding::Base64.strict_encode64(subject)
         )
       end
     end
@@ -31,7 +31,7 @@
 
       it "must URL-safe encode the String" do
         expect(subject.base64_encode(mode: :url_safe)).to eq(
-          Base64.strict_encode64(subject)
+          Ronin::Support::Encoding::Base64.strict_encode64(subject)
         )
       end
     end
@@ -49,15 +49,15 @@
 
   describe "#base64_decode" do
     let(:data)    { "hello" }
-    let(:subject) { Base64.encode64(data) }
+    let(:subject) { Ronin::Support::Encoding::Base64.encode64(data) }
 
     it "must Base64 decode the given data" do
       expect(subject.base64_decode).to eq(data)
     end
 
     context "when given the mode: keyword of :strict" do
       let(:data)    { 'A' * 256 }
-      let(:subject) { Base64.strict_encode64(data) }
+      let(:subject) { Ronin::Support::Encoding::Base64.strict_encode64(data) }
 
       it "must strict decode the given data" do
         expect(subject.base64_decode(mode: :strict)).to eq(data)
@@ -66,7 +66,7 @@
 
     context "when given the mode: keyword of :url_safe" do
       let(:data)    { 'A' * 256 }
-      let(:subject) { Base64.urlsafe_encode64(data) }
+      let(:subject) { Ronin::Support::Encoding::Base64.urlsafe_encode64(data) }
 
       it "must URL-safe decode the given data" do
         expect(subject.base64_decode(mode: :url_safe)).to eq(data)

spec/encoding/base64_spec.rb

@@ -6,15 +6,15 @@
     let(:data) { "hello" }
 
     it "must Base64 encode the given data" do
-      expect(subject.encode(data)).to eq(Base64.encode64(data))
+      expect(subject.encode(data)).to eq(described_class.encode64(data))
     end
 
     context "when given the mode: keyword of :strict" do
       let(:data) { 'A' * 256 }
 
       it "must strict encode the given data" do
         expect(subject.encode(data, mode: :strict)).to eq(
-          Base64.strict_encode64(data)
+          described_class.strict_encode64(data)
         )
       end
     end
@@ -24,7 +24,7 @@
 
       it "must URL-safe encode the given data" do
         expect(subject.encode(data, mode: :url_safe)).to eq(
-          Base64.strict_encode64(data)
+          described_class.strict_encode64(data)
         )
       end
     end
@@ -42,15 +42,15 @@
 
   describe ".decode" do
     let(:data)         { "hello" }
-    let(:encoded_data) { Base64.encode64(data) }
+    let(:encoded_data) { described_class.encode64(data) }
 
     it "must Base64 decode the given data" do
       expect(subject.decode(encoded_data)).to eq(data)
     end
 
     context "when given the mode: keyword of :strict" do
       let(:data)         { 'A' * 256 }
-      let(:encoded_data) { Base64.strict_encode64(data) }
+      let(:encoded_data) { described_class.strict_encode64(data) }
 
       it "must strict decode the given data" do
         expect(subject.decode(encoded_data, mode: :strict)).to eq(data)
@@ -59,7 +59,7 @@
 
     context "when given the mode: keyword of :url_safe" do
       let(:data)         { 'A' * 256 }
-      let(:encoded_data) { Base64.urlsafe_encode64(data) }
+      let(:encoded_data) { described_class.urlsafe_encode64(data) }
 
       it "must URL-safe decode the given data" do
         expect(subject.decode(encoded_data, mode: :url_safe)).to eq(data)
@@ -76,4 +76,58 @@
       end
     end
   end
+
+  describe "#encode64" do
+    let(:data) { "AAAA" }
+    let(:encoded_data) { "QUFBQQ==\n" }
+
+    it "must encode the given data" do
+      expect(subject.encode64(data)).to eq(encoded_data)
+    end
+  end
+
+  describe "#strict_encode64" do
+    let(:data) { "AAAA" }
+    let(:encoded_data) { "QUFBQQ==" }
+
+    it "must strict encode the given data" do
+      expect(subject.strict_encode64(data)).to eq(encoded_data)
+    end
+  end
+
+  describe "#urlsafe_encode64" do
+    let(:data) { "AAAA" }
+    let(:encoded_data) { "QUFBQQ==" }
+
+    it "must URL-safe encode the given data" do
+      expect(subject.urlsafe_encode64(data)).to eq(encoded_data)
+    end
+  end
+
+  describe "#decode64" do
+    let(:data) { "QUFBQQ==\n" }
+    let(:decoded_data) { "AAAA" }
+
+    it "must decode the given data" do
+      expect(subject.decode64(data)).to eq(decoded_data)
+    end
+  end
+
+  describe "#strict_decode64" do
+    let(:data) { "QUFBQQ==" }
+    let(:decoded_data) { "AAAA" }
+
+    it "must strict decode the given data" do
+      expect(subject.strict_decode64(data)).to eq(decoded_data)
+    end
+  end
+
+  describe "#urlsafe_decode64" do
+    let(:data) { "QUFBQQ==" }
+    let(:decoded_data) { "AAAA" }
+
+    it "must URL-safe decode the given data" do
+      expect(subject.urlsafe_decode64(data)).to eq(decoded_data)
+    end
+  end
 end