🙋🏿 🖲️ 🔈 La teoría de la estructura de los sistemas ocultos. 👩🏿 💒 🧠

Introducción

Comenzando con la criptografía clásica, desde sus inicios hasta su renacimiento en la criptografía moderna, siempre ha existido el problema de transferir una clave de cifrado entre sujetos. El problema se resolvió parcialmente en la segunda mitad del siglo XX, con el surgimiento de una sección asimétrica de la criptografía, cuando un ataque de escucha se volvió imposible [1]. Sin embargo, el problema original persiste y se explota hasta el día de hoy, aunque de forma velada.

El obstáculo que se ha convertido en la solución del problema reside en el elemento de confianza, en su presencia y en su ausencia. Si no toma ninguna medida para establecer conexiones confiables, todas las conexiones estarán a priori sujetas a ataques MITM (man in the middle). Por otro lado, si establece conexiones confiables, la posibilidad de ataques MITM no desaparece, sino que disminuye. Y ahora, junto a los sujetos originales, están los sujetos intermedios, intersticiales (servidores, nodos de almacenamiento y transmisión de información), elegidos por nosotros, y son atacantes legalmente establecidos. Solo al limitar el rango de ataque, no dejan de atacar potencialmente. Estos nodos conocen toda la información que nos transmitimos y a nosotros: pasatiempos, intereses, pasatiempos, entretenimiento, mensajes. Además, esta información (objeto), como sucede a menudo,comienza a convertirse en publicidad, a partir de la cual aumenta el capital de todas las mismas entidades intermedias. Como resultado, todo el problema está completamente patas arriba, y ahora, en lugar de buscar una conexión para escuchar a escondidas, el atacante la crea él mismo, él mismo se convierte en la base de la escucha bajo la apariencia de un servidor y, a su vez, las personas. , solo elige la cara del que está detrás será vigilado de cerca.

No es posible destruir tal sistema de confianza por la aparición de tipos de ataques más generales y destructivos, así como por la imposibilidad de erradicar por completo la confianza como tal [2, p.267]. Así pues, sólo queda mejorar este sistema, hacer que su propio mecanismo tienda a reducir el poder de la confianza *, de modo que su propia estructura represente la protección de objetos y sujetos anónimos. Los sistemas de este tipo incluyen redes anónimas y canales de comunicación encubiertos.

El poder de la confianza

* — , , . , , , , , . , , , . . , - . , , , , . , (-, ), , .

, , – , . , , – , , , . /, . , .

, , (, ). , , , . , .

, , . ( - ) , , . , . , . , , , , .

, , . , . : , . “ ” ( ), - . , . “ ” ( ), . , “” , (-) .

, . , , / . , . , / , , , , . , .

- , , , , . (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 - . , , .

gopeer: https://github.com/Number571/gopeer

- HES, : https://github.com/Number571/HES

, ( , ), , ( ) ( ). , . . , , . , , (, ), (, ) ( , ). ( ), .

. ., . . [ ]. — : 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. Ir al lenguaje de programación / A.A. Donovan, B.U. Kernighan. - M.: OOO "I.D. Williams ", 2018. - 432 p.
Shelukhin, O. I., Kanaev, S. D. Esteganografía. Implementación de algoritmos y software / O.I. Shelukhin, S.D. Kanaev. - M.: Hotline - Telecom, 2018 .-- 592 p.
Schneier, B. Criptografía aplicada. Protocolos, algoritmos y códigos fuente en C / B. Schneier. - SPB.: OOO "Alfa-kniga", 2018. - 1040 p.

La teoría de la estructura de los sistemas ocultos.

Introducción

More articles: