322 lines
7.8 KiB
C
322 lines
7.8 KiB
C
#define MODULE_LOG_PREFIX "pandora"
|
|
|
|
#include "globals.h"
|
|
|
|
#ifdef MODULE_PANDORA
|
|
|
|
#include "cscrypt/md5.h"
|
|
#include "oscam-client.h"
|
|
#include "oscam-ecm.h"
|
|
#include "oscam-net.h"
|
|
#include "oscam-string.h"
|
|
|
|
#define CWS_NETMSGSIZE 320
|
|
#define START_TIME 150000
|
|
#define MAX_TIME 500000
|
|
|
|
static void simple_crypt(uint8_t *buf, int len, uint8_t *key, int key_len)
|
|
{
|
|
int i, x;
|
|
for(i = 0, x = 0; i < len; i++)
|
|
{
|
|
buf[i] ^= key[x++];
|
|
if(x >= key_len)
|
|
{ x = 0; }
|
|
}
|
|
}
|
|
|
|
static void pandora_process_request(struct s_client *cl, uint8_t *buf, int32_t l)
|
|
{
|
|
int ecmlen;
|
|
ECM_REQUEST *er;
|
|
uint8_t md5tmp[MD5_DIGEST_LENGTH];
|
|
|
|
if(l < 10 + CS_ECMSTORESIZE + 2)
|
|
{ return; }
|
|
|
|
if(!(er = get_ecmtask()))
|
|
{ return; }
|
|
er->caid = b2i(2, buf + 1);
|
|
er->srvid = b2i(2, buf + 3);
|
|
er->prid = b2i(4, buf + 5);
|
|
//er->ecmcrc32 = crc32(0L, buf+10, CS_ECMSTORESIZE);
|
|
er->chid = b2i(2, buf + 10 + CS_ECMSTORESIZE);
|
|
|
|
if(!cl->pand_ignore_ecm && (l >= 10 + CS_ECMSTORESIZE + 2 + 2))
|
|
{
|
|
ecmlen = b2i(2, buf + 10 + CS_ECMSTORESIZE + 2);
|
|
|
|
if(ecmlen < 0 || ecmlen > MAX_ECM_SIZE
|
|
|| ((10 + CS_ECMSTORESIZE + 2 + 2 + ecmlen) > CWS_NETMSGSIZE)
|
|
|| ((10 + CS_ECMSTORESIZE + 2 + 2 + ecmlen) > l))
|
|
{
|
|
er->ecmlen = 0;
|
|
}
|
|
else
|
|
{
|
|
if(!memcmp(buf + 10, MD5(buf + 14 + CS_ECMSTORESIZE, ecmlen, md5tmp), CS_ECMSTORESIZE))
|
|
{
|
|
er->ecmlen = ecmlen;
|
|
memcpy(er->ecm, buf + 14 + CS_ECMSTORESIZE, ecmlen);
|
|
//set_ecmhash(cl, er);
|
|
}
|
|
else
|
|
{ er->ecmlen = 0; }
|
|
}
|
|
}
|
|
else
|
|
{ er->ecmlen = 0; }
|
|
|
|
if(!er->ecmlen)
|
|
{ usleep(cl->pand_autodelay); }
|
|
get_cw(cl, er);
|
|
}
|
|
|
|
static int pandora_recv(struct s_client *cl, uint8_t *buf, int32_t l)
|
|
{
|
|
int ret;
|
|
|
|
if(!cl->udp_fd)
|
|
{ return (-9); }
|
|
if(cl->typ != 'c')
|
|
{ ret = recv_from_udpipe(buf); }
|
|
else
|
|
{
|
|
ret = recvfrom(cl->udp_fd, buf, l, 0, (struct sockaddr *)&cl->udp_sa, &cl->udp_sa_len);
|
|
}
|
|
if(ret < 1)
|
|
{ return (-1); }
|
|
|
|
simple_crypt(buf, ret, cl->pand_md5_key, 16);
|
|
cl->last = time((time_t *) 0);
|
|
|
|
if(cl->typ != 'c')
|
|
{ pandora_process_request(cl, buf, ret); }
|
|
return (ret);
|
|
}
|
|
|
|
static void pandora_send_dcw(struct s_client *cl, ECM_REQUEST *er)
|
|
{
|
|
uint8_t msgbuf[CWS_NETMSGSIZE], len;
|
|
if(cfg.pand_skip_send_dw)
|
|
{ return; }
|
|
if(er->rc < E_NOTFOUND)
|
|
{
|
|
msgbuf[0] = 2; // DW_FOUND
|
|
memcpy(&msgbuf[1], er->cw, 16);
|
|
len = 1 + 16;
|
|
cl->pand_autodelay = START_TIME;
|
|
}
|
|
else
|
|
{
|
|
msgbuf[0] = 0xFF; // DW_NOT_FOUND
|
|
len = 1;
|
|
if(cl->pand_autodelay < MAX_TIME)
|
|
{ cl->pand_autodelay += 100000; }
|
|
}
|
|
simple_crypt(msgbuf, len, cl->pand_md5_key, 16);
|
|
sendto(cl->udp_fd, msgbuf, len, 0, (struct sockaddr *) &cl->udp_sa, cl->udp_sa_len);
|
|
}
|
|
|
|
int pandora_auth_client(struct s_client *cl, IN_ADDR_T ip)
|
|
{
|
|
int ok;
|
|
struct s_auth *account;
|
|
|
|
#ifdef IPV6SUPPORT
|
|
// FIXME: Add IPv6 support
|
|
(void)ip; // Prevent warning about unused var "ip"
|
|
#else
|
|
if(!cl->pand_ignore_ecm && cfg.pand_allowed)
|
|
{
|
|
struct s_ip *p_ip;
|
|
for(ok = 0, p_ip = cfg.pand_allowed; (p_ip) && (!ok); p_ip
|
|
= p_ip->next)
|
|
{ ok = ((ip >= p_ip->ip[0]) && (ip <= p_ip->ip[1])); }
|
|
|
|
if(!ok)
|
|
{
|
|
cs_auth_client(cl, (struct s_auth *) 0, "IP not allowed");
|
|
return 0;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
for(ok = 0, account = cfg.account; cfg.pand_usr && account && !ok; account = account->next)
|
|
{
|
|
ok = streq(cfg.pand_usr, account->usr);
|
|
if(ok && cs_auth_client(cl, account, NULL))
|
|
{ cs_disconnect_client(cl); }
|
|
}
|
|
if(!ok)
|
|
{ cs_auth_client(cl, (struct s_auth *)(-1), NULL); }
|
|
return ok;
|
|
}
|
|
|
|
static void *pandora_server(struct s_client *cl, uint8_t *UNUSED(mbuf), int32_t UNUSED(len))
|
|
{
|
|
uint8_t md5tmp[MD5_DIGEST_LENGTH];
|
|
if(!cl->init_done)
|
|
{
|
|
if(cfg.pand_pass)
|
|
{
|
|
cl->pand_autodelay = 150000;
|
|
memcpy(cl->pand_md5_key, MD5((uint8_t *)cfg.pand_pass, cs_strlen(cfg.pand_pass), md5tmp), 16);
|
|
cl->pand_ignore_ecm = (cfg.pand_ecm) ? 0 : 1;
|
|
cl->crypted = 1;
|
|
pandora_auth_client(cl, cl->ip);
|
|
cl->init_done = 1;
|
|
}
|
|
else
|
|
{
|
|
cs_log("Password for Pandora share MUST be set !!!");
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/************************************************************************************************************************
|
|
* client functions
|
|
*************************************************************************************************************************/
|
|
int pandora_client_init(struct s_client *cl)
|
|
{
|
|
static struct sockaddr_in loc_sa;
|
|
int16_t p_proto;
|
|
char ptxt[16];
|
|
struct s_reader *rdr = cl->reader;
|
|
uint8_t md5tmp[MD5_DIGEST_LENGTH];
|
|
|
|
cl->pfd = 0;
|
|
if(rdr->r_port <= 0)
|
|
{
|
|
cs_log("invalid port %d for server %s", rdr->r_port, rdr->device);
|
|
return (1);
|
|
}
|
|
p_proto = IPPROTO_UDP;
|
|
|
|
set_null_ip(&cl->ip);
|
|
memset((char *) &loc_sa, 0, sizeof(loc_sa));
|
|
loc_sa.sin_family = AF_INET;
|
|
|
|
if(IP_ISSET(cfg.srvip))
|
|
{ IP_ASSIGN(SIN_GET_ADDR(loc_sa), cfg.srvip); }
|
|
else
|
|
{ loc_sa.sin_addr.s_addr = INADDR_ANY; }
|
|
loc_sa.sin_port = htons(rdr->l_port);
|
|
|
|
if((cl->udp_fd = socket(PF_INET, SOCK_DGRAM, p_proto)) < 0)
|
|
{
|
|
cs_log("Socket creation failed (errno=%d)", errno);
|
|
return 1;
|
|
}
|
|
|
|
int32_t opt = 1;
|
|
setsockopt(cl->udp_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
|
|
|
|
set_so_reuseport(cl->udp_fd);
|
|
|
|
set_socket_priority(cl->udp_fd, cfg.netprio);
|
|
|
|
if(rdr->l_port > 0)
|
|
{
|
|
if(bind(cl->udp_fd, (struct sockaddr *) &loc_sa, sizeof(loc_sa)) < 0)
|
|
{
|
|
cs_log("bind failed (errno=%d)", errno);
|
|
close(cl->udp_fd);
|
|
return (1);
|
|
}
|
|
snprintf(ptxt, sizeof(ptxt), ", port=%d", rdr->l_port);
|
|
}
|
|
else
|
|
{ ptxt[0] = '\0'; }
|
|
|
|
memcpy(cl->pand_md5_key, MD5((uint8_t *)rdr->r_pwd, cs_strlen(rdr->r_pwd), md5tmp), 16);
|
|
cl->crypted = 1;
|
|
|
|
//cl->grp = 0xFFFFFFFF;
|
|
//rdr->caid[0] = rdr->ctab.caid[0];
|
|
|
|
cl->pand_send_ecm = rdr->pand_send_ecm;
|
|
memset((char *) &cl->udp_sa, 0, sizeof(cl->udp_sa));
|
|
#ifdef IPV6SUPPORT
|
|
((struct sockaddr_in *)(&cl->udp_sa))->sin_family = AF_INET;
|
|
((struct sockaddr_in *)(&cl->udp_sa))->sin_port = htons((u_short) rdr->r_port);
|
|
#else
|
|
cl->udp_sa.sin_family = AF_INET;
|
|
cl->udp_sa.sin_port = htons((u_short) rdr->r_port);
|
|
#endif
|
|
|
|
cs_log("proxy %s:%d pandora %s (%s)", rdr->device, rdr->r_port, rdr->pand_send_ecm ? "with ECM support" : "", ptxt);
|
|
|
|
cl->pfd = cl->udp_fd;
|
|
//set_nonblock(cl->udp_fd, true); //!!!!!
|
|
return (0);
|
|
}
|
|
|
|
static int pandora_send_ecm(struct s_client *cl, ECM_REQUEST *er)
|
|
{
|
|
uint8_t md5tmp[MD5_DIGEST_LENGTH];
|
|
uint8_t msgbuf[CWS_NETMSGSIZE];
|
|
int ret, len;
|
|
uint8_t adel;
|
|
adel = (cfg.ctimeout > 7) ? 7 : cfg.ctimeout;
|
|
|
|
msgbuf[0] = 1;
|
|
msgbuf[1] = er->caid >> 8;
|
|
msgbuf[2] = er->caid & 0xFF;
|
|
msgbuf[3] = er->srvid >> 8;
|
|
msgbuf[4] = er->srvid & 0xFF;
|
|
msgbuf[5] = er->prid >> 24;
|
|
msgbuf[6] = er->prid >> 16;
|
|
msgbuf[7] = er->prid >> 8;
|
|
msgbuf[8] = er->prid & 0xFF;
|
|
msgbuf[9] = adel;
|
|
memcpy(&msgbuf[10], MD5(er->ecm, er->ecmlen, md5tmp), CS_ECMSTORESIZE);
|
|
msgbuf[10 + CS_ECMSTORESIZE] = er->chid >> 8;
|
|
msgbuf[11 + CS_ECMSTORESIZE] = er->chid & 0xFF;
|
|
len = 12 + CS_ECMSTORESIZE;
|
|
if(cl->pand_send_ecm)
|
|
{
|
|
if(len+2+er->ecmlen > CWS_NETMSGSIZE)
|
|
{ return -1; }
|
|
msgbuf[12 + CS_ECMSTORESIZE] = er->ecmlen >> 8;
|
|
msgbuf[13 + CS_ECMSTORESIZE] = er->ecmlen & 0xFF;
|
|
memcpy(&msgbuf[14 + CS_ECMSTORESIZE], er->ecm, er->ecmlen);
|
|
len += er->ecmlen + 2;
|
|
}
|
|
simple_crypt(msgbuf, len, cl->pand_md5_key, 16);
|
|
ret = sendto(cl->pfd, msgbuf, len, 0, (struct sockaddr *) &cl->udp_sa, cl->udp_sa_len);
|
|
return ((ret < len) ? (-1) : 0);
|
|
}
|
|
|
|
static int pandora_recv_chk(struct s_client *UNUSED(cl), uint8_t *dcw, int *rc, uint8_t *buf, int UNUSED(n))
|
|
{
|
|
if(buf[0] != 0x2)
|
|
{ return (-1); }
|
|
*rc = 1;
|
|
memcpy(dcw, buf + 1, 16);
|
|
return (0);
|
|
}
|
|
|
|
void module_pandora(struct s_module *ph)
|
|
{
|
|
ph->ptab.nports = 1;
|
|
ph->ptab.ports[0].s_port = cfg.pand_port;
|
|
ph->num = R_PANDORA;
|
|
|
|
ph->desc = "pandora";
|
|
ph->type = MOD_CONN_UDP;
|
|
ph->large_ecm_support = 1;
|
|
//ph->watchdog = 1;
|
|
IP_ASSIGN(ph->s_ip, cfg.pand_srvip);
|
|
ph->s_handler = pandora_server;
|
|
ph->recv = pandora_recv;
|
|
ph->send_dcw = pandora_send_dcw;
|
|
|
|
ph->c_init = pandora_client_init;
|
|
ph->c_recv_chk = pandora_recv_chk;
|
|
ph->c_send_ecm = pandora_send_ecm;
|
|
}
|
|
|
|
#endif
|