clrghouz/app/Classes/Node.php
Deon George f006d829f4
All checks were successful
Create Docker Image / Build Docker Image (x86_64) (push) Successful in 37s
Create Docker Image / Build Docker Image (arm64) (push) Successful in 1m45s
Create Docker Image / Final Docker Image Manifest (push) Successful in 11s
Fix for originating calls and not recognising that the remote accepted our password
2024-06-27 09:09:47 +10:00

321 lines
7.6 KiB
PHP

<?php
namespace App\Classes;
use Carbon\Carbon;
use Exception;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Log;
use App\Models\Address;
/**
* Object representing the node we are communicating with
*
* @property int aka_authed
* @property int aka_num
* @property string ftn
* @property string password
* @property Carbon node_time
* @property int session_time
* @property int ver_major
* @property int ver_minor
*/
class Node
{
private const LOGKEY = 'N--';
// Remote Version
private int $version_major = 0;
private int $version_minor = 0;
private Carbon $start_time; // The time our connection started
// @todo Change this to Carbon
private string $node_time; // Current node's time
private string $node_timezone; // Current node's time zone
private Collection $ftns; // The FTNs of the remote system
private Collection $ftns_authed; // The FTNs we have validated
private Collection $ftns_other; // Other FTN addresses presented
private bool $authed; // Have we authenticated the remote.
private Address $originate; // When we originate a call, this is who we are after
private int $options; // This nodes capabilities/options
public function __construct()
{
$this->options = 0;
$this->authed = FALSE;
$this->start_time = Carbon::now();
$this->ftns = collect();
$this->ftns_authed = collect();
$this->ftns_other = collect();
// @todo This should be configured in the DB for each FTN system
$this->node_timezone = 'Australia/Melbourne';
}
/**
* @throws Exception
*/
public function __get($key)
{
switch ($key) {
case 'address':
return ($x=$this->ftns_authed)->count() ? $x->first() : $this->ftns->first();
// Number of AKAs the remote has
case 'aka_num':
return $this->ftns->count();
// The authenticated remote addresses
case 'aka_remote_authed':
return $this->ftns_authed;
case 'aka_remote':
return $this->ftns;
// Have we authenticated the remote
case 'aka_authed':
return $this->authed;
// FTNs that we dont know about
case 'aka_other':
return $this->ftns_other;
// The nodes password
case 'password':
// If we are originating a session, we'll use that password.
if (isset($this->originate))
return $this->originate->pass_session;
else
return ($this->ftns->count() && ($x=$this->ftns->first()->pass_session)) ? $x : '-';
// Return how long our session has been connected
case 'session_time':
return sprintf("%d",$this->start_time->diffInSeconds(Carbon::now()));
case 'system':
case 'sysop':
case 'location':
case 'phone':
case 'flags':
case 'message':
case 'files':
case 'node_time':
case 'node_timezone':
case 'netmail':
// The current session speed
case 'speed':
// The time our session started.
case 'start_time':
case 'software':
return $this->{$key};
// Client version
case 'ver_major':
return $this->version_major;
case 'ver_minor':
return $this->version_minor;
default:
throw new Exception('Unknown key: '.$key);
}
}
/**
* @throws Exception
*/
public function __set($key,$value)
{
switch ($key) {
case 'ftn':
if ((! is_object($value)) || (! $value instanceof Address))
throw new Exception('Not an Address object: '.(is_object($value) ? get_class($value) : serialize($value)));
// Ignore any duplicate FTNs that we get
if ($this->ftns->search(function($item) use ($value) { return $item->id === $value->id; }) !== FALSE) {
Log::debug(sprintf('%s:- Ignoring Duplicate FTN [%s]',self::LOGKEY,$value->ftn));
break;
}
$this->ftns->push($value);
break;
case 'ftn_other':
// Ignore any duplicate FTNs that we get
if ($this->ftns_other->search($value) !== FALSE) {
Log::debug(sprintf('%s:- Ignoring Duplicate FTN [%s]',self::LOGKEY,$value));
break;
}
$this->ftns_other->push($value);
break;
case 'system':
case 'sysop':
case 'location':
case 'phone':
case 'flags':
case 'message':
case 'files':
case 'netmail':
case 'software':
case 'speed':
case 'start_time':
case 'node_time':
case 'node_timezone':
case 'ver_major':
case 'ver_minor':
$this->{$key} = $value;
break;
default:
throw new Exception('Unknown variable: '.$key);
}
}
/**
* Authenticate the AKAs that the node provided
*
* @param string $password
* @param string $challenge
* @return int
* @throws Exception
*/
public function auth(string $password,string $challenge=''): int
{
Log::debug(sprintf('%s:+ auth [%s]',self::LOGKEY,$password));
$so = NULL;
// Make sure we havent been here already
if ($this->ftns_authed->count())
throw new Exception('Already authed');
foreach ($this->ftns as $o) {
Log::debug(sprintf('%s:- Attempting to authenticate [%s] with [%s]',self::LOGKEY,$o->ftn,$o->pass_session));
if (! $sespass=$o->pass_session)
continue;
// If we have challenge, then we are doing MD5
$exp_pwd = $challenge ? $this->md5_challenge($sespass,$challenge) : $sespass;
if ($exp_pwd === $password) {
if (! $so)
$so = $o->system;
// Make sure we are the same system
if ($so->id !== $o->system->id) {
Log::alert(sprintf('%s:! AKA [%s] is from a different system?',self::LOGKEY,$o->ftn),['so'=>$so->name]);
continue;
}
$this->ftns_authed->push($o);
$this->authed = TRUE;
}
}
if ($this->authed) {
$o->system->last_session = Carbon::now();
$o->system->save();
}
Log::debug(sprintf('%s:= auth, we authed [%d] addresses',self::LOGKEY,$this->ftns_authed->count()));
return $this->ftns_authed->count();
}
/**
* When we originate a connection and need to send our MD5 Challenge response
*
* @param string $challenge
* @return string
* @throws Exception
*/
public function get_md5chal(string $challenge): string
{
return $this->md5_challenge($this->password,$challenge);
}
/**
* Return the remotes BINKP version as a int
*
* @return int
*/
public function get_versionint(): int
{
return $this->ver_major*100+$this->ver_minor;
}
/**
* Calculate the response to an MD5 challenge, using the nodes password
*
* @param $pwd
* @param $challenge
* @return string
*/
private function md5_challenge($pwd,$challenge): string
{
$x = $pwd.str_repeat(chr(0x00),64-strlen($pwd));
return md5($this->str_xor($x,0x5c).md5($this->str_xor($x,0x36).$challenge,true));
}
/**
* When we originate a call to a node, we need to store the node we are connecting with in the ftns_authed, so
* authentication proceeds when we send our M_pwd
*
* @param Address $o
*/
public function originate(Address $o): void
{
$this->originate = $o;
$this->ftns_authed = $o->system->match($o->zone);
}
/**
* Check that our received FTNs match who we called
*
* @return bool
*/
public function originate_check(): bool
{
// If we have already authed, we wont do it again
if ($this->authed)
return TRUE;
Log::debug(sprintf('%s:- Making sure we called [%s] from [%s]',self::LOGKEY,$this->originate->ftn,$this->ftns->pluck('ftn')->join(',')));
$this->authed = $this->ftns->pluck('ftn')->contains($this->originate->ftn);
return $this->authed;
}
public function optionClear(int $key): void
{
$this->options &= ~$key;
}
public function optionGet(int $key): int
{
return ($this->options & $key);
}
public function optionSet(int $key): void
{
$this->options |= $key;
}
private function str_xor(string $string,int $val): string
{
$result = '';
for ($i=0;$i<strlen($string);$i++)
$result .= chr(ord($string[$i]) ^ $val);
return $result;
}
}