static int init_cmd_vars(t_data *data)
{
if (!(xmemset(data->pipe_old, -1, 2)) || !(xmemset(data->pipe_new, -1, 2)))
return (ID_FAIL_MEMSET);
data->exit_cmd = 0;
env_load_protected_vars(data->env);
return (0);
}
void CreateDock(HWND *hWndDock, DOCK **dkDock, BOOL bShow)
{
DOCK dk;
*hWndDock=NULL;
xmemset(&dk, 0, sizeof(DOCK));
dk.dwFlags=DKF_DRAGDROP;
dk.nSide=nCaptureDockSide;
dk.rcSize=rcCaptureDockRect;
if (*dkDock=(DOCK *)SendMessage(hMainWnd, AKD_DOCK, DK_ADD, (LPARAM)&dk))
{
*hWndDock=CreateDialogWide(hInstanceDLL, MAKEINTRESOURCEW(IDD_CAPTURE), hMainWnd, (DLGPROC)DockDlgProc);
if (*hWndDock)
{
if (!(*dkDock)->rcSize.right || !(*dkDock)->rcSize.bottom)
{
GetWindowRect(*hWndDock, &(*dkDock)->rcSize);
(*dkDock)->rcSize.right-=(*dkDock)->rcSize.left;
(*dkDock)->rcSize.bottom-=(*dkDock)->rcSize.top;
(*dkDock)->rcSize.left=0;
(*dkDock)->rcSize.top=0;
}
(*dkDock)->hWnd=*hWndDock;
SendMessage(hMainWnd, AKD_DOCK, DK_SUBCLASS, (LPARAM)*dkDock);
if (bShow)
SendMessage(hMainWnd, AKD_DOCK, DK_SHOW, (LPARAM)*dkDock);
else
(*dkDock)->dwFlags|=DKF_HIDDEN;
}
}
}
void SecureClearMem(char *Mem, int Size)
{
char *ptr;
if (! Mem) return;
xmemset((volatile char *) Mem,0,Size);
for (ptr=Mem; ptr < (Mem + Size); ptr++)
{
if (*ptr != 0)
{
fprintf(stderr,"LIBUSEFUL ERROR: Failed to clear secure memory");
exit(3);
}
}
}
int curve25519_proto_init(struct curve25519_proto *p, unsigned char *pubkey_remote,
size_t len, char *home, int server)
{
int fd;
ssize_t ret;
char path[PATH_MAX];
unsigned char secretkey_own[crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES] = { 0 };
unsigned char publickey_own[crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES] = { 0 };
if (!pubkey_remote ||
len != crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES)
return -EINVAL;
memset(path, 0, sizeof(path));
slprintf(path, sizeof(path), "%s/%s", home, FILE_PRIVKEY);
fd = open_or_die(path, O_RDONLY);
ret = read(fd, secretkey_own, sizeof(secretkey_own));
if (ret != sizeof(secretkey_own)) {
xmemset(secretkey_own, 0, sizeof(secretkey_own));
panic("Cannot read private key!\n");
}
close(fd);
crypto_scalarmult_curve25519_base(publickey_own, secretkey_own);
if (!crypto_verify_32(publickey_own, pubkey_remote)) {
xmemset(secretkey_own, 0, sizeof(secretkey_own));
xmemset(publickey_own, 0, sizeof(publickey_own));
panic("PANIC: remote end has same public key as you have!!!\n");
}
crypto_box_beforenm(p->key, pubkey_remote, secretkey_own);
xmemset(p->enonce, 0, sizeof(p->enonce));
xmemset(p->dnonce, 0, sizeof(p->dnonce));
xmemset(secretkey_own, 0, sizeof(secretkey_own));
xmemset(publickey_own, 0, sizeof(publickey_own));
return 0;
}
static void check_config_keypair_or_die(char *home)
{
int fd, err;
ssize_t ret;
const char * errstr = NULL;
unsigned char publickey[crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES];
unsigned char publicres[crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES];
unsigned char secretkey[crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES];
char path[PATH_MAX];
memset(path, 0, sizeof(path));
slprintf(path, sizeof(path), "%s/%s", home, FILE_PRIVKEY);
fd = open(path, O_RDONLY);
if (fd < 0) {
err = EIO;
errstr = "Cannot open privkey file!\n";
goto out_noclose;
}
ret = read(fd, secretkey, sizeof(secretkey));
if (ret != sizeof(secretkey)) {
err = EIO;
errstr = "Cannot read private key!\n";
goto out;
}
close(fd);
memset(path, 0, sizeof(path));
slprintf(path, sizeof(path), "%s/%s", home, FILE_PUBKEY);
fd = open(path, O_RDONLY);
if (fd < 0) {
err = EIO;
errstr = "Cannot open pubkey file!\n";
goto out_noclose;
}
ret = read(fd, publickey, sizeof(publickey));
if (ret != sizeof(publickey)) {
err = EIO;
errstr = "Cannot read public key!\n";
goto out;
}
crypto_scalarmult_curve25519_base(publicres, secretkey);
err = crypto_verify_32(publicres, publickey);
if (err) {
err = EINVAL;
errstr = "WARNING: your keypair is corrupted!!! You need to "
"generate new keys!!!\n";
goto out;
}
out:
close(fd);
out_noclose:
xmemset(publickey, 0, sizeof(publickey));
xmemset(publicres, 0, sizeof(publicres));
xmemset(secretkey, 0, sizeof(secretkey));
if (err)
panic("%s: %s\n", errstr, strerror(errno));
}
static void create_keypair(char *home)
{
int fd, err = 0;
ssize_t ret;
unsigned char publickey[crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES] = { 0 };
unsigned char secretkey[crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES] = { 0 };
char path[PATH_MAX];
const char * errstr = NULL;
printf("Reading from %s (this may take a while) ...\n", HIG_ENTROPY_SOURCE);
gen_key_bytes(secretkey, sizeof(secretkey));
crypto_scalarmult_curve25519_base(publickey, secretkey);
memset(path, 0, sizeof(path));
slprintf(path, sizeof(path), "%s/%s", home, FILE_PUBKEY);
fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
if (fd < 0) {
err = EIO;
errstr = "Cannot open pubkey file!\n";
goto out_noclose;
}
ret = write(fd, publickey, sizeof(publickey));
if (ret != sizeof(publickey)) {
err = EIO;
errstr = "Cannot write public key!\n";
goto out;
}
close(fd);
printf("Public key written to %s!\n", path);
memset(path, 0, sizeof(path));
slprintf(path, sizeof(path), "%s/%s", home, FILE_PRIVKEY);
fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
if (fd < 0) {
err = EIO;
errstr = "Cannot open privkey file!\n";
goto out_noclose;
}
ret = write(fd, secretkey, sizeof(secretkey));
if (ret != sizeof(secretkey)) {
err = EIO;
errstr = "Cannot write private key!\n";
goto out;
}
out:
close(fd);
out_noclose:
xmemset(publickey, 0, sizeof(publickey));
xmemset(secretkey, 0, sizeof(secretkey));
if (err)
panic("%s: %s", errstr, strerror(errno));
else
printf("Private key written to %s!\n", path);
}
int main()
{
int8_t res;
uint32_t n, m, p, cnt;
uint32_t cclk = CLKPWR_GetCLK(CLKPWR_CLKTYPE_CPU);
uint32_t filesize = 0;
uint32_t time_end;
// SystemInit();
SysTick_Config(cclk/1000 - 1); /* Generate interrupt each 1 ms */
debug_frmwrk_init(); // UART0
xfunc_out = put_char;
xfunc_in = get_char;
xprintf("%s",mciFsMenu);
xprintf("\nMMC/SD Card Filesystem Test (P:LPC1788 L:EFSL)\n");
xprintf("\nCARD init...");
// init file system
if ( ( res = efs_init( &efs, 0 ) ) != 0 ) {
xprintf("failed with %d\n",res);
}
else
{
xprintf("ok\n");
xprintf("Card type: ");
switch (CardConfig.CardType)
{
case MCI_MMC_CARD:
xprintf("MMC\n");
break;
case MCI_SDSC_V1_CARD:
xprintf("Version 1.x Standard Capacity SD card.\n");
break;
case MCI_SDSC_V2_CARD:
xprintf("Version 2.0 or later Standard Capacity SD card.\n");
break;
case MCI_SDHC_SDXC_CARD:
xprintf("Version 2.0 or later High/eXtended Capacity SD card.\n");
break;
default:
break;
}
xprintf("Sector size: %d bytes\n", CardConfig.SectorSize);
xprintf("Sector count: %d\n", CardConfig.SectorCount);
xprintf("Block size: %d sectors\n", CardConfig.BlockSize);
xprintf("Card capacity: %d MByte\n\n", (((CardConfig.SectorCount >> 10) * CardConfig.SectorSize)) >> 10);
xprintf("\nDirectory of 'root':\n");
/* list files in root directory */
ls_openDir( &list, &(efs.myFs) , "/");
while ( ls_getNext( &list ) == 0 ) {
// list.currentEntry is the current file
list.currentEntry.FileName[LIST_MAXLENFILENAME-1] = '\0';
xprintf("%s, 0x%x bytes\n", list.currentEntry.FileName, list.currentEntry.FileSize ) ;
}
#if READ_TEST_ENABLED!=0
/* Read test */
xprintf("\nFile read test:\n");
xprintf("Open file %s ...", FILE_NAME_R);
xmemset(Buff,0,sizeof(Buff));
if (file_fopen( &filer, &efs.myFs , FILE_NAME_R , 'r' ) == 0 )
{
xprintf(" OK. \nReading %lu bytes ...\n", FILE_RW_SIZE);
n=FILE_RW_SIZE;
m = 0;
Timer = 0;
xprintf("File's content:\n");
while (n)
{
if (n>=blen) {cnt = blen; n -= blen;}
else {cnt = n; n = 0;}
p = file_read( &filer, cnt, &Buff[m] );
xprintf("%s",&Buff[m]);
m += p;
if (p != cnt) break;
}
filesize = m;
time_end = Timer;
xprintf("\n%lu bytes read in %lu milisec.\n", m, time_end);
file_fclose( &filer );
} else
{
xprintf (" Failed.\n");
}
#endif
#if WRITE_TEST_ENABLED!=0
/* Write test*/
xprintf("\nFile write test:\n");
xprintf("Open file %s ...", FILE_NAME_W);
if (file_fopen( &filew, &efs.myFs , FILE_NAME_W , 'a' ) == 0 )
{
xprintf(" OK. \nWriting %lu bytes ...\n", filesize);
n=filesize;
m = 0;
Timer = 0;
while (n)
{
if (n>=blen) {
cnt = blen;
n -= blen;
} else {
cnt = n;
n = 0;
}
p = file_write( &filew, cnt, &Buff[m] );
m += p;
if (p != cnt) break;
}
time_end = Timer;
xprintf("%lu bytes written in %lu milisec.\n", m, time_end);
file_fclose( &filew );
} else {
xprintf (" Failed.\n");
}
#endif
#if READ_TEST_ENABLED!=0
/* Read test */
xprintf("\nFile read test:\n");
xprintf("Open file %s ...", FILE_NAME_W);
xmemset(Buff,0,sizeof(Buff));
if (file_fopen( &filer, &efs.myFs , FILE_NAME_W , 'r' ) == 0 )
{
xprintf(" OK. \nReading %lu bytes ...\n", FILE_RW_SIZE);
n=FILE_RW_SIZE;
m = 0;
Timer = 0;
xprintf("File's content:\n");
while (n)
{
if (n>=blen) {cnt = blen; n -= blen;}
else {cnt = n; n = 0;}
p = file_read( &filer, cnt, &Buff[m] );
xprintf("%s",&Buff[m]);
m += p;
if (p != cnt) break;
}
filesize = m;
time_end = Timer;
xprintf("\n%lu bytes read in %lumiliseconds.\n", m, time_end);
file_fclose( &filer );
} else
{
xprintf (" Failed.\n");
}
#endif
/* close file system */
fs_umount( &efs.myFs ) ;
}
xprintf("\nEFSL test complete.\n");
while (1);
}
/*
17.6.1.0780 BLANK
STRING
( c-addr u -- )
If u is greater than zero, store the character value for space in u consecutive character
positions beginning at c-addr.
*/
static void do_blank(void) { cell u = sf_pop(); xmemset((uint8_t *) sf_pop(), ' ', u); }
int main()
{
int8_t res;
uint32_t n, m, p, cnt;
// SystemInit();
SysTick_Config(SystemCoreClock/1000 - 1); /* Generate interrupt each 1 ms */
LPC17xx_UART_Init(115200); // UART0
xfunc_out = LPC17xx_UART_PutChar;
xfunc_in = LPC17xx_UART_GetChar;
xprintf("\nMMC/SD Card Filesystem Test (P:LPC1768 L:EFSL)\n");
xprintf("\nCARD init...");
// init file system
if ( ( res = efs_init( &efs, 0 ) ) != 0 ) {
xprintf("failed with %i\n",res);
}
else
{
xprintf("ok\n");
xprintf("Card type: ");
switch (CardType)
{
case CARDTYPE_MMC:
xprintf("MMC\n");
break;
case CARDTYPE_SDV1:
xprintf("Version 1.x Standard Capacity SD card.\n");
break;
case CARDTYPE_SDV2_SC:
xprintf("Version 2.0 or later Standard Capacity SD card.\n");
break;
case CARDTYPE_SDV2_HC:
xprintf("Version 2.0 or later High/eXtended Capacity SD card.\n");
break;
default:
break;
}
xprintf("Sector size: %d bytes\n", CardConfig.sectorsize);
xprintf("Sector count: %d\n", CardConfig.sectorcnt);
xprintf("Block size: %d sectors\n", CardConfig.blocksize);
xprintf("Card capacity: %d MByte\n\n", (((CardConfig.sectorcnt >> 10) * CardConfig.sectorsize)) >> 10);
xprintf("\nDirectory of 'root':\n");
/* list files in root directory */
ls_openDir( &list, &(efs.myFs) , "/");
while ( ls_getNext( &list ) == 0 ) {
// list.currentEntry is the current file
list.currentEntry.FileName[LIST_MAXLENFILENAME-1] = '\0';
xprintf("%s, 0x%x bytes\n", list.currentEntry.FileName, list.currentEntry.FileSize ) ;
}
#if WRITE_TEST_ENABLED!=0
/* Write test*/
xprintf("\nFile write test:\n");
xprintf("Open file %s ...", FILE_NAME);
if (file_fopen( &filew, &efs.myFs , FILE_NAME , 'a' ) == 0 )
{
xprintf(" OK. \nWriting %lu bytes ...\n", FILE_RW_SIZE);
xmemset(Buff, 0xAA, blen);
n=FILE_RW_SIZE;
m = 0;
Timer = 0;
while (n)
{
if (n>=blen) {
cnt = blen;
n -= blen;
} else {
cnt = n;
n = 0;
}
p = file_write( &filew, cnt, Buff );
m += p;
if (p != cnt) break;
}
xprintf("%lu bytes written with %lu kB/sec.\n", m, Timer ? (m / Timer) : 0);
file_fclose( &filew );
} else {
xprintf (" Failed.\n");
}
#endif
#if READ_TEST_ENABLED!=0
/* Read test */
xprintf("\nFile read test:\n");
xprintf("Open file %s ...", FILE_NAME);
if (file_fopen( &filer, &efs.myFs , FILE_NAME , 'r' ) == 0 )
{
xprintf(" OK. \nReading %lu bytes ...\n", FILE_RW_SIZE);
n=FILE_RW_SIZE;
m = 0;
Timer = 0;
while (n)
{
if (n>=blen) {cnt = blen; n -= blen;}
else {cnt = n; n = 0;}
p = file_read( &filer, cnt, Buff );
m += p;
if (p != cnt) break;
}
xprintf("%lu bytes read with %lu kB/sec.\n", m, Timer ? (m / Timer) : 0);
file_fclose( &filer );
} else
{
xprintf (" Failed.\n");
}
#endif
/* close file system */
fs_umount( &efs.myFs ) ;
}
xprintf("\nEFSL test complete.\n");
while (1);
}
int ConnectHopSocks5Auth(STREAM *S, const char *User, const char *Pass)
{
char *Tempstr=NULL;
const char *p_Password;
char *ptr;
int result, RetVal=FALSE;
uint8_t len, passlen;
Tempstr=SetStrLen(Tempstr, 10);
//socks5 version
Tempstr[0]=5;
//Number of Auth Methods (just 1, username/password)
Tempstr[1]=1;
//Auth method 2, username/password
if (StrValid(User) || StrValid(Pass)) Tempstr[2]=SOCKS5_AUTH_PASSWD;
else Tempstr[2]=SOCKS5_AUTH_NONE;
STREAMWriteBytes(S,Tempstr,3);
STREAMFlush(S);
result=STREAMReadBytes(S,Tempstr,10);
if ((result > 1) && (Tempstr[0]==5))
{
// Second Byte is authentication type selected by the server
switch (Tempstr[1])
{
//no authentication required
case 0:
RetVal=TRUE;
break;
//gssapi
case 1:
break;
//username/password
case 2:
if (Pass)
{
p_Password=Pass;
passlen=strlen(Pass);
}
// must be careful with password len, as it won't be null terminated
else passlen=CredsStoreLookup("", User, &p_Password);
Tempstr=SetStrLen(Tempstr, StrLen(User) + passlen + 10);
ptr=Tempstr;
//version 1 of username/password authentication
*ptr=1;
ptr++;
//username
len=StrLen(User) & 0xFF;
*ptr=len;
ptr++;
memcpy(ptr, User, len);
ptr+=len;
//password
len=passlen & 0xFF;
*ptr=len;
ptr++;
memcpy(ptr, Pass, len);
ptr+=len;
len=ptr-Tempstr;
STREAMWriteBytes(S,Tempstr,len);
//we have to flush to be sure data is sent, but this also wipes output
//data buffer, which is useful given that we just sent a password
STREAMFlush(S);
//As this memory contained a password, we wipe it
xmemset(Tempstr, 0, len);
result=STREAMReadBytes(S,Tempstr,10);
//two bytes reply. Byte1 is Version Byte2 is 0 for success
if ((result > 1) && (Tempstr[0]==1) && (Tempstr[1]==0)) RetVal=TRUE;
break;
}
}
DestroyString(Tempstr);
return(RetVal);
}
