132 lines
4.5 KiB
Ruby
132 lines
4.5 KiB
Ruby
def generate_xml(entity, remote_user, user)
|
|
DiasporaFederation::Salmon::EncryptedSlap.generate_xml(
|
|
remote_user.diaspora_handle,
|
|
OpenSSL::PKey::RSA.new(remote_user.encryption_key),
|
|
entity,
|
|
OpenSSL::PKey::RSA.new(user.encryption_key)
|
|
)
|
|
end
|
|
|
|
def generate_status_message
|
|
@entity = FactoryGirl.build(
|
|
:status_message_entity,
|
|
diaspora_id: @remote_user.diaspora_handle,
|
|
public: false
|
|
)
|
|
|
|
generate_xml(@entity, @remote_user, @user)
|
|
end
|
|
|
|
def generate_forged_status_message
|
|
substitute_wrong_key(@remote_user, 1)
|
|
generate_status_message
|
|
end
|
|
|
|
def mock_private_key_for_user(user)
|
|
expect(DiasporaFederation.callbacks).to receive(:trigger)
|
|
.with(:fetch_private_key_by_diaspora_id, user.person.diaspora_handle)
|
|
.once
|
|
.and_return(user.encryption_key)
|
|
end
|
|
|
|
def retraction_mock_callbacks(entity, sender)
|
|
return unless [
|
|
DiasporaFederation::Entities::SignedRetraction,
|
|
DiasporaFederation::Entities::RelayableRetraction
|
|
].include?(entity.class)
|
|
|
|
mock_private_key_for_user(sender)
|
|
|
|
allow(DiasporaFederation.callbacks).to receive(:trigger)
|
|
.with(
|
|
:fetch_entity_author_id_by_guid,
|
|
entity.target_type,
|
|
entity.target_guid
|
|
)
|
|
.once
|
|
.and_return(sender.encryption_key)
|
|
end
|
|
|
|
def generate_retraction(entity_name, target_object, sender=@remote_user)
|
|
@entity = FactoryGirl.build(
|
|
entity_name,
|
|
diaspora_id: sender.diaspora_handle,
|
|
target_guid: target_object.guid,
|
|
target_type: target_object.class.to_s
|
|
)
|
|
|
|
retraction_mock_callbacks(@entity, sender)
|
|
|
|
generate_xml(@entity, sender, @user)
|
|
end
|
|
|
|
def generate_forged_retraction(entity_name, target_object, sender=@remote_user)
|
|
times = 1
|
|
if %i(signed_retraction_entity relayable_retraction_entity).include?(entity_name)
|
|
times += 2
|
|
end
|
|
|
|
substitute_wrong_key(sender, times)
|
|
generate_retraction(entity_name, target_object, sender)
|
|
end
|
|
|
|
def generate_relayable_local_parent(entity_name)
|
|
@entity = FactoryGirl.build(
|
|
entity_name,
|
|
parent_guid: @local_message.guid,
|
|
diaspora_id: @remote_user.person.diaspora_handle
|
|
)
|
|
|
|
mock_private_key_for_user(@remote_user)
|
|
|
|
expect(DiasporaFederation.callbacks).to receive(:trigger)
|
|
.with(:fetch_author_private_key_by_entity_guid, "Post", kind_of(String))
|
|
.and_return(nil)
|
|
generate_xml(@entity, @remote_user, @user)
|
|
end
|
|
|
|
def generate_relayable_remote_parent(entity_name)
|
|
@entity = FactoryGirl.build(
|
|
entity_name,
|
|
parent_guid: @remote_message.guid,
|
|
diaspora_id: @remote_user2.person.diaspora_handle
|
|
)
|
|
|
|
mock_private_key_for_user(@remote_user2)
|
|
|
|
expect(DiasporaFederation.callbacks).to receive(:trigger)
|
|
.with(
|
|
:fetch_author_private_key_by_entity_guid,
|
|
"Post",
|
|
@remote_message.guid
|
|
)
|
|
.once
|
|
.and_return(@remote_user.encryption_key)
|
|
generate_xml(@entity, @remote_user, @user)
|
|
end
|
|
|
|
def substitute_wrong_key(user, times_number)
|
|
expect(user).to receive(:encryption_key).exactly(times_number).times.and_return(
|
|
OpenSSL::PKey::RSA.new(1024)
|
|
)
|
|
end
|
|
|
|
# Checks when a remote pod wants to send us a relayable without having a key for declared diaspora ID
|
|
def generate_relayable_local_parent_wrong_author_key(entity_name)
|
|
substitute_wrong_key(@remote_user, 2)
|
|
generate_relayable_local_parent(entity_name)
|
|
end
|
|
|
|
# Checks when a remote pod B wants to send us a relayable with authorship from a remote pod C user
|
|
# without having correct signature from him.
|
|
def generate_relayable_remote_parent_wrong_author_key(entity_name)
|
|
substitute_wrong_key(@remote_user2, 1)
|
|
generate_relayable_remote_parent(entity_name)
|
|
end
|
|
|
|
# Checks when a remote pod C wants to send us a relayable from its user, but bypassing the pod B where
|
|
# remote status came from.
|
|
def generate_relayable_remote_parent_wrong_parent_key(entity_name)
|
|
substitute_wrong_key(@remote_user, 2)
|
|
generate_relayable_remote_parent(entity_name)
|
|
end
|