Критерий ненаблюдаемости уже включает в себя критерий несвязываемости. Если пойти от обратного и предположить ложность данного суждения (то-есть, отсутствие несвязываемости в ненаблюдаемости), тогда можно было бы при помощи несвязываемости определить существование субъектов информации и, тем самым, допустить нарушение ненаблюдаемости, что является противоречием для последнего.

Скрытыми сетями с теоретически доказуемой анонимностью принято считать замкнутые (полностью прослушиваемые) системы, в которых становится невозможным осуществление любых пассивных атак (в том числе и при существовании глобального наблюдателя) направленных на деанонимизацию отправителя и получателя с минимальными условностями по количеству узлов неподчинённых сговору. Говоря иначе, с точки зрения пассивного атакующего, апостериорные знания (полученные вследствие наблюдений) должны оставаться равными априорным (до наблюдений), тем самым сохраняя равновероятность деанонимизации по N-ому множеству субъектов сети.

Существует несколько видов анонимизации трафика между отправителем и получателем:

1. Система разграничивает абонентов информации. В такой концепции существует три возможных случая: 1) отправитель анонимен к получателю, но получатель известен отправителю; 2) отправитель известен получателю, но получатель анонимен к отправителю; 3) отправитель и получатель анонимны друг к другу. Примером являются 1) анонимный доступ к открытому Интернет ресурсу; 2) анонимное получение информации из ботнет системы со стороны сервера-координатора; 3) анонимный доступ к скрытому ресурсу в анонимной сети.

2. Система связывает абонентов информации. В такой концепции отправитель и получатель известны друг к другу. Системы построенные на данном пункте часто ограничены в своём применении, но, так или иначе, остаются способными представлять анонимность субъектов, в том числе и на уровне критерия ненаблюдаемости.

Второй пункт является наименее привлекательным со стороны любого представленного случая из первого пункта. Тем не менее, такое действие становится оправданным со стороны простоты программной реализации и простоты теоретической доказуемости.

Клиент-безопасные приложения или приложения базируемые на безопасной линии связи «клиент-клиент» представляют собой абстрагирование передаваемых / хранимых объектов от промежуточных субъектов, тем самым приводя мощность доверия |T| к своему теоретически минимально заданному значению. Частным случаем связи «клиент-клиент» становится сквозное (end-to-end или E2E) шифрование.

Мощность доверия — количество узлов, участвующих в хранении или передаче информации, представленной дли них в открытом описании. Иными словами, такие узлы способны читать, подменять и видоизменять информацию, т.к. для них она находится в предельно чистом, прозрачном, транспарентном состоянии. Чем больше мощность доверия, тем выше предполагаемый шанс компрометации отдельных узлов, а следовательно, и хранимой на них информации. Принято считать одним из узлов получателя. Таким образом, нулевая мощность доверия |T| = 0 будет возникать лишь в моменты отсутствия каких-либо связей и соединений. Если |T| = 1, это говорит о том, что связь защищена, иными словами, никто кроме отправителя и получателя информацией не владеют. Во всех других случаях |T| > 1, что говорит о групповой связи (то-есть, о существовании нескольких получателей), либо о промежуточных узлах, способных читать информацию в открытом виде.

Существует несколько видов одноранговых сетей, а именно:

1. Централизованная одноранговая архитектура. Представляет собой существование двух ролей - клиентов и ретрансляторов. Клиент в такой системе генерируют и принимают всю информацию. Ретрансляторы служат исключительно для перенаправления клиентской информации, не содержа в себе никакой дополнительной логики.

2. Децентрализованная одноранговая архитектура. Представляет собой "сращивание" воедино клиентов и ретрансляторов, в следствие чего каждый клиент теперь становится способным осуществлять перенаправления поступаемой ему клиентской информации извне.

3. Распределённая одноранговая архитектура. Подвид децентрализованной одноранговой архитектуры. Зародилась в следствии "коррозии" децентрализованных форм централизованными. Иными словами, в децентрализованных архитектурах существует проблема, когда клиенты начинают выбирать малое количество стабильных клиентов для последующей ретрансляции, тем самым приводят систему к неявному виду централизации. Распределённая одноранговая архитектура переводит качество соединений на их количество.

Выбор децентрализованной архитектуры взамен распределённой был вызван вследствии пятого (f2f сети) и шестого пунктов (абстрактные анонимные сети) определения мессенджера. Данные пункты с одной стороны ограничивают количество соединений, тем самым затрудняя выстраивание распределённой системы, с другой стороны централизация (даже в явном представлении) не будет нарушать анонимизацию трафика.

Каждый действующий субъект сети будет выстраивать связи с другими участниками, основываясь на субъективности к уровню доверия, устанавливая и редактируя белый список на своей стороне. Чтобы успешно подключиться к сети такого рода, субъекту необходимо стать доверенным узлом, то есть пользователем, которому кто-либо доверяет. Сложность исполнения атаки на подобную сеть будет сводиться также к сложности встраивания подчиняемых узлов, потому как каждый получатель информации, в конечном итоге, должен будет заранее устанавливать список возможных отправителей.

Среди анонимных сетей можно выявить класс систем с теоретически доказуемой анонимностью и максимально разграничивающим свойством, приводящим к наибольшему разрыву связей между объектом (как информации) и его субъектами (в лице отправителя и получателя) посредством выстраивания децентрализованных соединений между всеми участниками сети.

Из-за своей специфичной архитектуры передача информации может осуществляться в любой дуплексной среде вне зависимости от расположения и связей узлов, что полностью отрывает распространение объектов от своей сетевой архитектуры и переводит маршрутизацию в этап виртуального транслирования. Анонимные сети, с вышеописанными характеристиками, будут именоваться абстрактными.

За счёт данной "абстрактности" комбинации и вариации расположения и связей узлов между собой никак не влияют на уровень безопасности и анонимности конечных клиентов.

Предположим, что участник A хочет отправить информацию по сети так, чтобы {B, C} эту информацию получили, но не смогли узнать, кто действительно является отправителем. Иными словами, для B это может быть {A, C}, а для C это {A, B} с вероятностью 50/50. Все участники начинают согласовывать общий бит со своими соседями в момент времени T. Предположим, что участники {A, B} согласовали бит = 1, {B, C} = 1, {C, A} = 0.

Далее каждый участник сети XOR'ит (операция исключающее ИЛИ) биты со всех своих соединений: A = 1 xor 0 = 1; B = 1 xor 1 = 0; C = 0 xor 1 = 1. Данные результаты обмениваются по всей сети и XOR'ятся каждым её участником: 0 xor 1 xor 1 = 0. Это говорит о том, что участник A передал бит информации = 0. Чтобы субъект A мог передать бит = 1, ему необходимо добавить операцию НЕ в своём вычислении, то есть A = НЕ(1 xor 0) = 0. В итоге, все вычисления прийдут к такому результату: 0 xor 0 xor 1 = 1. Таким образом, становится возможным передать 1 бит информации полностью анонимно (конечно же со стороны определения теоретически доказуемой анонимности).

Предположим, что один из участников, либо B, либо C захочет деанонимизировать либо оставшуются сеть {A, C}, либо {B, C} соответственно (то есть узнать, кто является отправителем информации). Тогда ему потребуется узнать согласованный секрет со стороны другой линии связи, что является сложной задачей (если конечно не был произведён сговор нескольких участников). Таким образом, атака со стороны внутреннего пассивного наблюдателя становится безрезультатной. Со стороны внешнего глобального наблюдателя такая же ситуация, потому как он видит лишь переадресации зашифрованных битов (потому как используется безопасный канал связи) в один момент времени T всеми участниками сети.

Bitmessage - клиент-безопасное приложение, мессенджер. Сам по себе не представляет анонимность пользователей, но его уникальной особенностью является маршрутизация отправляемых данных.

1. Информация шифруется (в качестве упрощения) публичным ключом получателя (на самом деле используется гибридная схема шифрования).

2. Зашифрованная информация отправляется всем участникам сети (на практике конечно же текущим соединеням).

3. Каждый пользователь, при получении шифрованной информации извне, пытается её расшифровать своим приватным ключом.

4. Если пользователь смог расшифровать информацию, значит он является истинным её получателем.

5. Если пользователь не смог расшифровать информацию, тогда он продолжает её распространять дальше по сети, отправляя таковую всем своим соединениям.

Уникальность такого подхода заключается в отстутствии маршрутизирующей информации, кроме как понимания факта {получатель / не получатель}. Тем не менее, Bitmessage не является анонимным мессенджером, потому что в нём отсутствует какая-либо запутывающая маршрутизация. Иными словами относительно легко определить кто является отправителем и кто получателем, при условии, если получатель всегда будет генерировать ответ на запрос инициатора.

Маршрутизация в анонимных сетях не является примитивной и ставит эффективность распространения объектов опциональным параметром (низкие / высокие задержки), потому как главной целью становится создание запутывающего алгоритма (анонимизатора), который приводил бы к трудоёмкости анализа истинного пути от точки отправления до точки назначения.

Производительность, эффективность «чистой» маршрутизации теряется, заменяясь особенностью алгоритма. В таких условиях, сами скрытые сети становятся медленными и сложными в применении (в том числе и с низкими задержками), что также частично или полноценно отодвигает их прикладное и повседневное использование в настоящее время.

// Принимает в качестве аргументов публичный ключ получателя
// и полезную нагрузку.
// Полезная нагрузка - это Header=uint64 и Body=[]byte.
func (client *sClient) Encrypt(receiver asymmetric.IPubKey, pl payload.IPayload) (message.IMessage, error) {
	// Для безопасности необходимо, чтобы ключи абонентов имели одинаковый размер
    // во избежание малых ключей со стороны отправителя или получателя
    if receiver.Size() != client.PubKey().Size() {
		return nil, fmt.Errorf("size of public keys sender and receiver not equal")
	}

    // fVoidMsgSize - размер пустого пакета без полезной нагрузки 
    // (здесь учитываются размеры публичного ключа, хеша, подписи и т.п. метаданных)
    // В качестве шифрованной информации принимаются байты, потому необходимо
    // их кодирование. 16-кодировка идеальное простое кодирование для точного
	// для точного понимания будущего размера информации.
    // Нам нужно учитывать реальный размер информации исходя из
    // закодированного размера, поэтому мы уменьшаем размер вдвое.
    var (
		maxMsgSize = client.Settings().GetMessageSize() >> 1 // limit of bytes without hex
		resultSize = uint64(client.fVoidMsgSize) + uint64(len(pl.ToBytes()))
	)

    // Если всё же полученный размер оказывается больше лимита,
    // тогда ничего не шифруем. В таком контексте надо подумать
    // о том, как разделить сообщение (если таковое больше положенного).
	if resultSize > maxMsgSize {
		return nil, fmt.Errorf(
			"limit of message size without hex encoding = %d bytes < current payload size with additional padding = %d bytes",
			maxMsgSize,
			resultSize,
		)
	}

    // Передаём в функцию шифрования размер дополнения до блока.
	return client.encryptWithParams(
		receiver,
		pl,
		client.Settings().GetWorkSize(),
		maxMsgSize-resultSize,
	), nil
}

// Тут используются первые три действия на инициирующей стороне
// криптографического протокола.
func (client *sClient) encryptWithParams(receiver asymmetric.IPubKey, pl payload.IPayload, workSize, addPadd uint64) message.IMessage {
	var (
		rand    = random.NewStdPRNG()
		salt    = rand.Bytes(symmetric.CAESKeySize)
		session = rand.Bytes(symmetric.CAESKeySize)
	)

    // Конкатенируем полезную нагрузку с дополнением случайных байт.
	// Образуем новую полезную нагрузку, в заголовке которой указан
    // размер настоящей информации.
    payloadBytes := pl.ToBytes()
	doublePayload := payload.NewPayload(
		uint64(len(payloadBytes)),
		bytes.Join(
			[][]byte{
				payloadBytes,
				rand.Bytes(addPadd),
			},
			[]byte{},
		),
	)

    // Хешируем всю основную информацию.
    // Соль необходима для образования разных хешей.
	hash := hashing.NewSHA256Hasher(bytes.Join(
		[][]byte{
			salt,
			client.PubKey().Bytes(),
			receiver.Bytes(),
			doublePayload.ToBytes(),
		},
		[]byte{},
	)).Bytes()

    // Шифруем все необходимые данные сеансовым ключом.
    // Сеансовый ключ шифруем публичным ключом.
	cipher := symmetric.NewAESCipher(session)
	bProof := encoding.Uint64ToBytes(puzzle.NewPoWPuzzle(workSize).Proof(hash))
	return &message.SMessage{
		FHead: message.SHeadMessage{
			FSender:  encoding.HexEncode(cipher.Encrypt(client.PubKey().Bytes())),
			FSession: encoding.HexEncode(receiver.Encrypt(session)),
			FSalt:    encoding.HexEncode(cipher.Encrypt(salt)),
		},
		FBody: message.SBodyMessage{
			FPayload: encoding.HexEncode(cipher.Encrypt(doublePayload.ToBytes())),
			FHash:    encoding.HexEncode(hash),
			FSign:    encoding.HexEncode(cipher.Encrypt(client.PrivKey().Sign(hash))),
			FProof:   encoding.HexEncode(bProof[:]),
		},
	}
}

// Последние пять действий на принимающей стороне
// криптографического протокола.
func (client *sClient) Decrypt(msg message.IMessage) (asymmetric.IPubKey, payload.IPayload, error) {
	// Проверяем корректность принятого msg.
    if msg == nil {
		return nil, nil, fmt.Errorf("msg is nil")
	}

	// Проверяем размер хеша.
	if len(msg.Body().Hash()) != hashing.CSHA256Size {
		return nil, nil, fmt.Errorf("msg hash != sha256 size")
	}

	// Проверяем совершённую работу.
	diff := client.Settings().GetWorkSize()
	puzzle := puzzle.NewPoWPuzzle(diff)
	if !puzzle.Verify(msg.Body().Hash(), msg.Body().Proof()) {
		return nil, nil, fmt.Errorf("invalid proof of msg")
	}

	// Пытаемся расшифровать сеансовый ключ.
	session := client.PrivKey().Decrypt(msg.Head().Session())
	if session == nil {
		return nil, nil, fmt.Errorf("failed decrypt session key")
	}

	// Расшифровываем публичный ключ.
	cipher := symmetric.NewAESCipher(session)
	publicBytes := cipher.Decrypt(msg.Head().Sender())
	if publicBytes == nil {
		return nil, nil, fmt.Errorf("failed decrypt public key")
	}

	// Декодируем публичный ключ из байт и проверяем его размер.
	pubKey := asymmetric.LoadRSAPubKey(publicBytes)
	if pubKey == nil {
		return nil, nil, fmt.Errorf("failed load public key")
	}
	if pubKey.Size() != client.PubKey().Size() {
		return nil, nil, fmt.Errorf("invalid public key size")
	}

	// Расшифровываем и декодируем полезную нагрузку.
	doublePayloadBytes := cipher.Decrypt(msg.Body().Payload().ToBytes())
	if doublePayloadBytes == nil {
		return nil, nil, fmt.Errorf("failed decrypt double payload")
	}
	doublePayload := payload.LoadPayload(doublePayloadBytes)
	if doublePayload == nil {
		return nil, nil, fmt.Errorf("failed load double payload")
	}

    // Расшифровываем соль.
	salt := cipher.Decrypt(msg.Head().Salt())
	if salt == nil {
		return nil, nil, fmt.Errorf("failed decrypt salt")
	}

	// Проверяем корректность принятого хеша с полученным.
	check := hashing.NewSHA256Hasher(bytes.Join(
		[][]byte{
			salt,
			publicBytes,
			client.PubKey().Bytes(),
			doublePayload.ToBytes(),
		},
		[]byte{},
	)).Bytes()
	if !bytes.Equal(check, msg.Body().Hash()) {
		return nil, nil, fmt.Errorf("invalid msg hash")
	}

	// Расшифровываем подпись и проверяем её корректность.
	sign := cipher.Decrypt(msg.Body().Sign())
	if sign == nil {
		return nil, nil, fmt.Errorf("failed decrypt sign")
	}
	if !pubKey.Verify(msg.Body().Hash(), sign) {
		return nil, nil, fmt.Errorf("invalid msg sign")
	}

	// Удаляем случайные (добавочные) байты из полезной нагрузки.
	mustLen := doublePayload.Head()
	if mustLen > uint64(len(doublePayload.Body())) {
		return nil, nil, fmt.Errorf("invalid size of payload")
	}
	pld := payload.LoadPayload(doublePayload.Body()[:mustLen])
	if pld == nil {
		return nil, nil, fmt.Errorf("invalid load payload")
	}

	// Возвращаем публичный ключ отправителя и 
    // отправленную полезную нагрузку.
	return pubKey, pld, nil
}

Message: 'hello, world!';
Sender's public key: 'Pub(go-peer/rsa){30818902818100CC228131C038583D6345EEFF79D5A6AD56EB3992CD1933655EC1830F66AAF8F9CAC7283F63C0E17D2C69DED57FF28F18A7C2E3905DD28466F57F3FA0F53F0EF724D109D0B120CD9CF49DAF4841EE22F86EBD6A498DF91518C52C78583E7D61509C5E3790694650A8A1891B3BA1F4FCFCF3945C93D16625432185E1677F3F0BD50203010001}';
Encrypted message: '{"head":{"salt":"86232459f3a46d6f8bb2d45d1d39898d047066b92606ff125d5c09b484c56558518c2c6b02067667939879859ba06e5533174c4cd357031a257c2f8f34631119","session":"c32d0e7e1b731f802de593104e5b062cfbda16437f89ede1c0b33a75fb008bd2b7b6b526f43116ccd5f8191ceae222d00adb2fd18ae4521c77f37da9199dad763b8a159caef9b5965527ede8b4ec4f43e16388845f41d07418b5abf3af22cad25cb546c21a1275f72ba1e5a6a7dd51139ad2ec61b07f4fe1bb0ddb108a1d51de","sender":"2b66ea223b48ae813b62e8a50eb059839f7b7f661ab67c9cebed54fe62a701a341b7bce736f9c6e29fae8d6596eea819ae00c48012c4586a3c31048085d5325db90f8c87794be38ad6b8fdc81cb2f983ead4fb57e5e231a41e740d6540c1f3f0e2012282892a31e9b8b106caa92f969a7d136edaf7cb744549d31792a260a7d6ea34805f15fc35978784f431ccd4a030b1f3b43ddd2d3fe681053c9584596f13"},"body":{"payload":"2cc55c74ecbd7fa0f75e2ce97678cd86e7920a8c919e063e43525216e18c53cf8918b0a18c3b93d57607ac1ec9e8e4f43f6df12d31bf15db56202ab63fad8e1d898a7bf9e9add90cef4d84e7e2c2cc07ac13ee823efdc4397c5c539f8ee1e32b37e851399f7f683a58b7a64e3873c6c84b9738dbab3512d05ba55e96e133926a69e6af68d8c29123802058e75db1726d164b245b1afbb4d2bdb11884f837f5a642d72260a2f660d794a2ebbc044a74662676e5b20b3ae24c32c0074d330fb55b895bd08dddbd1b04cf88d13a9fbc062312d859156f1a36967cd4f01f8c794b7844ab61c7e66ea83bb0f25595c78750131434fc024869e85eb3eb8e51fde56fa8d49df5ab41c41197712c1b38af8f31c4063626e1326e129e1ac1cb53570eb820fc2d0b6dceff3f622f88921f64405f5dbefb2452652902ed1bc211495f19a5cabe1c71cc3334ae8290feaec9018e00074ce7298ff8fc09f815eb839f2f95ce78d8f1e7dc4be785de62b616b3e7061288b07b2729f5813a3382f1ca0a5f8821436a36a94b2447d86a6d2356c61981aa095eb56df8cddae9cb6060a069d45301085a8bdea635a770f8c8a082560f40b9f4336b737acb4a14d8c5e52fef12927cc3026b01ec2d8e8d1a97c00574e078a15d89962974f659d0efe0a5dda20f36b9cd6e89a363da24fedfabe684519f3814f88b62de28f07eabb15c9711d3bc0e6f41b2508513dcc4c7a46063b0f6f29492cbe96ccf418edd0f7ab764d7517ca7feef6a33b380ac135457f139d7e00cdfe82b2a629f59fa57c7f4fc4695d0a014632b4a4ee825b4d9766aa1ba2c9377853235b18507d4a4b1990fcb691ab996624e1baa276724d2b4e67dbb294d4c54a26df90a8e8ed269e1f8cdd06f03c5677a98c22acbd8d97adc52d33cc4777600a3d553c6da1fed38f8648da4f52381369c950c39daa302c5c9232fe8838760b2fa7e21ccc218f57f7ee5c4dcaf6ef84d9db7ce5212194e87ef4acc61613b912d3d517415265a94b953c304a391221483f380e5819e903dccec1042330f04e88196f55a73ca5aaf942e36ae4cf693d42624293248d8b708b3ecc74376137f7a02275623","sign":"14438df8beb9f31a15fef4acbc644e5fd6401ca83a7e1154039564215b4682bac6cfc577c0174227c4400c419b212a028577d8db6747467e2ac386745d73c93a8ced28bc6feb14924bd9d44650ae9abd67940dde8c6aae390015e67cca723c0e574da75006d0b15f2b225d44696da834277f5c2a57a833f3fb04c46aede99d3174575b0013e7ee7baedfb2b00a20f8ea78848d8b49563fc32d24dfd8550436c2","hash":"d8873b265353fd564a95c6b122fa878579ba71243903704922036484a30c997b","proof":"0000000000001419"}}'

func (node *sNode) Broadcast(pld payload.IPayload) error {
	// Сохранение хеша в памяти, чтобы предотвратить бесконечное
    // зацикливание пакета в сетевой передачи
    hash := hashing.NewSHA256Hasher(pld.ToBytes()).Bytes()
	node.inMappingWithSet(hash)

    // Берём все текущие соединения и отправляем каждому
    // узлу копию полезной нагрузки.
	var err error
	for _, conn := range node.Connections() {
		e := conn.Write(pld)
		if e != nil {
			err = e
		}
	}

	return err
}

Это конечно же метод, а не функция со стороны терминологии языка Go. Тем не менее, термин "функция" употребляется здесь и далее как некое действие, как некая процедура без привязки конкретно к языку программирования.

func (conn *sConn) Write(pld payload.IPayload) error {
    // Ставим мьютекс, чтобы нельзя было записывать параллельно
    // два разных сообщения одному пользователю (коллизии).
	conn.fMutex.Lock()
	defer conn.fMutex.Unlock()

    // Упаковываем полезную нагрузку в сообщение (добавление HMAC)
	msg := message.NewMessage(pld, []byte(conn.fSettings.GetNetworkKey()))
	// Упаковываем сообщение в пакет (добавление размера пакета)
    packBytes := message.NewPackage(msg.ToBytes()).ToBytes()
	ptr := len(packBytes)

    // Отправляем байты.
	for {
		n, err := conn.fSocket.Write(packBytes[:ptr])
		if err != nil {
			return err
		}

		ptr = ptr - n
        packBytes = packBytes[:ptr]

		if ptr == 0 {
			break
		}
	}

	return nil
}

func (conn *sConn) Request(pld payload.IPayload) (payload.IPayload, error) {
	var (
		chPld    = make(chan payload.IPayload)
		timeWait = conn.fSettings.GetTimeWait()
	)

    // Отправляем полезную нагрузку.
	if err := conn.Write(pld); err != nil {
		return nil, err
	}
    // Запускаем горутину и пытаемся получить ответ.
	go readPayload(conn, chPld)

	select {
	case rpld := <-chPld:
        // Принятые данные могут оказаться невалидными.
		if rpld == nil {
			return nil, fmt.Errorf("failed: read payload")
		}
		return rpld, nil
	case <-time.After(timeWait):
		return nil, fmt.Errorf("failed: time out")
	}
}

func readPayload(conn *sConn, chPld chan payload.IPayload) {
	// Результатом функции станет вывод полезной нагрузки.
    var pld payload.IPayload
	defer func() {
		chPld <- pld
	}()

	// Пытаемся прочитать блок в 64бит указывающий
    // размер принимаемых данных.
	bufLen := make([]byte, encoding.CSizeUint64)
	length, err := conn.fSocket.Read(bufLen)
	if err != nil {
		return
	}
	if length != encoding.CSizeUint64 {
		return
	}

	// mustLen = Size[u64] in uint64
	arrLen := [encoding.CSizeUint64]byte{}
	copy(arrLen[:], bufLen)

    // Сравниваем принятый размер с допустимым лимитом.
	mustLen := encoding.BytesToUint64(arrLen)
	if mustLen > conn.fSettings.GetMessageSize() {
		return
	}

    // Читаем принимаемые байты.
	msgRaw := make([]byte, 0, mustLen)
	for {
		buffer := make([]byte, mustLen)
		n, err := conn.fSocket.Read(buffer)
		if err != nil {
			return
		}

		msgRaw = bytes.Join(
			[][]byte{
				msgRaw,
				buffer[:n],
			},
			[]byte{},
		)

		mustLen -= uint64(n)
		if mustLen == 0 {
			break
		}
	}

	// Пытаемся распаковать полученные байты в структуру сообщения.
	msg := message.LoadMessage(
		msgRaw,
		[]byte(conn.fSettings.GetNetworkKey()),
	)
	if msg == nil {
		return
	}

    // Выгружаем из сообщения полезную нагрузку.
	pld = msg.Payload()
}

В функции readPayload используется упоминание Message, тем не менее это иная структура, отличная от Message в криптографическом протоколе. Общее название было взято по причине косвенного, непрямого применения в момент передачи. Иными словами, в сетевых коммуникациях передаётся не сама полезная нагрузка, а полезная нагрузка запакованная в структуру Message. Ровно по такому же сценарию в криптографическом протоколе передаётся не сама полезная нагрузка, а структура Message, в которой содержится зашифрованная полезная нагрузка.

// Аргументы = узел принимающий информацию, соединение отправителя,
// отправленная полезная нагрузка.
type IHandlerF func(INode, conn.IConn, payload.IPayload)

