melos 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85db7b48fd128cb7bb205689c66ae391964b16228d21d3cd7b1e2f941d332a31
-  data.tar.gz: d324b915daf2f12f9226f690e9e2a577ab9a34e7235d9088e181e46ffb7d563c
+  metadata.gz: 2e29fdc55c828d8bdd2bfd2c2375835dd9e3bf04020bf04291915cd0de2af83b
+  data.tar.gz: 467c07c1eaff33a00fb9261a579e52a6fed0fd0d15c9cc1f83b15c99b7a98aa4
 SHA512:
-  metadata.gz: b0c1e2b24240f32c119d10c09f16ccebe2c3442ec6422df9d85d8669dba4b058d331bc22d8eff36aafda228bd86c0d9d75a8f83d4fce8e2ad9727537ee54593d
-  data.tar.gz: 3fe93f19e872cb70e313714008065026e41ddc0374029a5d0f50b9f843d24f4b394cae6974205098fbfdde36cbdcd979ddd8c4bf73ce721181b1c602877e1a22
+  metadata.gz: 9ace207ff77ecfa0e220fcc94366e2e07cc41b68424bc6840254c4f5c8c3c8ec1d2e1c94bebde387454a2f12c0054ec00031e41bd77b015c0f5a74c085f4ca46
+  data.tar.gz: 3741b2507119fa79de960ab719f37e447b15521b6387a144a7a70ebeeb5e4a57e604e226847b159854e56a796fa2f3468f548c16d64932fcdd6468ef5b4731b3

data/README.md

@@ -1,5 +1,24 @@
 # Melos
 
+
+[![Gem Version](https://badge.fury.io/rb/melos.svg)](https://badge.fury.io/rb/melos)
+
 a [Messaging Layer Security Protocol](https://www.rfc-editor.org/rfc/rfc9420.html) implementation in Ruby
 
 (yes, [an mls gem](https://rubygems.org/gems/mls) happened to exist since 2014, so...)
+
+## Note on implementation status
+
+As of version 0.0.1, this implements:
+
+- Serialization/deserialization of messages
+- Key Schedule
+- Encryption Secret Tree
+- Applying Add/Update/Remove/PreSharedKey/GroupContextExtensions Proposal types
+- (thus passes all test vectors in [mls-implementations/test-vectors.md](https://github.com/mlswg/mls-implementations/blob/main/test-vectors.md))
+
+but lacks the following (not a complete list):
+
+- Creating messages
+- Applying ReInit/ExternalInit proposals
+- Validation (rejecting error cases)

data/lib/melos/struct/base.rb

@@ -1,19 +1,13 @@
 module Melos::Struct; end
 
 class Melos::Struct::Base
-  def initialize(buf)
-    context, _ = deserialize(buf)
+  def initialize(stream)
+    stream = StringIO.new(stream) if stream.is_a?(String)
+    context = deserialize(stream)
     set_instance_vars(context)
     self
   end
 
-  def self.new_and_rest(buf)
-    instance = self.allocate
-    context, buf = instance.send(:deserialize, buf)
-    instance.send(:set_instance_vars, context)
-    [instance, buf]
-  end
-
   def raw
     buf = ''
     self.class::STRUCT.each do |elem|
@@ -29,45 +23,35 @@ class Melos::Struct::Base
     buf
   end
 
-  def self.vecs(buf)
-    value, buf = Melos::Vec.parse_vec(buf)
-    array = []
-    while (value.bytesize > 0)
-      current_instance, value = Melos::Vec.parse_vec(value)
-      array << current_instance
-    end
-    [array, buf]
-  end
-
   # context here takes a hash
-  # returns [value, rest_of_buffer]
+  # returns the deserialized value
   # value could return nil, which means predicate was not applicable
   # predicate takes the context and returns true or false
-  def deserialize_select_elem_with_context(buf, context, predicate, type, type_param)
+  def deserialize_select_elem_with_context(stream, context, predicate, type, type_param)
     if predicate.(context)
-      deserialize_elem(buf, type, type_param)
+      deserialize_elem(stream, type, type_param)
     else
-      [nil, buf]
+      nil
     end
   end
 
   private
-  def deserialize(buf)
+  def deserialize(stream)
     context = []
     self.class::STRUCT.each do |elem|
       case elem[1]
       when :select
-        value, buf = deserialize_select_elem_with_context(buf, context.to_h, elem[2], elem[3], elem[4])
+        value = deserialize_select_elem_with_context(stream, context.to_h, elem[2], elem[3], elem[4])
         context << [elem[0], value]
       when :framed_content_auth_data
-        value, buf = Melos::Struct::FramedContentAuthData.new_and_rest_with_content_type(buf, context.to_h[:content].content_type)
+        value = Melos::Struct::FramedContentAuthData.new_with_content_type(stream, context.to_h[:content].content_type)
         context << [elem[0], value]
       else
-        value, buf = deserialize_elem(buf, elem[1], elem[2])
+        value = deserialize_elem(stream, elem[1], elem[2])
         context << [elem[0], value]
       end
     end
-    [context, buf]
+    context
   end
 
   def set_instance_vars(context)
@@ -76,57 +60,51 @@ class Melos::Struct::Base
     end
   end
 
-  def deserialize_elem(buf, type, type_param)
+  def deserialize_elem(stream, type, type_param)
     case type
     when :uint8
-      value = buf.byteslice(0, 1).unpack1('C')
-      buf = buf.byteslice(1..)
+      value = stream.read(1).unpack1('C')
     when :uint16
-      value = buf.byteslice(0, 2).unpack1('S>')
-      buf = buf.byteslice(2..)
+      value = stream.read(2).unpack1('S>')
     when :uint32
-      value = buf.byteslice(0, 4).unpack1('L>')
-      buf = buf.byteslice(4..)
+      value = stream.read(4).unpack1('L>')
     when :uint64
-      value = buf.byteslice(0, 8).unpack1('Q>')
-      buf = buf.byteslice(8..)
+      value = stream.read(8).unpack1('Q>')
     when :vec
-      value, buf = Melos::Vec.parse_vec(buf)
+      value = Melos::Vec.parse_stringio(stream)
     when :vec_of_type
-      vec, buf = Melos::Vec.parse_vec(buf)
+      data = Melos::Vec.parse_stringio(stream)
       value = []
-      while (vec.bytesize > 0)
-        current_instance, vec = deserialize_elem(vec, type_param, nil)
+      data_stream = StringIO.new(data)
+      while (!data_stream.eof?)
+        current_instance = deserialize_elem(data_stream, type_param, nil)
         value << current_instance
       end
     when :class
-      value, buf = type_param.send(:new_and_rest, buf)
+      value = type_param.send(:new, stream)
     when :classes
-      # prefix, length = buf.get_prefix_and_length
-      # puts "#{prefix}, #{length}"
-      vec, buf = Melos::Vec.parse_vec(buf)
+      data = Melos::Vec.parse_stringio(stream)
       value = []
-      while (vec.bytesize > 0)
-        current_instance, vec = type_param.send(:new_and_rest, vec)
+      data_stream = StringIO.new(data)
+      while (!data_stream.eof?)
+        current_instance = type_param.send(:new, data_stream)
         value << current_instance
       end
     when :optional
-      presence = buf.byteslice(0, 1).unpack1('C')
-      buf = buf.byteslice(1..)
+      presence = stream.read(1).unpack1('C')
       case presence
       when 0
         value = nil
       when 1
         # as of RFC 9420, optional always takes a class
-        value, buf = type_param.send(:new_and_rest, buf)
+        value = type_param.send(:new, stream)
       end
     when :opaque
-      value = buf.byteslice(0, type_param.to_i)
-      buf = buf.byteslice((type_param.to_i)..)
+      value = stream.read(type_param.to_i)
     when :padding
-      value = buf
+      value = stream.read
     end
-    [value, buf]
+    value
   end
 
   # take a name and type

data/lib/melos/struct/ratchet_tree.rb

@@ -6,26 +6,26 @@ require_relative '../tree'
 require_relative '../crypto'
 
 module Melos::Struct::RatchetTree
-  def self.parse(vec)
-    array, _ = new_and_rest(vec)
-    array
+  def self.parse(stream)
+    stream = StringIO.new(stream) if stream.is_a?(String)
+    new(stream)
   end
 
-  def self.new_and_rest(vec)
+  def self.new(stream)
     array = []
-    buf, rest = Melos::Vec.parse_vec(vec)
-    while buf.bytesize > 0
-      presence = buf.byteslice(0, 1).unpack1('C')
-      buf = buf.byteslice(1..)
+    data = Melos::Vec.parse_stringio(stream)
+    data_stream = StringIO.new(data)
+    while !data_stream.eof?
+      presence = data_stream.read(1).unpack1('C')
       case presence
       when 0
         array << nil
       when 1
-        node, buf = Melos::Struct::Node.new_and_rest(buf)
+        node = Melos::Struct::Node.new(data_stream)
         array << node
       end
     end
-    [array, rest]
+    array
   end
 
   def self.raw(array)

data/lib/melos/struct/structs.rb

@@ -638,18 +638,18 @@ class Melos::Struct::FramedContentAuthData < Melos::Struct::Base
   ]
 
   # initialize from stream
-  def self.new_and_rest_with_content_type(buf, content_type)
+  def self.new_with_content_type(stream, content_type)
     instance = self.allocate
-    context, buf = instance.send(:deserialize, buf)
+    context = instance.send(:deserialize, stream)
     # custom part based on instance variable
     if content_type == Melos::Constants::ContentType::COMMIT # commit
       # read MAC(opaque <V>) confirmation_tag
-      value, buf = Melos::Vec.parse_vec(buf)
+      value = Melos::Vec.parse_stringio(stream)
       context << [:confirmation_tag, value]
     end
     context << [:content_type, content_type]
     instance.send(:set_instance_vars, context)
-    [instance, buf]
+    instance
   end
 
   def raw
@@ -887,7 +887,8 @@ class Melos::Struct::PrivateMessage < Melos::Struct::Base
     sender_data = decrypt_sender_data(suite, sender_data_secret)
     key, nonce, _ = Melos::SecretTree.ratchet_until_and_get(suite, content_type, secret_tree, sender_data.leaf_index, sender_data.generation)
     new_nonce = self.class.apply_nonce_reuse_guard(nonce, sender_data.reuse_guard)
-    pmc, _ = Melos::Struct::PrivateMessageContent.new_and_rest_with_content_type(Melos::Crypto.aead_decrypt(suite, key, new_nonce, private_content_aad, ciphertext), content_type)
+    stream = StringIO.new(Melos::Crypto.aead_decrypt(suite, key, new_nonce, private_content_aad, ciphertext))
+    pmc = Melos::Struct::PrivateMessageContent.new_with_content_type(stream, content_type)
 
     fc = Melos::Struct::FramedContent.create(
       group_id: group_id,
@@ -945,27 +946,27 @@ class Melos::Struct::PrivateMessageContent < Melos::Struct::Base
   # bytes -> struct: decode the content and auth field, rest is padding
   # struct -> bytes: encode content and auth field, add set amount of padding (zero bytes)
 
-  def self.new_and_rest_with_content_type(buf, content_type)
+  def self.new_with_content_type(stream, content_type)
     instance = self.allocate
     context = []
     # deserialize application_data/proposal/commit
     case content_type
     when Melos::Constants::ContentType::APPLICATION
-      value, buf = Melos::Vec.parse_vec(buf)
+      value = Melos::Vec.parse_stringio(stream)
       context << [:application_data, value]
     when Melos::Constants::ContentType::PROPOSAL
-      value, buf = Melos::Struct::Proposal.new_and_rest(buf)
+      value = Melos::Struct::Proposal.new(stream)
       context << [:proposal, value]
     when Melos::Constants::ContentType::COMMIT
-      value, buf = Melos::Struct::Commit.new_and_rest(buf)
+      value = Melos::Struct::Commit.new(stream)
       context << [:commit, value]
     end
-    fcad, buf = Melos::Struct::FramedContentAuthData.new_and_rest_with_content_type(buf, content_type)
+    fcad = Melos::Struct::FramedContentAuthData.new_with_content_type(stream, content_type)
     context << [:auth, fcad]
     # assume rest is padding
-    context << [:padding, buf]
+    context << [:padding, stream.read()]
     instance.send(:set_instance_vars, context)
-    [instance, '']
+    instance
   end
 
   def content

data/lib/melos/vec.rb

@@ -40,13 +40,6 @@ module Melos::Vec
     write_varint(str.bytesize) + str
   end
 
-  def get_prefix_and_length(str)
-    prefix = str[0].ord >> 6
-    length = read_varint(str)
-
-    [prefix, length]
-  end
-
   def parse_vec(vec_as_string)
     prefix = vec_as_string[0].ord >> 6
     length = read_varint(vec_as_string)
@@ -67,23 +60,33 @@ module Melos::Vec
     [str, rest]
   end
 
-  def get_first_vec(vec_as_string)
-    prefix = vec[0].ord >> 6
-    length = read_varint(vec_as_string)
+  def parse_stringio(vec_as_stringio)
+    prefix = prefix_from_stringio(vec_as_stringio)
+    length = length_from_stringio(vec_as_stringio)
     case prefix
-    when 0
-      first_vec = vec_as_string[0, 1 + length]
-      rest = vec_as_string[(1 + length)..]
-    when 1
-      first_vec = vec_as_string[0, 2 + length]
-      rest = vec_as_string[(2 + length)..]
-    when 2
-      first_vec = vec_as_string[0, 4 + length]
-      rest = vec_as_string[(4 + length)..]
+    when 0..2
+      vec_as_stringio.pos = (vec_as_stringio.pos + (2 ** prefix))
+      str = vec_as_stringio.read(length)
     else
       raise ArgumentError.new('invalid header')
     end
 
-    [first_vec, rest]
+    str
+  end
+
+  private
+
+  def prefix_from_stringio(stringio)
+    pos = stringio.pos
+    prefix_ = stringio.getbyte >> 6
+    stringio.seek(pos)
+    prefix_
+  end
+
+  def length_from_stringio(stringio)
+    pos = stringio.pos
+    buf = stringio.read(4)
+    stringio.seek(pos)
+    read_varint(buf)
   end
 end

data/lib/melos/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Melos
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: melos
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Ryo Kajiwara
 bindir: exe
 cert_chain: []
-date: 2025-04-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hpke
@@ -50,7 +50,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -104,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.5
+rubygems_version: 3.7.1
 specification_version: 4
 summary: Messaging Layer Security Protocol (RFC 9420) on Ruby
 test_files: []

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper