nim-libp2p/libp2p/protocols/secure/secure.nim

121 lines
3.7 KiB
Nim
Raw Normal View History

2019-09-06 06:51:46 +00:00
## Nim-LibP2P
2019-09-24 17:48:23 +00:00
## Copyright (c) 2019 Status Research & Development GmbH
2019-09-06 06:51:46 +00:00
## Licensed under either of
## * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
## * MIT license ([LICENSE-MIT](LICENSE-MIT))
## at your option.
## This file may not be copied, modified, or distributed except according to
## those terms.
import options
import chronos, chronicles
2020-03-09 17:27:57 +00:00
import ../protocol,
../../stream/streamseq,
../../stream/connection,
../../peerinfo
2019-09-06 06:51:46 +00:00
logScope:
topics = "secure"
2019-09-06 06:51:46 +00:00
type
Secure* = ref object of LPProtocol # base type for secure managers
2020-04-03 20:36:51 +00:00
2020-03-09 17:27:57 +00:00
SecureConn* = ref object of Connection
stream*: Connection
buf: StreamSeq
2020-03-09 17:27:57 +00:00
method initStream*(s: SecureConn) =
if s.objName.len == 0:
s.objName = "SecureConn"
procCall Connection(s).initStream()
method close*(s: SecureConn) {.async.} =
if not(isNil(s.stream)):
await s.stream.close()
await procCall Connection(s).close()
2020-03-09 17:27:57 +00:00
method readMessage*(c: SecureConn): Future[seq[byte]] {.async, base.} =
doAssert(false, "Not implemented!")
method handshake(s: Secure,
conn: Connection,
initiator: bool): Future[SecureConn] {.async, base.} =
doAssert(false, "Not implemented!")
proc handleConn*(s: Secure, conn: Connection, initiator: bool): Future[Connection] {.async, gcsafe.} =
2020-03-08 03:14:56 +00:00
var sconn = await s.handshake(conn, initiator)
result = sconn
result.observedAddr = conn.observedAddr
if not isNil(sconn.peerInfo) and sconn.peerInfo.publicKey.isSome:
result.peerInfo = PeerInfo.init(sconn.peerInfo.publicKey.get())
method init*(s: Secure) {.gcsafe.} =
proc handle(conn: Connection, proto: string) {.async, gcsafe.} =
trace "handling connection upgrade", proto
try:
# We don't need the result but we definitely need to await the handshake
discard await s.handleConn(conn, false)
trace "connection secured"
except CatchableError as exc:
2020-05-23 16:51:54 +00:00
warn "securing connection failed", msg = exc.msg
await conn.close()
s.handler = handle
method secure*(s: Secure, conn: Connection, initiator: bool): Future[Connection] {.async, base, gcsafe.} =
2020-03-08 03:14:56 +00:00
try:
result = await s.handleConn(conn, initiator)
2020-05-21 20:24:20 +00:00
except CancelledError as exc:
raise exc
2020-03-08 03:14:56 +00:00
except CatchableError as exc:
warn "securing connection failed", msg = exc.msg
2020-05-21 20:24:20 +00:00
return nil
method readExactly*(s: SecureConn,
pbytes: pointer,
nbytes: int):
Future[void] {.async, gcsafe.} =
2020-05-23 16:51:54 +00:00
try:
if nbytes == 0:
return
while s.buf.data().len < nbytes:
# TODO write decrypted content straight into buf using `prepare`
let buf = await s.readMessage()
if buf.len == 0:
raise newLPStreamIncompleteError()
s.buf.add(buf)
var p = cast[ptr UncheckedArray[byte]](pbytes)
let consumed = s.buf.consumeTo(toOpenArray(p, 0, nbytes - 1))
doAssert consumed == nbytes, "checked above"
except CatchableError as exc:
trace "exception reading from secure connection", exc = exc.msg
await s.close() # make sure to close the wrapped connection
raise exc
method readOnce*(s: SecureConn,
pbytes: pointer,
nbytes: int):
Future[int] {.async, gcsafe.} =
2020-05-23 16:51:54 +00:00
try:
if nbytes == 0:
return 0
2020-05-23 16:51:54 +00:00
if s.buf.data().len() == 0:
let buf = await s.readMessage()
if buf.len == 0:
raise newLPStreamIncompleteError()
s.buf.add(buf)
2020-05-23 16:51:54 +00:00
var p = cast[ptr UncheckedArray[byte]](pbytes)
return s.buf.consumeTo(toOpenArray(p, 0, nbytes - 1))
except CatchableError as exc:
trace "exception reading from secure connection", exc = exc.msg
await s.close() # make sure to close the wrapped connection
raise exc