func (node *sNode) Handle(head uint64, handle IHandlerF) INode {
	node.fMutex.Lock()
	defer node.fMutex.Unlock()

    // Устанавливаем функцию в качестве роутинга.
	node.fHandleRoutes[head] = handle
	return node
}

func (node *sNode) handleConn(address string, conn conn.IConn) {
	defer node.Disconnect(address)
	for {
        // Если сообщение принято валидное, тогда пытаемся
        // прочитать ещё одно сообщение от данного узла.
		ok := node.handleMessage(conn, conn.Read())
		if !ok {
            // Иначе обрываем с ним соединение.
			break
		}
	}
}

func (node *sNode) handleMessage(conn conn.IConn, pld payload.IPayload) bool {
	// Проверяем валидность принятой полезной нагрузки
	if pld == nil {
		return false
	}

	// Проверяем сообщение в маппинге (принимало ли оно ранее?)
	hash := hashing.NewSHA256Hasher(pld.ToBytes()).Bytes()
	if node.inMappingWithSet(hash) {
        // Это не есть ошибка, потому что отправитель
        // может получить пакет с разнородных узлов.
		return true
	}

	// Пытаемся получить функцию роута. Если таковой нет
    // или она неопределена, тогда считаем, что это ошибка
    // на стороне отправителя.
	f, ok := node.getFunction(pld.Head())
	if !ok || f == nil {
		return false
	}

    // Обрабатываем полезную нагрузку полученной функцией.
	f(node, conn, pld)
	return true
}

func (conn *sConn) Read() payload.IPayload {
	chPld := make(chan payload.IPayload)
	go readPayload(conn, chPld)
	return <-chPld
}

service '#1' got 'ping#0'
service '#2' got 'pong#1'
service '#1' got 'ping#2'
service '#2' got 'pong#3'
service '#1' got 'ping#4'
service '#2' got 'pong#5'
service '#1' got 'ping#6'
service '#2' got 'pong#7'
service '#1' got 'ping#8'
service '#2' got 'pong#9'
service '#1' got 'ping#10'
service '#2' got 'pong#11'
...

func (q *sQueue) Enqueue(msg message.IMessage) error {
	q.fMutex.Lock()
	defer q.fMutex.Unlock()

    // Если очередь переполнена -> выдавать ошибку.
	if uint64(len(q.fQueue)) >= q.Settings().GetCapacity() {
		return errors.New("queue already full, need wait and retry")
	}

    // Поместить сообщение в очередь.
	go func() {
		q.fMutex.Lock()
		defer q.fMutex.Unlock()

		q.fQueue <- msg
	}()

	return nil
}

func (q *sQueue) Dequeue() <-chan message.IMessage {
	time.Sleep(q.Settings().GetDuration())

	go func() {
		q.fMutex.Lock()
		defer q.fMutex.Unlock()

        // Если очередь неактивна -> остановить выполнение.
		if !q.fIsRun {
			return
		}

        // Если в очереди сообщений не существует сообщений,
        // тогда нужно взять ложное сообщение из пула сгенерированных.
		if len(q.fQueue) == 0 {
			q.fQueue <- (<-q.fMsgPull.fQueue)
		}
	}()

	return q.fQueue
}

type IHandlerF func(INode, asymmetric.IPubKey, payload.IPayload) []byte

func (node *sNode) Handle(head uint32, handle IHandlerF) INode {
	node.fMutex.Lock()
	defer node.fMutex.Unlock()

	node.fHandleRoutes[head] = handle
	return node
}

Стоит заметить, что head ранее был равен 64bit, теперь 32bit. Связано это с тем, что в "обёрточной" реализации нам также необходимо создать механизм получения ответа. Данная реализация более затруднительна, чем Request в сетевых коммуникациях, потому что неизвестно насколько далеко и в какой части сети находится конечный адресат сообщения. В такой парадигме информация будет проходить несколько узлов и ответ получателя может быть принят не тем узлом, через кого первоначально отправлялось сообщение.

Поэтому здесь 64bit разбивается на две составляющие по 32bit в виде конкатенации. Левая половина отвечает за уникальный идентификатор связи между отправителем и получателем для правильного валидирования принимаемой информации и перенаправления таковой на функцию Request в качестве ответа. Правая половина отвечает за функции редиректа, как и в сетевых коммуникациях 64bit.

