Introdução
Começando com a criptografia clássica, desde seu início até seu renascimento na criptografia moderna, sempre houve um problema de transferência de uma chave de criptografia entre assuntos. O problema foi parcialmente resolvido na segunda metade do século 20, com o surgimento de uma seção assimétrica da criptografia, quando um ataque de espionagem se tornou impossível [1]. No entanto, o problema original ainda permanece e é explorado até hoje, embora de forma velada.
O obstáculo que se coloca à solução do problema reside no elemento da confiança, na sua presença e na sua ausência. Se você não tomar nenhuma medida para estabelecer conexões confiáveis, quaisquer conexões estarão, a priori, sujeitas a ataques MITM (man in the middle). Por outro lado, se você estabelecer conexões confiáveis, a possibilidade de ataques MITM não desaparece, mas diminui. E agora, junto com os assuntos originais, existem os assuntos intermediários, intersticiais (servidores, nós para armazenar e transmitir informações), escolhidos por nós, e são atacantes legalmente estabelecidos. Apenas limitando o alcance do ataque, eles não param de atacar potencialmente. Esses nós conhecem todas as informações transmitidas por nós e para nós: hobbies, interesses, hobbies, entretenimento, mensagens. Além disso, essa informação (objeto), como costuma acontecer,começa a se converter em publicidade, com base na qual aumenta o capital de todas as mesmas entidades intermediárias. Como resultado, todo o problema está completamente virado de cabeça para baixo e agora, em vez de procurar uma conexão para espionagem, o invasor a cria ele mesmo, ele mesmo se torna a base para ouvir sob o disfarce de um servidor, e as pessoas, por sua vez , escolha apenas o rosto de quem está atrás, eles serão observados de perto.
Não é possível destruir tal sistema de confiança devido ao surgimento de tipos de ataques mais gerais e destrutivos, bem como pela impossibilidade de erradicar completamente a confiança como tal [2, p.267]. Assim, resta aperfeiçoar esse sistema, fazer com que seu próprio mecanismo tenda a reduzir o poder de confiança *, de modo que sua própria estrutura representasse a proteção de objetos e sujeitos anônimos. Sistemas desse tipo incluem redes anônimas e canais de comunicação secretos.
O poder da confiança
* — , , . , , , , , . , , , . . , - . , , , , . , (-, ), , .
, , – , . , , – , , , . /, . , .
, , (, ). , , , . , .
, , . ( - ) , , . , . , . , , , , .
, , . , . : , . “ ” ( ), - . , . “ ” ( ), . , “” , (-) .
, . , , / . , . , / , , , , . , .
- , , , , . (2,3,4,5,6 ).
|A| = 0*. .
-, -. , (, IP-, , ). . , , , , - . , , |A| = 1. -.
, , - . , , , lim|A|→C, C - - . , . , ( ) - , - , .
. , , , , , . , , ( ) . , , , [3] .., ( , ). , , , , , , - , [4, .398]. , , , . , ( ) () () . , - 0 < |A| ≤ N, N - . , , , .
, , . . , lim|A|→C, C - . , Tor ( ), I2P ( ) ..
, , , ( ) . , , . 0 < |A| ≤ N(C+1), N - , C - . , , . , , , .
, , , , , , - .
, , , [5, .223]. , , , , , . , . , , . , .
, , ( ), , , ( ). , , ( , ) . , , . , , , , , (lim|A|→1) . , , , , . , , . , . , . , . , , . :
. , . , , , , , . -- ( friend-to-friend), — . , , , . , , - , - . , , , , , , . friend-to-friend (f2f) , , , .
— . , , , () / (). , - , , . , . O(N) . , , N , N-1 . (TTL) , , , , .
, , , . , . , , , , , . , . , , :
— , . , . , . , , , .
. , - . , , A B, A**. Tor, , “”, .
. , , . , . , , , . , . , . , , , — , “” . , , . , , - -.
[6]
import (
"bytes"
)
func RoutePackage(sender *PrivateKey, receiver *PublicKey, data []byte, route []*PublicKey) *Package {
var (
rpack = Encrypt(sender, receiver, data)
psender = GenerateKey(N)
)
for _, pub := range route {
rpack = Encrypt(
psender,
pub,
bytes.Join(
[][]byte{
ROUTE_MODE,
SerializePackage(rpack),
},
[]byte{},
),
)
}
return rpack
}
, {A, B, C} ( — A) , , ( , ). , , , , , . , , , : (A → B A → C) → (B → C C → B) → (B → A C → A), , : (A → B A → C) → (B → A C → A)***. , (), . , ( , ), ( , ). , , , , , : (1) - (1) - (2) (1) - (1) - (1). , ( ), (2) (2), . , ( ) k n ( n = 2), (k, 2) = 2 ( — ), , k = 2, : (A → B A → C) → (B → C C → B) → (B → C C → B) → (B → A C → A). , : (1) - (1) - (2) - (2) (1) - (1) - (~1) - (1), . , (1) = (1), (2) = (1), (2) = (~1). (1), , . - , . , (3) = (2), .
, , , , . , , - , - , - - . , . , :
. , , . , . , , .
. , , , , , . , .
, , , , ( ). T, (2+k, 2) ( - ), , k = 2 4. , , , ( ). , , , , . :
k ( , ).
k [1;n], n < N ( ).
* — , , , . , ( ). , ( ).
** — , , . , , . .
*** , , , .
, , - , , , . , , , , - . , :
, , - , / [7] . , , (, ), (). (), .
, , , , . , , . , . , , , . ( |A| = 1), . , , . , , , , . - — ( ).
, , , . , , , . , , , , . , -, -, , , . , . , ( , ) 2MiB, 256KiB.
, , . , , , . , , (, ..), , . , , , . , , .
, , , . , , . , ( , , ), , .
, , , , , [8, .720]. , , , , , . , , , . , - , .
, , ( ), , ( ), ( ) ( , ).
, , , , . [2, .58][8, .80].
. , , , , , .
, . , , . . . .
, , , , , , - , . , , ( , ) .
import (
"bytes"
"encoding/hex"
)
func Encrypt(sender *PrivateKey, receiver *PublicKey, data []byte) *Package {
var (
session = GenerateBytes(N)
rand = GenerateBytes(M)
pubsend = PublicKeyToBytes(&sender.PublicKey)
hash = HashSum(bytes.Join(
[][]byte{
rand,
data,pubsend,
PublicKeyToBytes(receiver),
},
[]byte{},
))
sign = Sign(sender, hash)
)
return &Package{
Head: HeadPackage{
Rand: hex.EncodeToString(EncryptS(session, rand)),
Sender: hex.EncodeToString(EncryptS(session, pubsend)),
Session: hex.EncodeToString(EncryptA(receiver, session)),
}, Body: BodyPackage{
Data: hex.EncodeToString(EncryptS(session, data)),
Hash: hex.EncodeToString(hash),
Sign: hex.EncodeToString(EncryptS(session, sign)),
Npow: ProofOfWork(hash, C),
},
}
}
, , ( ) . , .
() , , , .
import (
"bytes"
"encoding/hex"
)
func Decrypt(receiver *PrivateKey, pack *Package) (*PublicKey, []byte) {
// Check proof.
hash, err := hex.DecodeString(pack.Body.Hash)
if err != nil {
return nil, nil
}
if !ProofIsValid(hash, C, pack.Body.Npow) {
return nil, nil
}
// Decrypt session key.
eskey, err := hex.DecodeString(pack.Head.Session)
if err != nil {
return nil, nil
}
skey := DecryptA(receiver, eskey)
if skey == nil {
return nil, nil
}
// Decrypt public key.
ebpubsend, err := hex.DecodeString(pack.Head.Sender)
if err != nil {
return nil, nil
}
bpubsend := DecryptS(skey, ebpubsend)
if bpubsend == nil {
return nil, nil
}
pubsend := BytesToPublicKey(bpubsend)
if pubsend == nil {
return nil, nil
}
// Decrypt and check sign.
esign, err := hex.DecodeString(pack.Body.Sign)
if err != nil {
return nil, nil
}
sign := DecryptS(skey, esign)
if sign == nil {
return nil, nil
}
if !Verify(pubsend, hash, sign) {
return nil, nil
}
// Decrypt rand.
erand, err := hex.DecodeString(pack.Head.Rand)
if err != nil {
return nil, nil
}
rand := DecryptS(skey, erand)
if rand == nil {
return nil, nil
}
// Decrypt data.
edata, err := hex.DecodeString(pack.Body.Data)
if err != nil {
return nil, nil
}
data := DecryptS(skey, edata)
if data == nil {
return nil, nil
}
// Check hash.
check := HashSum(bytes.Join(
[][]byte{
rand,
data,
PublicKeyToBytes(pubsend),
PublicKeyToBytes(&receiver.PublicKey),
},
[]byte{},
))
if !bytes.Equal(hash, check) {
return nil, nil
}
return pubsend, data
}
, , , , ( ), n- , i- . , ⎡M/nN⎤+1 , M - , N - . , , .
, ( , ), , ( ) ( ). , . . , , . , , (, ), (, ) ( , ). ( ), .
. ., . . [ ]. — : https://ee.stanford.edu/~hellman/publications/24.pdf ( : 19.12.2020).
, ., , . . / . , . . . - .: «, 2005. - 420 .
, . : [ ]. — : https://bitcoin.org/files/bitcoin-paper/bitcoin_ru.pdf ( : 19.12.2020).
, ., , . / . , . . — .: , 2017. - 960 .
, . ., , . . / . . , . . . - .: - , 2019. - 300 .
Donovan, A.A., Kernighan, B.U. Linguagem de programação Go / A.A. Donovan, B.U. Kernighan. - M.: OOO "I.D. Williams ", 2018. - 432 p.
Shelukhin, O. I., Kanaev, S. D. Esteganografia. Implementação de algoritmos e software / O.I. Shelukhin, S.D. Kanaev. - M: Hotline - Telecom, 2018 .-- 592 p.
Schneier, B. Applied Cryptography. Protocolos, algoritmos e códigos-fonte em C / B. Schneier. - SPB .: OOO "Alfa-kniga", 2018. - 1040 p.