// Единственная роут функция из сетевых коммуникаций.
// Представляет собой обёртку над множеством роут функций
// анонимных коммуникаций.
func (node *sNode) handleWrapper() network.IHandlerF {
	go func() {
		for {
            // Если из очереди пришло сообщение,
            // то его необходимо отправить в сеть.
			msg, ok := <-node.Queue().Dequeue()
			if !ok {
				break
			}
			node.broadcast(msg)
		}
	}()

	return func(nnode network.INode, _ conn.IConn, npld payload.IPayload) {
		// Получаем сообщение из сети. Проверяем. Распаковываем.
        msg := node.initialCheck(message.LoadMessage(npld.Body()))
		if msg == nil {
			return
		}

		// Как только получили новое сообщение из сети ->
        // отправляем его всем своим соединениям.
		nnode.Broadcast(npld)
		client := node.Queue().Client()

		// Пытаемся расшифровать полученное сообщение.
		sender, pld, err := client.Decrypt(msg)
		if err != nil {
			return
		}

		// Если сообщение отправлено нам, тогда необходимо
        // проверить отправителя информации. Находится ли
        // он в нашем белом списке?
		if !node.F2F().InList(sender) {
			return
		}

		// Проверяем существования сообщения в базе данных.
  		// Если существует, то далее ничего не предпринимаем.
        // Если отсутствует, тогда заносим в БД и смотрим далее.
        hash := []byte(fmt.Sprintf("_hash_%X", msg.Body().Hash()))
		if _, err := node.KeyValueDB().Get(hash); err == nil {
			return
		}
		node.KeyValueDB().Set(hash, []byte{})

		// Получаем связь от отправителя и пытаемся сопоставить
        // со своими связями из Request. Если таковая связь 
        // существует - это значит, что данный отправитель
        // является получателем сгенерировавшим ответ.
		head := pld.Head()
		action, ok := node.getAction(
			loadHead(head).Actions(),
		)
		if ok {
            // Перенаправляем полезную нагрузку на функцию 
            // Request.
			action <- pld.Body()
			return
		}

		// Берём по роуту функцию и смотрим её существование.
		f, ok := node.getRoute(
			loadHead(head).Routes(),
		)
		if !ok || f == nil {
			return
		}

        // Выполняем действие на основе роут функции.
		resp := f(node, sender, pld)
		// Если resp пустой - это не ошибка. Может существовать
        // логика, где не требуется ответа.
        if resp == nil {
			return
		}

        // Генерируем ответ.
		respMsg, err := client.Encrypt(
			sender,
			payload.NewPayload(head, resp),
		)
		if err != nil {
			panic(err)
		}

        // Заносим ответ в очередь.
		for i := uint64(0); i <= node.Settings().GetRetryEnqueue(); i++ {
			err := node.Queue().Enqueue(respMsg)
			if err != nil {
				time.Sleep(node.Queue().Settings().GetDuration())
				continue
			}
			break
		}
	}
}

// Представляет собой низкоуровневую функцию (конечно же относительно
// действий данного пакета) и находится вне выполнения очередей.
// Такое свойство необходимо для распространения маршрутизирующей 
// информации без замедления по очередям.
// Чтобы отправить пакет без необходимости ожидать ответа,
// нужно воспользоваться конструкцией node.Queue().Enqueue(msg).
func (node *sNode) broadcast(msg message.IMessage) error {
    // Перенаправляем сообщение всем своим соединениям. 
	return node.Network().Broadcast(payload.NewPayload(
		settings.CMaskNetwork,
		msg.ToBytes(),
	))
}

// Данная функция необходима для предотвращения редиректа
// невалидной информации при помощи функции Broadcast.
func (node *sNode) initialCheck(msg message.IMessage) message.IMessage {
	// Проверяем валидность сообщения.
    if msg == nil {
		return nil
	}

    // Проверяем размер хеша.
	if len(msg.Body().Hash()) != hashing.CSHA256Size {
		return nil
	}

    // Проверяем проделанную работу.
	diff := node.Queue().Client().Settings().GetWorkSize()
	puzzle := puzzle.NewPoWPuzzle(diff)
	if !puzzle.Verify(msg.Body().Hash(), msg.Body().Proof()) {
		return nil
	}

    // Внешне структура сообщения валидна.
	return msg
}

func (node *sNode) Request(recv asymmetric.IPubKey, pld payload_adapter.IPayload) ([]byte, error) {
	// Если количество соединений равно нулю, то и нет смысла
    // что-либо отправлять.
    if len(node.Network().Connections()) == 0 {
		return nil, errors.New("length of connections = 0")
	}

    // Создаём 32-битную связь с отправителем и
    // заносим редирект функцию в качестве запроса к ней.
	headAction := uint32(random.NewStdPRNG().Uint64())
	headRoutes := mustBeUint32(pld.Head())

    // Создаём новую полезную нагрузку на базе нового заголовка.
	newPld = payload.NewPayload(
		joinHead(headAction, headRoutes).Uint64(),
		pld.Body(),
	)

    // Шифруем полезную нагрузку открытым ключом получателя.
	msg, err := node.Queue().Client().Encrypt(recv, newPld)
	if err != nil {
		return nil, err
	}

    // Устанавливаем связь с получателем.
	node.setAction(headAction)
	defer node.delAction(headAction)

    // Пытаемся занести сообщение в очередь.
	for i := uint64(0); i <= node.Settings().GetRetryEnqueue(); i++ {
		if err := node.Queue().Enqueue(msg); err != nil {
			time.Sleep(node.Queue().Settings().GetDuration())
			continue
		}
		break
	}

    // Получаем ответ по связи.
	return node.recv(headAction, node.Settings().GetTimeWait())
}

func (node *sNode) recv(head uint32, timeOut time.Duration) ([]byte, error) {
	// Берём "считыватель" по связи
    action, ok := node.getAction(head)
	if !ok {
		return nil, errors.New("action undefined")
	}
    // Просматриваем и получаем событие.
	select {
	case result, opened := <-action:
		if !opened {
			return nil, errors.New("chan is closed")
		}
		return result, nil
	case <-time.After(timeOut):
		return nil, errors.New("time is over")
	}
}

Ровно такой же как в примере кода сетевых коммуникаций.

#!/bin/bash

str2hex() {
    local str=${1:-""}
    local fmt="%02X"
    local chr
    local -i i
    for i in `seq 0 $((${#str}-1))`; do
        chr=${str:i:1}
        printf "${fmt}" "'${chr}"
    done
}

JSON_DATA='{
        "method":"POST",
        "host":"hidden-echo-service",
        "path":"/echo",
        "head":{
            "Accept": "application/json"
        },
        "body":"aGVsbG8sIHdvcmxkIQ=="
}';

PUSH_FORMAT="{
        \"receiver\":\"Pub(go-peer/rsa){3082020A0282020100B752D35E81F4AEEC1A9C42EDED16E8924DD4D359663611DE2DCCE1A9611704A697B26254DD2AFA974A61A2CF94FAD016450FEF22F218CA970BFE41E6340CE3ABCBEE123E35A9DCDA6D23738DAC46AF8AC57902DDE7F41A03EB00A4818137E1BF4DFAE1EEDF8BB9E4363C15FD1C2278D86F2535BC3F395BE9A6CD690A5C852E6C35D6184BE7B9062AEE2AFC1A5AC81E7D21B7252A56C62BB5AC0BBAD36C7A4907C868704985E1754BAA3E8315E775A51B7BDC7ACB0D0675D29513D78CB05AB6119D3CA0A810A41F78150E3C5D9ACAFBE1533FC3533DECEC14387BF7478F6E229EB4CC312DC22436F4DB0D4CC308FB6EEA612F2F9E00239DE7902DE15889EE71370147C9696A5E7B022947ABB8AFBBC64F7840BED4CE69592CAF4085A1074475E365ED015048C89AE717BC259C42510F15F31DA3F9302EAD8F263B43D14886B2335A245C00871C041CBB683F1F047573F789673F9B11B6E6714C2A3360244757BB220C7952C6D3D9D65AA47511A63E2A59706B7A70846C930DCFB3D8CAFB3BD6F687CACF5A708692C26B363C80C460F54E59912D41D9BB359698051ABC049A0D0CFD7F23DC97DA940B1EDEAC6B84B194C8F8A56A46CE69EE7A0AEAA11C99508A368E64D27756AD0BA7146A6ADA3D5FA237B3B4EDDC84B71C27DE3A9F26A42197791C7DC09E2D7C4A7D8FCDC8F9A5D4983BB278FCE9513B1486D18F8560C3F31CC70203010001}\",
        \"hex_data\":\"$(str2hex "$JSON_DATA")\"
}";

curl -i -X POST -H 'Accept: application/json' http://localhost:7572/api/network/push --data "${PUSH_FORMAT}"

package main

import (
	"encoding/json"
	"io"
	"net/http"
)

type sResponse struct {
	FEcho   string `json:"echo"`
	FReturn int    `json:"return"`
}

func main() {
	http.HandleFunc("/echo", echoPage)
	http.ListenAndServe(":8080", nil)
}

func echoPage(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		response(w, 2, "failed: incorrect method")
		return
	}
	res, err := io.ReadAll(r.Body)
	if err != nil {
		response(w, 3, "failed: read body")
		return
	}
	response(w, 1, string(res))
}

func response(w http.ResponseWriter, ret int, res string) {
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(&sResponse{
		FEcho:   res,
		FReturn: ret,
	})
}

HLS:

{
	"address": {
		"http": "localhost:8572"
	},
	"services": {
		"go-peer/hidden-lake-messenger": "localhost:8081"
	},
	"connections": [
		"localhost:9571"
	],
	"friends": {
		"Alice": "Pub(go-peer/rsa){3082020A0282020100C17B6FA53983050B0339A0AB60D20A8A5FF5F8210564464C45CD2FAC2F266E8DDBA3B36C6F356AE57D1A71EED7B612C4CBC808557E4FCBAF6EDCFCECE37494144F09D65C7533109CE2F9B9B31D754453CA636A4463594F2C38303AE1B7BFFE738AC57805C782193B4854FF3F3FACA2C6BF9F75428DF6C583FBC29614C0B3329DF50F7B6399E1CC1F12BED77F29F885D7137ADFADE74A43451BB97A32F2301BE8EA866AFF34D6C7ED7FF1FAEA11FFB5B1034602B67E7918E42CA3D20E3E68AA700BE1B55A78C73A1D60D0A3DED3A6E5778C0BA68BAB9C345462131B9DC554D1A189066D649D7E167621815AB5B93905582BF19C28BCA6018E0CD205702968885E92A3B1E3DB37A25AC26FA4D2A47FF024ECD401F79FA353FEF2E4C2183C44D1D44B44938D32D8DBEDDAF5C87D042E4E9DAD671BE9C10DD8B3FE0A7C29AFE20843FE268C6A8F14949A04FF25A3EEE1EBE0027A99CE1C4DC561697297EA9FD9E23CF2E190B58CA385B66A235290A23CBB3856108EFFDD775601B3DE92C06C9EA2695C2D25D7897FD9D43C1AE10016E51C46C67F19AC84CD25F47DE2962A48030BCD8A0F14FFE4135A2893F62AC3E15CC61EC2E4ACADE0736C9A8DBC17D439248C42C5C0C6E08612414170FBE5AA6B52AE64E4CCDAE6FD3066BED5C200E07DBB0167D74A9FAD263AF253DFA870F44407F8EF3D9F12B8D910C4D803AD82ABA136F93F0203010001}"
	}
}

HLM:

{
	"address": {
		"web_local": "localhost:8080",
		"incoming": "localhost:8081"
	},
	"connection": "localhost:8572"
}